Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * CAN driver for PEAK System PCAN-USB Pro adapter
0004  * Derived from the PCAN project file driver/src/pcan_usbpro.c
0005  *
0006  * Copyright (C) 2003-2011 PEAK System-Technik GmbH
0007  * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
0008  */
0009 #include <linux/netdevice.h>
0010 #include <linux/usb.h>
0011 #include <linux/module.h>
0012 #include <linux/ethtool.h>
0013 
0014 #include <linux/can.h>
0015 #include <linux/can/dev.h>
0016 #include <linux/can/error.h>
0017 
0018 #include "pcan_usb_core.h"
0019 #include "pcan_usb_pro.h"
0020 
0021 #define PCAN_USBPRO_CHANNEL_COUNT   2
0022 
0023 /* PCAN-USB Pro adapter internal clock (MHz) */
0024 #define PCAN_USBPRO_CRYSTAL_HZ      56000000
0025 
0026 /* PCAN-USB Pro command timeout (ms.) */
0027 #define PCAN_USBPRO_COMMAND_TIMEOUT 1000
0028 
0029 /* PCAN-USB Pro rx/tx buffers size */
0030 #define PCAN_USBPRO_RX_BUFFER_SIZE  1024
0031 #define PCAN_USBPRO_TX_BUFFER_SIZE  64
0032 
0033 #define PCAN_USBPRO_MSG_HEADER_LEN  4
0034 
0035 /* some commands responses need to be re-submitted */
0036 #define PCAN_USBPRO_RSP_SUBMIT_MAX  2
0037 
0038 #define PCAN_USBPRO_RTR         0x01
0039 #define PCAN_USBPRO_EXT         0x02
0040 #define PCAN_USBPRO_SS          0x08
0041 
0042 #define PCAN_USBPRO_CMD_BUFFER_SIZE 512
0043 
0044 /* handle device specific info used by the netdevices */
0045 struct pcan_usb_pro_interface {
0046     struct peak_usb_device *dev[PCAN_USBPRO_CHANNEL_COUNT];
0047     struct peak_time_ref time_ref;
0048     int cm_ignore_count;
0049     int dev_opened_count;
0050 };
0051 
0052 /* device information */
0053 struct pcan_usb_pro_device {
0054     struct peak_usb_device dev;
0055     struct pcan_usb_pro_interface *usb_if;
0056     u32 cached_ccbt;
0057 };
0058 
0059 /* internal structure used to handle messages sent to bulk urb */
0060 struct pcan_usb_pro_msg {
0061     u8 *rec_ptr;
0062     int rec_buffer_size;
0063     int rec_buffer_len;
0064     union {
0065         __le16 *rec_cnt_rd;
0066         __le32 *rec_cnt;
0067         u8 *rec_buffer;
0068     } u;
0069 };
0070 
0071 /* records sizes table indexed on message id. (8-bits value) */
0072 static u16 pcan_usb_pro_sizeof_rec[256] = {
0073     [PCAN_USBPRO_SETBTR] = sizeof(struct pcan_usb_pro_btr),
0074     [PCAN_USBPRO_SETBUSACT] = sizeof(struct pcan_usb_pro_busact),
0075     [PCAN_USBPRO_SETSILENT] = sizeof(struct pcan_usb_pro_silent),
0076     [PCAN_USBPRO_SETFILTR] = sizeof(struct pcan_usb_pro_filter),
0077     [PCAN_USBPRO_SETTS] = sizeof(struct pcan_usb_pro_setts),
0078     [PCAN_USBPRO_GETDEVID] = sizeof(struct pcan_usb_pro_devid),
0079     [PCAN_USBPRO_SETLED] = sizeof(struct pcan_usb_pro_setled),
0080     [PCAN_USBPRO_RXMSG8] = sizeof(struct pcan_usb_pro_rxmsg),
0081     [PCAN_USBPRO_RXMSG4] = sizeof(struct pcan_usb_pro_rxmsg) - 4,
0082     [PCAN_USBPRO_RXMSG0] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
0083     [PCAN_USBPRO_RXRTR] = sizeof(struct pcan_usb_pro_rxmsg) - 8,
0084     [PCAN_USBPRO_RXSTATUS] = sizeof(struct pcan_usb_pro_rxstatus),
0085     [PCAN_USBPRO_RXTS] = sizeof(struct pcan_usb_pro_rxts),
0086     [PCAN_USBPRO_TXMSG8] = sizeof(struct pcan_usb_pro_txmsg),
0087     [PCAN_USBPRO_TXMSG4] = sizeof(struct pcan_usb_pro_txmsg) - 4,
0088     [PCAN_USBPRO_TXMSG0] = sizeof(struct pcan_usb_pro_txmsg) - 8,
0089 };
0090 
0091 /*
0092  * initialize PCAN-USB Pro message data structure
0093  */
0094 static u8 *pcan_msg_init(struct pcan_usb_pro_msg *pm, void *buffer_addr,
0095              int buffer_size)
0096 {
0097     if (buffer_size < PCAN_USBPRO_MSG_HEADER_LEN)
0098         return NULL;
0099 
0100     pm->u.rec_buffer = (u8 *)buffer_addr;
0101     pm->rec_buffer_size = pm->rec_buffer_len = buffer_size;
0102     pm->rec_ptr = pm->u.rec_buffer + PCAN_USBPRO_MSG_HEADER_LEN;
0103 
0104     return pm->rec_ptr;
0105 }
0106 
0107 static u8 *pcan_msg_init_empty(struct pcan_usb_pro_msg *pm,
0108                    void *buffer_addr, int buffer_size)
0109 {
0110     u8 *pr = pcan_msg_init(pm, buffer_addr, buffer_size);
0111 
0112     if (pr) {
0113         pm->rec_buffer_len = PCAN_USBPRO_MSG_HEADER_LEN;
0114         *pm->u.rec_cnt = 0;
0115     }
0116     return pr;
0117 }
0118 
0119 /*
0120  * add one record to a message being built
0121  */
0122 static int pcan_msg_add_rec(struct pcan_usb_pro_msg *pm, int id, ...)
0123 {
0124     int len, i;
0125     u8 *pc;
0126     va_list ap;
0127 
0128     va_start(ap, id);
0129 
0130     pc = pm->rec_ptr + 1;
0131 
0132     i = 0;
0133     switch (id) {
0134     case PCAN_USBPRO_TXMSG8:
0135         i += 4;
0136         fallthrough;
0137     case PCAN_USBPRO_TXMSG4:
0138         i += 4;
0139         fallthrough;
0140     case PCAN_USBPRO_TXMSG0:
0141         *pc++ = va_arg(ap, int);
0142         *pc++ = va_arg(ap, int);
0143         *pc++ = va_arg(ap, int);
0144         *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
0145         pc += 4;
0146         memcpy(pc, va_arg(ap, int *), i);
0147         pc += i;
0148         break;
0149 
0150     case PCAN_USBPRO_SETBTR:
0151     case PCAN_USBPRO_GETDEVID:
0152         *pc++ = va_arg(ap, int);
0153         pc += 2;
0154         *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
0155         pc += 4;
0156         break;
0157 
0158     case PCAN_USBPRO_SETFILTR:
0159     case PCAN_USBPRO_SETBUSACT:
0160     case PCAN_USBPRO_SETSILENT:
0161         *pc++ = va_arg(ap, int);
0162         *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
0163         pc += 2;
0164         break;
0165 
0166     case PCAN_USBPRO_SETLED:
0167         *pc++ = va_arg(ap, int);
0168         *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
0169         pc += 2;
0170         *(__le32 *)pc = cpu_to_le32(va_arg(ap, u32));
0171         pc += 4;
0172         break;
0173 
0174     case PCAN_USBPRO_SETTS:
0175         pc++;
0176         *(__le16 *)pc = cpu_to_le16(va_arg(ap, int));
0177         pc += 2;
0178         break;
0179 
0180     default:
0181         pr_err("%s: %s(): unknown data type %02Xh (%d)\n",
0182             PCAN_USB_DRIVER_NAME, __func__, id, id);
0183         pc--;
0184         break;
0185     }
0186 
0187     len = pc - pm->rec_ptr;
0188     if (len > 0) {
0189         le32_add_cpu(pm->u.rec_cnt, 1);
0190         *pm->rec_ptr = id;
0191 
0192         pm->rec_ptr = pc;
0193         pm->rec_buffer_len += len;
0194     }
0195 
0196     va_end(ap);
0197 
0198     return len;
0199 }
0200 
0201 /*
0202  * send PCAN-USB Pro command synchronously
0203  */
0204 static int pcan_usb_pro_send_cmd(struct peak_usb_device *dev,
0205                  struct pcan_usb_pro_msg *pum)
0206 {
0207     int actual_length;
0208     int err;
0209 
0210     /* usb device unregistered? */
0211     if (!(dev->state & PCAN_USB_STATE_CONNECTED))
0212         return 0;
0213 
0214     err = usb_bulk_msg(dev->udev,
0215         usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
0216         pum->u.rec_buffer, pum->rec_buffer_len,
0217         &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
0218     if (err)
0219         netdev_err(dev->netdev, "sending command failure: %d\n", err);
0220 
0221     return err;
0222 }
0223 
0224 /*
0225  * wait for PCAN-USB Pro command response
0226  */
0227 static int pcan_usb_pro_wait_rsp(struct peak_usb_device *dev,
0228                  struct pcan_usb_pro_msg *pum)
0229 {
0230     u8 req_data_type, req_channel;
0231     int actual_length;
0232     int i, err = 0;
0233 
0234     /* usb device unregistered? */
0235     if (!(dev->state & PCAN_USB_STATE_CONNECTED))
0236         return 0;
0237 
0238     req_data_type = pum->u.rec_buffer[4];
0239     req_channel = pum->u.rec_buffer[5];
0240 
0241     *pum->u.rec_cnt = 0;
0242     for (i = 0; !err && i < PCAN_USBPRO_RSP_SUBMIT_MAX; i++) {
0243         struct pcan_usb_pro_msg rsp;
0244         union pcan_usb_pro_rec *pr;
0245         u32 r, rec_cnt;
0246         u16 rec_len;
0247         u8 *pc;
0248 
0249         err = usb_bulk_msg(dev->udev,
0250             usb_rcvbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDIN),
0251             pum->u.rec_buffer, pum->rec_buffer_len,
0252             &actual_length, PCAN_USBPRO_COMMAND_TIMEOUT);
0253         if (err) {
0254             netdev_err(dev->netdev, "waiting rsp error %d\n", err);
0255             break;
0256         }
0257 
0258         if (actual_length == 0)
0259             continue;
0260 
0261         err = -EBADMSG;
0262         if (actual_length < PCAN_USBPRO_MSG_HEADER_LEN) {
0263             netdev_err(dev->netdev,
0264                    "got abnormal too small rsp (len=%d)\n",
0265                    actual_length);
0266             break;
0267         }
0268 
0269         pc = pcan_msg_init(&rsp, pum->u.rec_buffer,
0270             actual_length);
0271 
0272         rec_cnt = le32_to_cpu(*rsp.u.rec_cnt);
0273 
0274         /* loop on records stored into message */
0275         for (r = 0; r < rec_cnt; r++) {
0276             pr = (union pcan_usb_pro_rec *)pc;
0277             rec_len = pcan_usb_pro_sizeof_rec[pr->data_type];
0278             if (!rec_len) {
0279                 netdev_err(dev->netdev,
0280                        "got unprocessed record in msg\n");
0281                 pcan_dump_mem("rcvd rsp msg", pum->u.rec_buffer,
0282                           actual_length);
0283                 break;
0284             }
0285 
0286             /* check if response corresponds to request */
0287             if (pr->data_type != req_data_type)
0288                 netdev_err(dev->netdev,
0289                        "got unwanted rsp %xh: ignored\n",
0290                        pr->data_type);
0291 
0292             /* check if channel in response corresponds too */
0293             else if ((req_channel != 0xff) &&
0294                 (pr->bus_act.channel != req_channel))
0295                 netdev_err(dev->netdev,
0296                     "got rsp %xh but on chan%u: ignored\n",
0297                     req_data_type, pr->bus_act.channel);
0298 
0299             /* got the response */
0300             else
0301                 return 0;
0302 
0303             /* otherwise, go on with next record in message */
0304             pc += rec_len;
0305         }
0306     }
0307 
0308     return (i >= PCAN_USBPRO_RSP_SUBMIT_MAX) ? -ERANGE : err;
0309 }
0310 
0311 int pcan_usb_pro_send_req(struct peak_usb_device *dev, int req_id,
0312               int req_value, void *req_addr, int req_size)
0313 {
0314     int err;
0315     u8 req_type;
0316     unsigned int p;
0317 
0318     /* usb device unregistered? */
0319     if (!(dev->state & PCAN_USB_STATE_CONNECTED))
0320         return 0;
0321 
0322     req_type = USB_TYPE_VENDOR | USB_RECIP_OTHER;
0323 
0324     switch (req_id) {
0325     case PCAN_USBPRO_REQ_FCT:
0326         p = usb_sndctrlpipe(dev->udev, 0);
0327         break;
0328 
0329     default:
0330         p = usb_rcvctrlpipe(dev->udev, 0);
0331         req_type |= USB_DIR_IN;
0332         memset(req_addr, '\0', req_size);
0333         break;
0334     }
0335 
0336     err = usb_control_msg(dev->udev, p, req_id, req_type, req_value, 0,
0337                   req_addr, req_size, 2 * USB_CTRL_GET_TIMEOUT);
0338     if (err < 0) {
0339         netdev_info(dev->netdev,
0340                 "unable to request usb[type=%d value=%d] err=%d\n",
0341                 req_id, req_value, err);
0342         return err;
0343     }
0344 
0345     return 0;
0346 }
0347 
0348 static int pcan_usb_pro_set_ts(struct peak_usb_device *dev, u16 onoff)
0349 {
0350     struct pcan_usb_pro_msg um;
0351 
0352     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0353     pcan_msg_add_rec(&um, PCAN_USBPRO_SETTS, onoff);
0354 
0355     return pcan_usb_pro_send_cmd(dev, &um);
0356 }
0357 
0358 static int pcan_usb_pro_set_bitrate(struct peak_usb_device *dev, u32 ccbt)
0359 {
0360     struct pcan_usb_pro_device *pdev =
0361             container_of(dev, struct pcan_usb_pro_device, dev);
0362     struct pcan_usb_pro_msg um;
0363 
0364     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0365     pcan_msg_add_rec(&um, PCAN_USBPRO_SETBTR, dev->ctrl_idx, ccbt);
0366 
0367     /* cache the CCBT value to reuse it before next buson */
0368     pdev->cached_ccbt = ccbt;
0369 
0370     return pcan_usb_pro_send_cmd(dev, &um);
0371 }
0372 
0373 static int pcan_usb_pro_set_bus(struct peak_usb_device *dev, u8 onoff)
0374 {
0375     struct pcan_usb_pro_msg um;
0376 
0377     /* if bus=on, be sure the bitrate being set before! */
0378     if (onoff) {
0379         struct pcan_usb_pro_device *pdev =
0380                  container_of(dev, struct pcan_usb_pro_device, dev);
0381 
0382         pcan_usb_pro_set_bitrate(dev, pdev->cached_ccbt);
0383     }
0384 
0385     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0386     pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, onoff);
0387 
0388     return pcan_usb_pro_send_cmd(dev, &um);
0389 }
0390 
0391 static int pcan_usb_pro_set_silent(struct peak_usb_device *dev, u8 onoff)
0392 {
0393     struct pcan_usb_pro_msg um;
0394 
0395     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0396     pcan_msg_add_rec(&um, PCAN_USBPRO_SETSILENT, dev->ctrl_idx, onoff);
0397 
0398     return pcan_usb_pro_send_cmd(dev, &um);
0399 }
0400 
0401 static int pcan_usb_pro_set_filter(struct peak_usb_device *dev, u16 filter_mode)
0402 {
0403     struct pcan_usb_pro_msg um;
0404 
0405     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0406     pcan_msg_add_rec(&um, PCAN_USBPRO_SETFILTR, dev->ctrl_idx, filter_mode);
0407 
0408     return pcan_usb_pro_send_cmd(dev, &um);
0409 }
0410 
0411 static int pcan_usb_pro_set_led(struct peak_usb_device *dev, u8 mode,
0412                 u32 timeout)
0413 {
0414     struct pcan_usb_pro_msg um;
0415 
0416     pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0417     pcan_msg_add_rec(&um, PCAN_USBPRO_SETLED, dev->ctrl_idx, mode, timeout);
0418 
0419     return pcan_usb_pro_send_cmd(dev, &um);
0420 }
0421 
0422 static int pcan_usb_pro_get_device_id(struct peak_usb_device *dev,
0423                       u32 *device_id)
0424 {
0425     struct pcan_usb_pro_devid *pdn;
0426     struct pcan_usb_pro_msg um;
0427     int err;
0428     u8 *pc;
0429 
0430     pc = pcan_msg_init_empty(&um, dev->cmd_buf, PCAN_USB_MAX_CMD_LEN);
0431     pcan_msg_add_rec(&um, PCAN_USBPRO_GETDEVID, dev->ctrl_idx);
0432 
0433     err =  pcan_usb_pro_send_cmd(dev, &um);
0434     if (err)
0435         return err;
0436 
0437     err = pcan_usb_pro_wait_rsp(dev, &um);
0438     if (err)
0439         return err;
0440 
0441     pdn = (struct pcan_usb_pro_devid *)pc;
0442     *device_id = le32_to_cpu(pdn->dev_num);
0443 
0444     return err;
0445 }
0446 
0447 static int pcan_usb_pro_set_bittiming(struct peak_usb_device *dev,
0448                       struct can_bittiming *bt)
0449 {
0450     u32 ccbt;
0451 
0452     ccbt = (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) ? 0x00800000 : 0;
0453     ccbt |= (bt->sjw - 1) << 24;
0454     ccbt |= (bt->phase_seg2 - 1) << 20;
0455     ccbt |= (bt->prop_seg + bt->phase_seg1 - 1) << 16; /* = tseg1 */
0456     ccbt |= bt->brp - 1;
0457 
0458     netdev_info(dev->netdev, "setting ccbt=0x%08x\n", ccbt);
0459 
0460     return pcan_usb_pro_set_bitrate(dev, ccbt);
0461 }
0462 
0463 void pcan_usb_pro_restart_complete(struct urb *urb)
0464 {
0465     /* can delete usb resources */
0466     peak_usb_async_complete(urb);
0467 
0468     /* notify candev and netdev */
0469     peak_usb_restart_complete(urb->context);
0470 }
0471 
0472 /*
0473  * handle restart but in asynchronously way
0474  */
0475 static int pcan_usb_pro_restart_async(struct peak_usb_device *dev,
0476                       struct urb *urb, u8 *buf)
0477 {
0478     struct pcan_usb_pro_msg um;
0479 
0480     pcan_msg_init_empty(&um, buf, PCAN_USB_MAX_CMD_LEN);
0481     pcan_msg_add_rec(&um, PCAN_USBPRO_SETBUSACT, dev->ctrl_idx, 1);
0482 
0483     usb_fill_bulk_urb(urb, dev->udev,
0484             usb_sndbulkpipe(dev->udev, PCAN_USBPRO_EP_CMDOUT),
0485             buf, PCAN_USB_MAX_CMD_LEN,
0486             pcan_usb_pro_restart_complete, dev);
0487 
0488     return usb_submit_urb(urb, GFP_ATOMIC);
0489 }
0490 
0491 static int pcan_usb_pro_drv_loaded(struct peak_usb_device *dev, int loaded)
0492 {
0493     u8 *buffer;
0494     int err;
0495 
0496     buffer = kzalloc(PCAN_USBPRO_FCT_DRVLD_REQ_LEN, GFP_KERNEL);
0497     if (!buffer)
0498         return -ENOMEM;
0499 
0500     buffer[0] = 0;
0501     buffer[1] = !!loaded;
0502 
0503     err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_FCT,
0504                     PCAN_USBPRO_FCT_DRVLD, buffer,
0505                     PCAN_USBPRO_FCT_DRVLD_REQ_LEN);
0506     kfree(buffer);
0507 
0508     return err;
0509 }
0510 
0511 static inline
0512 struct pcan_usb_pro_interface *pcan_usb_pro_dev_if(struct peak_usb_device *dev)
0513 {
0514     struct pcan_usb_pro_device *pdev =
0515             container_of(dev, struct pcan_usb_pro_device, dev);
0516     return pdev->usb_if;
0517 }
0518 
0519 static int pcan_usb_pro_handle_canmsg(struct pcan_usb_pro_interface *usb_if,
0520                       struct pcan_usb_pro_rxmsg *rx)
0521 {
0522     const unsigned int ctrl_idx = (rx->len >> 4) & 0x0f;
0523     struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
0524     struct net_device *netdev = dev->netdev;
0525     struct can_frame *can_frame;
0526     struct sk_buff *skb;
0527     struct skb_shared_hwtstamps *hwts;
0528 
0529     skb = alloc_can_skb(netdev, &can_frame);
0530     if (!skb)
0531         return -ENOMEM;
0532 
0533     can_frame->can_id = le32_to_cpu(rx->id);
0534     can_frame->len = rx->len & 0x0f;
0535 
0536     if (rx->flags & PCAN_USBPRO_EXT)
0537         can_frame->can_id |= CAN_EFF_FLAG;
0538 
0539     if (rx->flags & PCAN_USBPRO_RTR) {
0540         can_frame->can_id |= CAN_RTR_FLAG;
0541     } else {
0542         memcpy(can_frame->data, rx->data, can_frame->len);
0543 
0544         netdev->stats.rx_bytes += can_frame->len;
0545     }
0546     netdev->stats.rx_packets++;
0547 
0548     hwts = skb_hwtstamps(skb);
0549     peak_usb_get_ts_time(&usb_if->time_ref, le32_to_cpu(rx->ts32),
0550                  &hwts->hwtstamp);
0551 
0552     netif_rx(skb);
0553 
0554     return 0;
0555 }
0556 
0557 static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if,
0558                      struct pcan_usb_pro_rxstatus *er)
0559 {
0560     const u16 raw_status = le16_to_cpu(er->status);
0561     const unsigned int ctrl_idx = (er->channel >> 4) & 0x0f;
0562     struct peak_usb_device *dev = usb_if->dev[ctrl_idx];
0563     struct net_device *netdev = dev->netdev;
0564     struct can_frame *can_frame;
0565     enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
0566     u8 err_mask = 0;
0567     struct sk_buff *skb;
0568     struct skb_shared_hwtstamps *hwts;
0569 
0570     /* nothing should be sent while in BUS_OFF state */
0571     if (dev->can.state == CAN_STATE_BUS_OFF)
0572         return 0;
0573 
0574     if (!raw_status) {
0575         /* no error bit (back to active state) */
0576         dev->can.state = CAN_STATE_ERROR_ACTIVE;
0577         return 0;
0578     }
0579 
0580     if (raw_status & (PCAN_USBPRO_STATUS_OVERRUN |
0581               PCAN_USBPRO_STATUS_QOVERRUN)) {
0582         /* trick to bypass next comparison and process other errors */
0583         new_state = CAN_STATE_MAX;
0584     }
0585 
0586     if (raw_status & PCAN_USBPRO_STATUS_BUS) {
0587         new_state = CAN_STATE_BUS_OFF;
0588     } else if (raw_status & PCAN_USBPRO_STATUS_ERROR) {
0589         u32 rx_err_cnt = (le32_to_cpu(er->err_frm) & 0x00ff0000) >> 16;
0590         u32 tx_err_cnt = (le32_to_cpu(er->err_frm) & 0xff000000) >> 24;
0591 
0592         if (rx_err_cnt > 127)
0593             err_mask |= CAN_ERR_CRTL_RX_PASSIVE;
0594         else if (rx_err_cnt > 96)
0595             err_mask |= CAN_ERR_CRTL_RX_WARNING;
0596 
0597         if (tx_err_cnt > 127)
0598             err_mask |= CAN_ERR_CRTL_TX_PASSIVE;
0599         else if (tx_err_cnt > 96)
0600             err_mask |= CAN_ERR_CRTL_TX_WARNING;
0601 
0602         if (err_mask & (CAN_ERR_CRTL_RX_WARNING |
0603                 CAN_ERR_CRTL_TX_WARNING))
0604             new_state = CAN_STATE_ERROR_WARNING;
0605         else if (err_mask & (CAN_ERR_CRTL_RX_PASSIVE |
0606                      CAN_ERR_CRTL_TX_PASSIVE))
0607             new_state = CAN_STATE_ERROR_PASSIVE;
0608     }
0609 
0610     /* donot post any error if current state didn't change */
0611     if (dev->can.state == new_state)
0612         return 0;
0613 
0614     /* allocate an skb to store the error frame */
0615     skb = alloc_can_err_skb(netdev, &can_frame);
0616     if (!skb)
0617         return -ENOMEM;
0618 
0619     switch (new_state) {
0620     case CAN_STATE_BUS_OFF:
0621         can_frame->can_id |= CAN_ERR_BUSOFF;
0622         dev->can.can_stats.bus_off++;
0623         can_bus_off(netdev);
0624         break;
0625 
0626     case CAN_STATE_ERROR_PASSIVE:
0627         can_frame->can_id |= CAN_ERR_CRTL;
0628         can_frame->data[1] |= err_mask;
0629         dev->can.can_stats.error_passive++;
0630         break;
0631 
0632     case CAN_STATE_ERROR_WARNING:
0633         can_frame->can_id |= CAN_ERR_CRTL;
0634         can_frame->data[1] |= err_mask;
0635         dev->can.can_stats.error_warning++;
0636         break;
0637 
0638     case CAN_STATE_ERROR_ACTIVE:
0639         break;
0640 
0641     default:
0642         /* CAN_STATE_MAX (trick to handle other errors) */
0643         if (raw_status & PCAN_USBPRO_STATUS_OVERRUN) {
0644             can_frame->can_id |= CAN_ERR_PROT;
0645             can_frame->data[2] |= CAN_ERR_PROT_OVERLOAD;
0646             netdev->stats.rx_over_errors++;
0647             netdev->stats.rx_errors++;
0648         }
0649 
0650         if (raw_status & PCAN_USBPRO_STATUS_QOVERRUN) {
0651             can_frame->can_id |= CAN_ERR_CRTL;
0652             can_frame->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
0653             netdev->stats.rx_over_errors++;
0654             netdev->stats.rx_errors++;
0655         }
0656 
0657         new_state = CAN_STATE_ERROR_ACTIVE;
0658         break;
0659     }
0660 
0661     dev->can.state = new_state;
0662 
0663     hwts = skb_hwtstamps(skb);
0664     peak_usb_get_ts_time(&usb_if->time_ref, le32_to_cpu(er->ts32), &hwts->hwtstamp);
0665     netif_rx(skb);
0666 
0667     return 0;
0668 }
0669 
0670 static void pcan_usb_pro_handle_ts(struct pcan_usb_pro_interface *usb_if,
0671                    struct pcan_usb_pro_rxts *ts)
0672 {
0673     /* should wait until clock is stabilized */
0674     if (usb_if->cm_ignore_count > 0)
0675         usb_if->cm_ignore_count--;
0676     else
0677         peak_usb_set_ts_now(&usb_if->time_ref,
0678                     le32_to_cpu(ts->ts64[1]));
0679 }
0680 
0681 /*
0682  * callback for bulk IN urb
0683  */
0684 static int pcan_usb_pro_decode_buf(struct peak_usb_device *dev, struct urb *urb)
0685 {
0686     struct pcan_usb_pro_interface *usb_if = pcan_usb_pro_dev_if(dev);
0687     struct net_device *netdev = dev->netdev;
0688     struct pcan_usb_pro_msg usb_msg;
0689     u8 *rec_ptr, *msg_end;
0690     u16 rec_cnt;
0691     int err = 0;
0692 
0693     rec_ptr = pcan_msg_init(&usb_msg, urb->transfer_buffer,
0694                     urb->actual_length);
0695     if (!rec_ptr) {
0696         netdev_err(netdev, "bad msg hdr len %d\n", urb->actual_length);
0697         return -EINVAL;
0698     }
0699 
0700     /* loop reading all the records from the incoming message */
0701     msg_end = urb->transfer_buffer + urb->actual_length;
0702     rec_cnt = le16_to_cpu(*usb_msg.u.rec_cnt_rd);
0703     for (; rec_cnt > 0; rec_cnt--) {
0704         union pcan_usb_pro_rec *pr = (union pcan_usb_pro_rec *)rec_ptr;
0705         u16 sizeof_rec = pcan_usb_pro_sizeof_rec[pr->data_type];
0706 
0707         if (!sizeof_rec) {
0708             netdev_err(netdev,
0709                    "got unsupported rec in usb msg:\n");
0710             err = -ENOTSUPP;
0711             break;
0712         }
0713 
0714         /* check if the record goes out of current packet */
0715         if (rec_ptr + sizeof_rec > msg_end) {
0716             netdev_err(netdev,
0717                 "got frag rec: should inc usb rx buf size\n");
0718             err = -EBADMSG;
0719             break;
0720         }
0721 
0722         switch (pr->data_type) {
0723         case PCAN_USBPRO_RXMSG8:
0724         case PCAN_USBPRO_RXMSG4:
0725         case PCAN_USBPRO_RXMSG0:
0726         case PCAN_USBPRO_RXRTR:
0727             err = pcan_usb_pro_handle_canmsg(usb_if, &pr->rx_msg);
0728             if (err < 0)
0729                 goto fail;
0730             break;
0731 
0732         case PCAN_USBPRO_RXSTATUS:
0733             err = pcan_usb_pro_handle_error(usb_if, &pr->rx_status);
0734             if (err < 0)
0735                 goto fail;
0736             break;
0737 
0738         case PCAN_USBPRO_RXTS:
0739             pcan_usb_pro_handle_ts(usb_if, &pr->rx_ts);
0740             break;
0741 
0742         default:
0743             netdev_err(netdev,
0744                    "unhandled rec type 0x%02x (%d): ignored\n",
0745                    pr->data_type, pr->data_type);
0746             break;
0747         }
0748 
0749         rec_ptr += sizeof_rec;
0750     }
0751 
0752 fail:
0753     if (err)
0754         pcan_dump_mem("received msg",
0755                   urb->transfer_buffer, urb->actual_length);
0756 
0757     return err;
0758 }
0759 
0760 static int pcan_usb_pro_encode_msg(struct peak_usb_device *dev,
0761                    struct sk_buff *skb, u8 *obuf, size_t *size)
0762 {
0763     struct can_frame *cf = (struct can_frame *)skb->data;
0764     u8 data_type, len, flags;
0765     struct pcan_usb_pro_msg usb_msg;
0766 
0767     pcan_msg_init_empty(&usb_msg, obuf, *size);
0768 
0769     if ((cf->can_id & CAN_RTR_FLAG) || (cf->len == 0))
0770         data_type = PCAN_USBPRO_TXMSG0;
0771     else if (cf->len <= 4)
0772         data_type = PCAN_USBPRO_TXMSG4;
0773     else
0774         data_type = PCAN_USBPRO_TXMSG8;
0775 
0776     len = (dev->ctrl_idx << 4) | (cf->len & 0x0f);
0777 
0778     flags = 0;
0779     if (cf->can_id & CAN_EFF_FLAG)
0780         flags |= PCAN_USBPRO_EXT;
0781     if (cf->can_id & CAN_RTR_FLAG)
0782         flags |= PCAN_USBPRO_RTR;
0783 
0784     /* Single-Shot frame */
0785     if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
0786         flags |= PCAN_USBPRO_SS;
0787 
0788     pcan_msg_add_rec(&usb_msg, data_type, 0, flags, len, cf->can_id,
0789              cf->data);
0790 
0791     *size = usb_msg.rec_buffer_len;
0792 
0793     return 0;
0794 }
0795 
0796 static int pcan_usb_pro_start(struct peak_usb_device *dev)
0797 {
0798     struct pcan_usb_pro_device *pdev =
0799             container_of(dev, struct pcan_usb_pro_device, dev);
0800     int err;
0801 
0802     err = pcan_usb_pro_set_silent(dev,
0803                 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
0804     if (err)
0805         return err;
0806 
0807     /* filter mode: 0-> All OFF; 1->bypass */
0808     err = pcan_usb_pro_set_filter(dev, 1);
0809     if (err)
0810         return err;
0811 
0812     /* opening first device: */
0813     if (pdev->usb_if->dev_opened_count == 0) {
0814         /* reset time_ref */
0815         peak_usb_init_time_ref(&pdev->usb_if->time_ref, &pcan_usb_pro);
0816 
0817         /* ask device to send ts messages */
0818         err = pcan_usb_pro_set_ts(dev, 1);
0819     }
0820 
0821     pdev->usb_if->dev_opened_count++;
0822 
0823     return err;
0824 }
0825 
0826 /*
0827  * stop interface
0828  * (last chance before set bus off)
0829  */
0830 static int pcan_usb_pro_stop(struct peak_usb_device *dev)
0831 {
0832     struct pcan_usb_pro_device *pdev =
0833             container_of(dev, struct pcan_usb_pro_device, dev);
0834 
0835     /* turn off ts msgs for that interface if no other dev opened */
0836     if (pdev->usb_if->dev_opened_count == 1)
0837         pcan_usb_pro_set_ts(dev, 0);
0838 
0839     pdev->usb_if->dev_opened_count--;
0840 
0841     return 0;
0842 }
0843 
0844 /*
0845  * called when probing to initialize a device object.
0846  */
0847 static int pcan_usb_pro_init(struct peak_usb_device *dev)
0848 {
0849     struct pcan_usb_pro_device *pdev =
0850             container_of(dev, struct pcan_usb_pro_device, dev);
0851     struct pcan_usb_pro_interface *usb_if = NULL;
0852     struct pcan_usb_pro_fwinfo *fi = NULL;
0853     struct pcan_usb_pro_blinfo *bi = NULL;
0854     int err;
0855 
0856     /* do this for 1st channel only */
0857     if (!dev->prev_siblings) {
0858         /* allocate netdevices common structure attached to first one */
0859         usb_if = kzalloc(sizeof(struct pcan_usb_pro_interface),
0860                  GFP_KERNEL);
0861         fi = kmalloc(sizeof(struct pcan_usb_pro_fwinfo), GFP_KERNEL);
0862         bi = kmalloc(sizeof(struct pcan_usb_pro_blinfo), GFP_KERNEL);
0863         if (!usb_if || !fi || !bi) {
0864             err = -ENOMEM;
0865             goto err_out;
0866         }
0867 
0868         /* number of ts msgs to ignore before taking one into account */
0869         usb_if->cm_ignore_count = 5;
0870 
0871         /*
0872          * explicit use of dev_xxx() instead of netdev_xxx() here:
0873          * information displayed are related to the device itself, not
0874          * to the canx netdevices.
0875          */
0876         err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
0877                         PCAN_USBPRO_INFO_FW,
0878                         fi, sizeof(*fi));
0879         if (err) {
0880             dev_err(dev->netdev->dev.parent,
0881                 "unable to read %s firmware info (err %d)\n",
0882                 pcan_usb_pro.name, err);
0883             goto err_out;
0884         }
0885 
0886         err = pcan_usb_pro_send_req(dev, PCAN_USBPRO_REQ_INFO,
0887                         PCAN_USBPRO_INFO_BL,
0888                         bi, sizeof(*bi));
0889         if (err) {
0890             dev_err(dev->netdev->dev.parent,
0891                 "unable to read %s bootloader info (err %d)\n",
0892                 pcan_usb_pro.name, err);
0893             goto err_out;
0894         }
0895 
0896         /* tell the device the can driver is running */
0897         err = pcan_usb_pro_drv_loaded(dev, 1);
0898         if (err)
0899             goto err_out;
0900 
0901         dev_info(dev->netdev->dev.parent,
0902              "PEAK-System %s hwrev %u serial %08X.%08X (%u channels)\n",
0903              pcan_usb_pro.name,
0904              bi->hw_rev, bi->serial_num_hi, bi->serial_num_lo,
0905              pcan_usb_pro.ctrl_count);
0906     } else {
0907         usb_if = pcan_usb_pro_dev_if(dev->prev_siblings);
0908     }
0909 
0910     pdev->usb_if = usb_if;
0911     usb_if->dev[dev->ctrl_idx] = dev;
0912 
0913     /* set LED in default state (end of init phase) */
0914     pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_DEVICE, 1);
0915 
0916     kfree(bi);
0917     kfree(fi);
0918 
0919     return 0;
0920 
0921  err_out:
0922     kfree(bi);
0923     kfree(fi);
0924     kfree(usb_if);
0925 
0926     return err;
0927 }
0928 
0929 static void pcan_usb_pro_exit(struct peak_usb_device *dev)
0930 {
0931     struct pcan_usb_pro_device *pdev =
0932             container_of(dev, struct pcan_usb_pro_device, dev);
0933 
0934     /*
0935      * when rmmod called before unplug and if down, should reset things
0936      * before leaving
0937      */
0938     if (dev->can.state != CAN_STATE_STOPPED) {
0939         /* set bus off on the corresponding channel */
0940         pcan_usb_pro_set_bus(dev, 0);
0941     }
0942 
0943     /* if channel #0 (only) */
0944     if (dev->ctrl_idx == 0) {
0945         /* turn off calibration message if any device were opened */
0946         if (pdev->usb_if->dev_opened_count > 0)
0947             pcan_usb_pro_set_ts(dev, 0);
0948 
0949         /* tell the PCAN-USB Pro device the driver is being unloaded */
0950         pcan_usb_pro_drv_loaded(dev, 0);
0951     }
0952 }
0953 
0954 /*
0955  * called when PCAN-USB Pro adapter is unplugged
0956  */
0957 static void pcan_usb_pro_free(struct peak_usb_device *dev)
0958 {
0959     /* last device: can free pcan_usb_pro_interface object now */
0960     if (!dev->prev_siblings && !dev->next_siblings)
0961         kfree(pcan_usb_pro_dev_if(dev));
0962 }
0963 
0964 /*
0965  * probe function for new PCAN-USB Pro usb interface
0966  */
0967 int pcan_usb_pro_probe(struct usb_interface *intf)
0968 {
0969     struct usb_host_interface *if_desc;
0970     int i;
0971 
0972     if_desc = intf->altsetting;
0973 
0974     /* check interface endpoint addresses */
0975     for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
0976         struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
0977 
0978         /*
0979          * below is the list of valid ep addresses. Any other ep address
0980          * is considered as not-CAN interface address => no dev created
0981          */
0982         switch (ep->bEndpointAddress) {
0983         case PCAN_USBPRO_EP_CMDOUT:
0984         case PCAN_USBPRO_EP_CMDIN:
0985         case PCAN_USBPRO_EP_MSGOUT_0:
0986         case PCAN_USBPRO_EP_MSGOUT_1:
0987         case PCAN_USBPRO_EP_MSGIN:
0988         case PCAN_USBPRO_EP_UNUSED:
0989             break;
0990         default:
0991             return -ENODEV;
0992         }
0993     }
0994 
0995     return 0;
0996 }
0997 
0998 static int pcan_usb_pro_set_phys_id(struct net_device *netdev,
0999                     enum ethtool_phys_id_state state)
1000 {
1001     struct peak_usb_device *dev = netdev_priv(netdev);
1002     int err = 0;
1003 
1004     switch (state) {
1005     case ETHTOOL_ID_ACTIVE:
1006         /* fast blinking forever */
1007         err = pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_BLINK_FAST,
1008                        0xffffffff);
1009         break;
1010 
1011     case ETHTOOL_ID_INACTIVE:
1012         /* restore LED default */
1013         err = pcan_usb_pro_set_led(dev, PCAN_USBPRO_LED_DEVICE, 1);
1014         break;
1015 
1016     default:
1017         break;
1018     }
1019 
1020     return err;
1021 }
1022 
1023 static const struct ethtool_ops pcan_usb_pro_ethtool_ops = {
1024     .set_phys_id = pcan_usb_pro_set_phys_id,
1025     .get_ts_info = pcan_get_ts_info,
1026 };
1027 
1028 /*
1029  * describe the PCAN-USB Pro adapter
1030  */
1031 static const struct can_bittiming_const pcan_usb_pro_const = {
1032     .name = "pcan_usb_pro",
1033     .tseg1_min = 1,
1034     .tseg1_max = 16,
1035     .tseg2_min = 1,
1036     .tseg2_max = 8,
1037     .sjw_max = 4,
1038     .brp_min = 1,
1039     .brp_max = 1024,
1040     .brp_inc = 1,
1041 };
1042 
1043 const struct peak_usb_adapter pcan_usb_pro = {
1044     .name = "PCAN-USB Pro",
1045     .device_id = PCAN_USBPRO_PRODUCT_ID,
1046     .ctrl_count = PCAN_USBPRO_CHANNEL_COUNT,
1047     .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY |
1048                   CAN_CTRLMODE_ONE_SHOT,
1049     .clock = {
1050         .freq = PCAN_USBPRO_CRYSTAL_HZ,
1051     },
1052     .bittiming_const = &pcan_usb_pro_const,
1053 
1054     /* size of device private data */
1055     .sizeof_dev_private = sizeof(struct pcan_usb_pro_device),
1056 
1057     .ethtool_ops = &pcan_usb_pro_ethtool_ops,
1058 
1059     /* timestamps usage */
1060     .ts_used_bits = 32,
1061     .us_per_ts_scale = 1, /* us = (ts * scale) >> shift */
1062     .us_per_ts_shift = 0,
1063 
1064     /* give here messages in/out endpoints */
1065     .ep_msg_in = PCAN_USBPRO_EP_MSGIN,
1066     .ep_msg_out = {PCAN_USBPRO_EP_MSGOUT_0, PCAN_USBPRO_EP_MSGOUT_1},
1067 
1068     /* size of rx/tx usb buffers */
1069     .rx_buffer_size = PCAN_USBPRO_RX_BUFFER_SIZE,
1070     .tx_buffer_size = PCAN_USBPRO_TX_BUFFER_SIZE,
1071 
1072     /* device callbacks */
1073     .intf_probe = pcan_usb_pro_probe,
1074     .dev_init = pcan_usb_pro_init,
1075     .dev_exit = pcan_usb_pro_exit,
1076     .dev_free = pcan_usb_pro_free,
1077     .dev_set_bus = pcan_usb_pro_set_bus,
1078     .dev_set_bittiming = pcan_usb_pro_set_bittiming,
1079     .dev_get_device_id = pcan_usb_pro_get_device_id,
1080     .dev_decode_buf = pcan_usb_pro_decode_buf,
1081     .dev_encode_msg = pcan_usb_pro_encode_msg,
1082     .dev_start = pcan_usb_pro_start,
1083     .dev_stop = pcan_usb_pro_stop,
1084     .dev_restart_async = pcan_usb_pro_restart_async,
1085 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!