1057 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * CAN driver for PEAK System PCAN-USB adapter4 * Derived from the PCAN project file driver/src/pcan_usb.c5 *6 * Copyright (C) 2003-2010 PEAK System-Technik GmbH7 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>8 *9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>10 */11#include <linux/unaligned.h>12 13#include <linux/ethtool.h>14#include <linux/module.h>15#include <linux/netdevice.h>16#include <linux/usb.h>17 18#include <linux/can.h>19#include <linux/can/dev.h>20#include <linux/can/error.h>21 22#include "pcan_usb_core.h"23 24/* PCAN-USB Endpoints */25#define PCAN_USB_EP_CMDOUT 126#define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT | USB_DIR_IN)27#define PCAN_USB_EP_MSGOUT 228#define PCAN_USB_EP_MSGIN (PCAN_USB_EP_MSGOUT | USB_DIR_IN)29 30/* PCAN-USB command struct */31#define PCAN_USB_CMD_FUNC 032#define PCAN_USB_CMD_NUM 133#define PCAN_USB_CMD_ARGS 234#define PCAN_USB_CMD_ARGS_LEN 1435#define PCAN_USB_CMD_LEN (PCAN_USB_CMD_ARGS + \36 PCAN_USB_CMD_ARGS_LEN)37 38/* PCAN-USB commands */39#define PCAN_USB_CMD_BITRATE 140#define PCAN_USB_CMD_SET_BUS 341#define PCAN_USB_CMD_DEVID 442#define PCAN_USB_CMD_SN 643#define PCAN_USB_CMD_REGISTER 944#define PCAN_USB_CMD_EXT_VCC 1045#define PCAN_USB_CMD_ERR_FR 1146#define PCAN_USB_CMD_LED 1247 48/* PCAN_USB_CMD_SET_BUS number arg */49#define PCAN_USB_BUS_XCVER 250#define PCAN_USB_BUS_SILENT_MODE 351 52/* PCAN_USB_CMD_xxx functions */53#define PCAN_USB_GET 154#define PCAN_USB_SET 255 56/* PCAN-USB command timeout (ms.) */57#define PCAN_USB_COMMAND_TIMEOUT 100058 59/* PCAN-USB startup timeout (ms.) */60#define PCAN_USB_STARTUP_TIMEOUT 1061 62/* PCAN-USB rx/tx buffers size */63#define PCAN_USB_RX_BUFFER_SIZE 6464#define PCAN_USB_TX_BUFFER_SIZE 6465 66#define PCAN_USB_MSG_HEADER_LEN 267 68#define PCAN_USB_MSG_TX_CAN 2 /* Tx msg is a CAN frame */69 70/* PCAN-USB adapter internal clock (MHz) */71#define PCAN_USB_CRYSTAL_HZ 1600000072 73/* PCAN-USB USB message record status/len field */74#define PCAN_USB_STATUSLEN_TIMESTAMP (1 << 7)75#define PCAN_USB_STATUSLEN_INTERNAL (1 << 6)76#define PCAN_USB_STATUSLEN_EXT_ID (1 << 5)77#define PCAN_USB_STATUSLEN_RTR (1 << 4)78#define PCAN_USB_STATUSLEN_DLC (0xf)79 80/* PCAN-USB 4.1 CAN Id tx extended flags */81#define PCAN_USB_TX_SRR 0x01 /* SJA1000 SRR command */82#define PCAN_USB_TX_AT 0x02 /* SJA1000 AT command */83 84/* PCAN-USB error flags */85#define PCAN_USB_ERROR_TXFULL 0x0186#define PCAN_USB_ERROR_RXQOVR 0x0287#define PCAN_USB_ERROR_BUS_LIGHT 0x0488#define PCAN_USB_ERROR_BUS_HEAVY 0x0889#define PCAN_USB_ERROR_BUS_OFF 0x1090#define PCAN_USB_ERROR_RXQEMPTY 0x2091#define PCAN_USB_ERROR_QOVR 0x4092#define PCAN_USB_ERROR_TXQFULL 0x8093 94#define PCAN_USB_ERROR_BUS (PCAN_USB_ERROR_BUS_LIGHT | \95 PCAN_USB_ERROR_BUS_HEAVY | \96 PCAN_USB_ERROR_BUS_OFF)97 98/* SJA1000 modes */99#define SJA1000_MODE_NORMAL 0x00100#define SJA1000_MODE_INIT 0x01101 102/*103 * tick duration = 42.666 us =>104 * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000105 * accuracy = 10^-7106 */107#define PCAN_USB_TS_DIV_SHIFTER 20108#define PCAN_USB_TS_US_PER_TICK 44739243109 110/* PCAN-USB messages record types */111#define PCAN_USB_REC_ERROR 1112#define PCAN_USB_REC_ANALOG 2113#define PCAN_USB_REC_BUSLOAD 3114#define PCAN_USB_REC_TS 4115#define PCAN_USB_REC_BUSEVT 5116 117/* CAN bus events notifications selection mask */118#define PCAN_USB_ERR_RXERR 0x02 /* ask for rxerr counter */119#define PCAN_USB_ERR_TXERR 0x04 /* ask for txerr counter */120 121/* This mask generates an usb packet each time the state of the bus changes.122 * In other words, its interest is to know which side among rx and tx is123 * responsible of the change of the bus state.124 */125#define PCAN_USB_BERR_MASK (PCAN_USB_ERR_RXERR | PCAN_USB_ERR_TXERR)126 127/* identify bus event packets with rx/tx error counters */128#define PCAN_USB_ERR_CNT_DEC 0x00 /* counters are decreasing */129#define PCAN_USB_ERR_CNT_INC 0x80 /* counters are increasing */130 131/* private to PCAN-USB adapter */132struct pcan_usb {133 struct peak_usb_device dev;134 struct peak_time_ref time_ref;135 struct timer_list restart_timer;136 struct can_berr_counter bec;137};138 139/* incoming message context for decoding */140struct pcan_usb_msg_context {141 u16 ts16;142 u8 prev_ts8;143 u8 *ptr;144 u8 *end;145 u8 rec_cnt;146 u8 rec_idx;147 u8 rec_ts_idx;148 struct net_device *netdev;149 struct pcan_usb *pdev;150};151 152/*153 * send a command154 */155static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)156{157 int err;158 int actual_length;159 160 /* usb device unregistered? */161 if (!(dev->state & PCAN_USB_STATE_CONNECTED))162 return 0;163 164 dev->cmd_buf[PCAN_USB_CMD_FUNC] = f;165 dev->cmd_buf[PCAN_USB_CMD_NUM] = n;166 167 if (p)168 memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS,169 p, PCAN_USB_CMD_ARGS_LEN);170 171 err = usb_bulk_msg(dev->udev,172 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),173 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,174 PCAN_USB_COMMAND_TIMEOUT);175 if (err)176 netdev_err(dev->netdev,177 "sending cmd f=0x%x n=0x%x failure: %d\n",178 f, n, err);179 return err;180}181 182/*183 * send a command then wait for its response184 */185static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)186{187 int err;188 int actual_length;189 190 /* usb device unregistered? */191 if (!(dev->state & PCAN_USB_STATE_CONNECTED))192 return 0;193 194 /* first, send command */195 err = pcan_usb_send_cmd(dev, f, n, NULL);196 if (err)197 return err;198 199 err = usb_bulk_msg(dev->udev,200 usb_rcvbulkpipe(dev->udev, PCAN_USB_EP_CMDIN),201 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,202 PCAN_USB_COMMAND_TIMEOUT);203 if (err)204 netdev_err(dev->netdev,205 "waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err);206 else if (p)207 memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS,208 PCAN_USB_CMD_ARGS_LEN);209 210 return err;211}212 213static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)214{215 u8 args[PCAN_USB_CMD_ARGS_LEN] = {216 [1] = mode,217 };218 219 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_REGISTER, PCAN_USB_SET,220 args);221}222 223static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff)224{225 u8 args[PCAN_USB_CMD_ARGS_LEN] = {226 [0] = !!onoff,227 };228 229 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS, PCAN_USB_BUS_XCVER,230 args);231}232 233static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff)234{235 u8 args[PCAN_USB_CMD_ARGS_LEN] = {236 [0] = !!onoff,237 };238 239 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS,240 PCAN_USB_BUS_SILENT_MODE, args);241}242 243/* send the cmd to be notified from bus errors */244static int pcan_usb_set_err_frame(struct peak_usb_device *dev, u8 err_mask)245{246 u8 args[PCAN_USB_CMD_ARGS_LEN] = {247 [0] = err_mask,248 };249 250 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_ERR_FR, PCAN_USB_SET, args);251}252 253static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff)254{255 u8 args[PCAN_USB_CMD_ARGS_LEN] = {256 [0] = !!onoff,257 };258 259 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_EXT_VCC, PCAN_USB_SET, args);260}261 262static int pcan_usb_set_led(struct peak_usb_device *dev, u8 onoff)263{264 u8 args[PCAN_USB_CMD_ARGS_LEN] = {265 [0] = !!onoff,266 };267 268 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_LED, PCAN_USB_SET, args);269}270 271/*272 * set bittiming value to can273 */274static int pcan_usb_set_bittiming(struct peak_usb_device *dev,275 struct can_bittiming *bt)276{277 u8 args[PCAN_USB_CMD_ARGS_LEN];278 u8 btr0, btr1;279 280 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);281 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |282 (((bt->phase_seg2 - 1) & 0x7) << 4);283 if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)284 btr1 |= 0x80;285 286 netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n",287 btr0, btr1);288 289 args[0] = btr1;290 args[1] = btr0;291 292 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_BITRATE, PCAN_USB_SET, args);293}294 295/*296 * init/reset can297 */298static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff)299{300 int err;301 302 err = pcan_usb_set_bus(dev, onoff);303 if (err)304 return err;305 306 if (!onoff) {307 err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT);308 } else {309 /* the PCAN-USB needs time to init */310 set_current_state(TASK_INTERRUPTIBLE);311 schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));312 }313 314 return err;315}316 317/*318 * handle end of waiting for the device to reset319 */320static void pcan_usb_restart(struct timer_list *t)321{322 struct pcan_usb *pdev = from_timer(pdev, t, restart_timer);323 struct peak_usb_device *dev = &pdev->dev;324 325 /* notify candev and netdev */326 peak_usb_restart_complete(dev);327}328 329/*330 * handle the submission of the restart urb331 */332static void pcan_usb_restart_pending(struct urb *urb)333{334 struct pcan_usb *pdev = urb->context;335 336 /* the PCAN-USB needs time to restart */337 mod_timer(&pdev->restart_timer,338 jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));339 340 /* can delete usb resources */341 peak_usb_async_complete(urb);342}343 344/*345 * handle asynchronous restart346 */347static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb,348 u8 *buf)349{350 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);351 352 if (timer_pending(&pdev->restart_timer))353 return -EBUSY;354 355 /* set bus on */356 buf[PCAN_USB_CMD_FUNC] = 3;357 buf[PCAN_USB_CMD_NUM] = 2;358 buf[PCAN_USB_CMD_ARGS] = 1;359 360 usb_fill_bulk_urb(urb, dev->udev,361 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),362 buf, PCAN_USB_CMD_LEN,363 pcan_usb_restart_pending, pdev);364 365 return usb_submit_urb(urb, GFP_ATOMIC);366}367 368/*369 * read serial number from device370 */371static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number)372{373 u8 args[PCAN_USB_CMD_ARGS_LEN];374 int err;375 376 err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_SN, PCAN_USB_GET, args);377 if (err)378 return err;379 *serial_number = le32_to_cpup((__le32 *)args);380 381 return 0;382}383 384/*385 * read can channel id from device386 */387static int pcan_usb_get_can_channel_id(struct peak_usb_device *dev, u32 *can_ch_id)388{389 u8 args[PCAN_USB_CMD_ARGS_LEN];390 int err;391 392 err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_DEVID, PCAN_USB_GET, args);393 if (err)394 netdev_err(dev->netdev, "getting can channel id failure: %d\n", err);395 396 else397 *can_ch_id = args[0];398 399 return err;400}401 402/* set a new CAN channel id in the flash memory of the device */403static int pcan_usb_set_can_channel_id(struct peak_usb_device *dev, u32 can_ch_id)404{405 u8 args[PCAN_USB_CMD_ARGS_LEN];406 407 /* this kind of device supports 8-bit values only */408 if (can_ch_id > U8_MAX)409 return -EINVAL;410 411 /* during the flash process the device disconnects during ~1.25 s.:412 * prohibit access when interface is UP413 */414 if (dev->netdev->flags & IFF_UP)415 return -EBUSY;416 417 args[0] = can_ch_id;418 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_DEVID, PCAN_USB_SET, args);419}420 421/*422 * update current time ref with received timestamp423 */424static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)425{426 if ((mc->ptr + 2) > mc->end)427 return -EINVAL;428 429 mc->ts16 = get_unaligned_le16(mc->ptr);430 431 if (mc->rec_idx > 0)432 peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16);433 else434 peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16);435 436 return 0;437}438 439/*440 * decode received timestamp441 */442static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet)443{444 /* only 1st packet supplies a word timestamp */445 if (first_packet) {446 if ((mc->ptr + 2) > mc->end)447 return -EINVAL;448 449 mc->ts16 = get_unaligned_le16(mc->ptr);450 mc->prev_ts8 = mc->ts16 & 0x00ff;451 452 mc->ptr += 2;453 } else {454 u8 ts8;455 456 if ((mc->ptr + 1) > mc->end)457 return -EINVAL;458 459 ts8 = *mc->ptr++;460 461 if (ts8 < mc->prev_ts8)462 mc->ts16 += 0x100;463 464 mc->ts16 &= 0xff00;465 mc->ts16 |= ts8;466 mc->prev_ts8 = ts8;467 }468 469 return 0;470}471 472static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,473 u8 status_len)474{475 struct sk_buff *skb;476 struct can_frame *cf;477 enum can_state new_state = CAN_STATE_ERROR_ACTIVE;478 479 /* ignore this error until 1st ts received */480 if (n == PCAN_USB_ERROR_QOVR)481 if (!mc->pdev->time_ref.tick_count)482 return 0;483 484 /* allocate an skb to store the error frame */485 skb = alloc_can_err_skb(mc->netdev, &cf);486 487 if (n & PCAN_USB_ERROR_RXQOVR) {488 /* data overrun interrupt */489 netdev_dbg(mc->netdev, "data overrun interrupt\n");490 mc->netdev->stats.rx_over_errors++;491 mc->netdev->stats.rx_errors++;492 if (cf) {493 cf->can_id |= CAN_ERR_CRTL;494 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;495 }496 }497 498 if (n & PCAN_USB_ERROR_TXQFULL)499 netdev_dbg(mc->netdev, "device Tx queue full)\n");500 501 if (n & PCAN_USB_ERROR_BUS_OFF) {502 new_state = CAN_STATE_BUS_OFF;503 } else if (n & PCAN_USB_ERROR_BUS_HEAVY) {504 new_state = ((mc->pdev->bec.txerr >= 128) ||505 (mc->pdev->bec.rxerr >= 128)) ?506 CAN_STATE_ERROR_PASSIVE :507 CAN_STATE_ERROR_WARNING;508 } else {509 new_state = CAN_STATE_ERROR_ACTIVE;510 }511 512 /* handle change of state */513 if (new_state != mc->pdev->dev.can.state) {514 enum can_state tx_state =515 (mc->pdev->bec.txerr >= mc->pdev->bec.rxerr) ?516 new_state : 0;517 enum can_state rx_state =518 (mc->pdev->bec.txerr <= mc->pdev->bec.rxerr) ?519 new_state : 0;520 521 can_change_state(mc->netdev, cf, tx_state, rx_state);522 523 if (new_state == CAN_STATE_BUS_OFF) {524 can_bus_off(mc->netdev);525 } else if (cf && (cf->can_id & CAN_ERR_CRTL)) {526 /* Supply TX/RX error counters in case of527 * controller error.528 */529 cf->can_id = CAN_ERR_CNT;530 cf->data[6] = mc->pdev->bec.txerr;531 cf->data[7] = mc->pdev->bec.rxerr;532 }533 }534 535 if (!skb)536 return -ENOMEM;537 538 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {539 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);540 541 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16,542 &hwts->hwtstamp);543 }544 545 netif_rx(skb);546 547 return 0;548}549 550/* decode bus event usb packet: first byte contains rxerr while 2nd one contains551 * txerr.552 */553static int pcan_usb_handle_bus_evt(struct pcan_usb_msg_context *mc, u8 ir)554{555 struct pcan_usb *pdev = mc->pdev;556 557 /* according to the content of the packet */558 switch (ir) {559 case PCAN_USB_ERR_CNT_DEC:560 case PCAN_USB_ERR_CNT_INC:561 562 /* save rx/tx error counters from in the device context */563 pdev->bec.rxerr = mc->ptr[1];564 pdev->bec.txerr = mc->ptr[2];565 break;566 567 default:568 /* reserved */569 break;570 }571 572 return 0;573}574 575/*576 * decode non-data usb message577 */578static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,579 u8 status_len)580{581 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;582 u8 f, n;583 int err;584 585 /* check whether function and number can be read */586 if ((mc->ptr + 2) > mc->end)587 return -EINVAL;588 589 f = mc->ptr[PCAN_USB_CMD_FUNC];590 n = mc->ptr[PCAN_USB_CMD_NUM];591 mc->ptr += PCAN_USB_CMD_ARGS;592 593 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {594 int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx);595 596 if (err)597 return err;598 599 /* Next packet in the buffer will have a timestamp on a single600 * byte601 */602 mc->rec_ts_idx++;603 }604 605 switch (f) {606 case PCAN_USB_REC_ERROR:607 err = pcan_usb_decode_error(mc, n, status_len);608 if (err)609 return err;610 break;611 612 case PCAN_USB_REC_ANALOG:613 /* analog values (ignored) */614 rec_len = 2;615 break;616 617 case PCAN_USB_REC_BUSLOAD:618 /* bus load (ignored) */619 rec_len = 1;620 break;621 622 case PCAN_USB_REC_TS:623 /* only timestamp */624 if (pcan_usb_update_ts(mc))625 return -EINVAL;626 break;627 628 case PCAN_USB_REC_BUSEVT:629 /* bus event notifications (get rxerr/txerr) */630 err = pcan_usb_handle_bus_evt(mc, n);631 if (err)632 return err;633 break;634 default:635 netdev_err(mc->netdev, "unexpected function %u\n", f);636 break;637 }638 639 if ((mc->ptr + rec_len) > mc->end)640 return -EINVAL;641 642 mc->ptr += rec_len;643 644 return 0;645}646 647/*648 * decode data usb message649 */650static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)651{652 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;653 struct sk_buff *skb;654 struct can_frame *cf;655 struct skb_shared_hwtstamps *hwts;656 u32 can_id_flags;657 658 skb = alloc_can_skb(mc->netdev, &cf);659 if (!skb)660 return -ENOMEM;661 662 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {663 if ((mc->ptr + 4) > mc->end)664 goto decode_failed;665 666 can_id_flags = get_unaligned_le32(mc->ptr);667 cf->can_id = can_id_flags >> 3 | CAN_EFF_FLAG;668 mc->ptr += 4;669 } else {670 if ((mc->ptr + 2) > mc->end)671 goto decode_failed;672 673 can_id_flags = get_unaligned_le16(mc->ptr);674 cf->can_id = can_id_flags >> 5;675 mc->ptr += 2;676 }677 678 can_frame_set_cc_len(cf, rec_len, mc->pdev->dev.can.ctrlmode);679 680 /* Only first packet timestamp is a word */681 if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx))682 goto decode_failed;683 684 /* Next packet in the buffer will have a timestamp on a single byte */685 mc->rec_ts_idx++;686 687 /* read data */688 memset(cf->data, 0x0, sizeof(cf->data));689 if (status_len & PCAN_USB_STATUSLEN_RTR) {690 cf->can_id |= CAN_RTR_FLAG;691 } else {692 if ((mc->ptr + rec_len) > mc->end)693 goto decode_failed;694 695 memcpy(cf->data, mc->ptr, cf->len);696 mc->ptr += rec_len;697 698 /* Ignore next byte (client private id) if SRR bit is set */699 if (can_id_flags & PCAN_USB_TX_SRR)700 mc->ptr++;701 702 /* update statistics */703 mc->netdev->stats.rx_bytes += cf->len;704 }705 mc->netdev->stats.rx_packets++;706 707 /* convert timestamp into kernel time */708 hwts = skb_hwtstamps(skb);709 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp);710 711 /* push the skb */712 netif_rx(skb);713 714 return 0;715 716decode_failed:717 dev_kfree_skb(skb);718 return -EINVAL;719}720 721/*722 * process incoming message723 */724static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)725{726 struct pcan_usb_msg_context mc = {727 .rec_cnt = ibuf[1],728 .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN,729 .end = ibuf + lbuf,730 .netdev = dev->netdev,731 .pdev = container_of(dev, struct pcan_usb, dev),732 };733 int err;734 735 for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) {736 u8 sl = *mc.ptr++;737 738 /* handle status and error frames here */739 if (sl & PCAN_USB_STATUSLEN_INTERNAL) {740 err = pcan_usb_decode_status(&mc, sl);741 /* handle normal can frames here */742 } else {743 err = pcan_usb_decode_data(&mc, sl);744 }745 }746 747 return err;748}749 750/*751 * process any incoming buffer752 */753static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb)754{755 int err = 0;756 757 if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) {758 err = pcan_usb_decode_msg(dev, urb->transfer_buffer,759 urb->actual_length);760 761 } else if (urb->actual_length > 0) {762 netdev_err(dev->netdev, "usb message length error (%u)\n",763 urb->actual_length);764 err = -EINVAL;765 }766 767 return err;768}769 770/*771 * process outgoing packet772 */773static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb,774 u8 *obuf, size_t *size)775{776 struct net_device *netdev = dev->netdev;777 struct net_device_stats *stats = &netdev->stats;778 struct can_frame *cf = (struct can_frame *)skb->data;779 u32 can_id_flags = cf->can_id & CAN_ERR_MASK;780 u8 *pc;781 782 obuf[0] = PCAN_USB_MSG_TX_CAN;783 obuf[1] = 1; /* only one CAN frame is stored in the packet */784 785 pc = obuf + PCAN_USB_MSG_HEADER_LEN;786 787 /* status/len byte */788 *pc = can_get_cc_dlc(cf, dev->can.ctrlmode);789 790 if (cf->can_id & CAN_RTR_FLAG)791 *pc |= PCAN_USB_STATUSLEN_RTR;792 793 /* can id */794 if (cf->can_id & CAN_EFF_FLAG) {795 *pc |= PCAN_USB_STATUSLEN_EXT_ID;796 pc++;797 798 can_id_flags <<= 3;799 800 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)801 can_id_flags |= PCAN_USB_TX_SRR;802 803 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)804 can_id_flags |= PCAN_USB_TX_AT;805 806 put_unaligned_le32(can_id_flags, pc);807 pc += 4;808 } else {809 pc++;810 811 can_id_flags <<= 5;812 813 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)814 can_id_flags |= PCAN_USB_TX_SRR;815 816 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)817 can_id_flags |= PCAN_USB_TX_AT;818 819 put_unaligned_le16(can_id_flags, pc);820 pc += 2;821 }822 823 /* can data */824 if (!(cf->can_id & CAN_RTR_FLAG)) {825 memcpy(pc, cf->data, cf->len);826 pc += cf->len;827 }828 829 /* SRR bit needs a writer id (useless here) */830 if (can_id_flags & PCAN_USB_TX_SRR)831 *pc++ = 0x80;832 833 obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff);834 835 return 0;836}837 838/* socket callback used to copy berr counters values received through USB */839static int pcan_usb_get_berr_counter(const struct net_device *netdev,840 struct can_berr_counter *bec)841{842 struct peak_usb_device *dev = netdev_priv(netdev);843 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);844 845 *bec = pdev->bec;846 847 /* must return 0 */848 return 0;849}850 851/*852 * start interface853 */854static int pcan_usb_start(struct peak_usb_device *dev)855{856 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);857 int err;858 859 /* number of bits used in timestamps read from adapter struct */860 peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb);861 862 pdev->bec.rxerr = 0;863 pdev->bec.txerr = 0;864 865 /* always ask the device for BERR reporting, to be able to switch from866 * WARNING to PASSIVE state867 */868 err = pcan_usb_set_err_frame(dev, PCAN_USB_BERR_MASK);869 if (err)870 netdev_warn(dev->netdev,871 "Asking for BERR reporting error %u\n",872 err);873 874 /* if revision greater than 3, can put silent mode on/off */875 if (dev->device_rev > 3) {876 err = pcan_usb_set_silent(dev,877 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);878 if (err)879 return err;880 }881 882 return pcan_usb_set_ext_vcc(dev, 0);883}884 885static int pcan_usb_init(struct peak_usb_device *dev)886{887 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);888 u32 serial_number;889 int err;890 891 /* initialize a timer needed to wait for hardware restart */892 timer_setup(&pdev->restart_timer, pcan_usb_restart, 0);893 894 /*895 * explicit use of dev_xxx() instead of netdev_xxx() here:896 * information displayed are related to the device itself, not897 * to the canx netdevice.898 */899 err = pcan_usb_get_serial(dev, &serial_number);900 if (err) {901 dev_err(dev->netdev->dev.parent,902 "unable to read %s serial number (err %d)\n",903 pcan_usb.name, err);904 return err;905 }906 907 dev_info(dev->netdev->dev.parent,908 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n",909 pcan_usb.name, dev->device_rev, serial_number,910 pcan_usb.ctrl_count);911 912 /* Since rev 4.1, PCAN-USB is able to make single-shot as well as913 * looped back frames.914 */915 if (dev->device_rev >= 41) {916 struct can_priv *priv = netdev_priv(dev->netdev);917 918 priv->ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT |919 CAN_CTRLMODE_LOOPBACK;920 } else {921 dev_info(dev->netdev->dev.parent,922 "Firmware update available. Please contact support@peak-system.com\n");923 }924 925 return 0;926}927 928/*929 * probe function for new PCAN-USB usb interface930 */931static int pcan_usb_probe(struct usb_interface *intf)932{933 struct usb_host_interface *if_desc;934 int i;935 936 if_desc = intf->altsetting;937 938 /* check interface endpoint addresses */939 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {940 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;941 942 switch (ep->bEndpointAddress) {943 case PCAN_USB_EP_CMDOUT:944 case PCAN_USB_EP_CMDIN:945 case PCAN_USB_EP_MSGOUT:946 case PCAN_USB_EP_MSGIN:947 break;948 default:949 return -ENODEV;950 }951 }952 953 return 0;954}955 956static int pcan_usb_set_phys_id(struct net_device *netdev,957 enum ethtool_phys_id_state state)958{959 struct peak_usb_device *dev = netdev_priv(netdev);960 int err = 0;961 962 switch (state) {963 case ETHTOOL_ID_ACTIVE:964 /* call ON/OFF twice a second */965 return 2;966 967 case ETHTOOL_ID_OFF:968 err = pcan_usb_set_led(dev, 0);969 break;970 971 case ETHTOOL_ID_ON:972 fallthrough;973 974 case ETHTOOL_ID_INACTIVE:975 /* restore LED default */976 err = pcan_usb_set_led(dev, 1);977 break;978 979 default:980 break;981 }982 983 return err;984}985 986/* This device only handles 8-bit CAN channel id. */987static int pcan_usb_get_eeprom_len(struct net_device *netdev)988{989 return sizeof(u8);990}991 992static const struct ethtool_ops pcan_usb_ethtool_ops = {993 .set_phys_id = pcan_usb_set_phys_id,994 .get_ts_info = pcan_get_ts_info,995 .get_eeprom_len = pcan_usb_get_eeprom_len,996 .get_eeprom = peak_usb_get_eeprom,997 .set_eeprom = peak_usb_set_eeprom,998};999 1000/*1001 * describe the PCAN-USB adapter1002 */1003static const struct can_bittiming_const pcan_usb_const = {1004 .name = "pcan_usb",1005 .tseg1_min = 1,1006 .tseg1_max = 16,1007 .tseg2_min = 1,1008 .tseg2_max = 8,1009 .sjw_max = 4,1010 .brp_min = 1,1011 .brp_max = 64,1012 .brp_inc = 1,1013};1014 1015const struct peak_usb_adapter pcan_usb = {1016 .name = "PCAN-USB",1017 .device_id = PCAN_USB_PRODUCT_ID,1018 .ctrl_count = 1,1019 .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY |1020 CAN_CTRLMODE_CC_LEN8_DLC,1021 .clock = {1022 .freq = PCAN_USB_CRYSTAL_HZ / 2,1023 },1024 .bittiming_const = &pcan_usb_const,1025 1026 /* size of device private data */1027 .sizeof_dev_private = sizeof(struct pcan_usb),1028 1029 .ethtool_ops = &pcan_usb_ethtool_ops,1030 1031 /* timestamps usage */1032 .ts_used_bits = 16,1033 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */1034 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */1035 1036 /* give here messages in/out endpoints */1037 .ep_msg_in = PCAN_USB_EP_MSGIN,1038 .ep_msg_out = {PCAN_USB_EP_MSGOUT},1039 1040 /* size of rx/tx usb buffers */1041 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,1042 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,1043 1044 /* device callbacks */1045 .intf_probe = pcan_usb_probe,1046 .dev_init = pcan_usb_init,1047 .dev_set_bus = pcan_usb_write_mode,1048 .dev_set_bittiming = pcan_usb_set_bittiming,1049 .dev_get_can_channel_id = pcan_usb_get_can_channel_id,1050 .dev_set_can_channel_id = pcan_usb_set_can_channel_id,1051 .dev_decode_buf = pcan_usb_decode_buf,1052 .dev_encode_msg = pcan_usb_encode_msg,1053 .dev_start = pcan_usb_start,1054 .dev_restart_async = pcan_usb_restart_async,1055 .do_get_berr_counter = pcan_usb_get_berr_counter,1056};1057