1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * CAN driver for "8 devices" USB2CAN converter 4 * 5 * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at) 6 * 7 * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c 8 * and drivers/net/can/usb/esd_usb2.c 9 * 10 * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de) 11 * for testing and fixing this driver. Also many thanks to "8 devices", 12 * who were very cooperative and answered my questions. 13 */ 14 15 #include <linux/signal.h> 16 #include <linux/slab.h> 17 #include <linux/module.h> 18 #include <linux/netdevice.h> 19 #include <linux/usb.h> 20 21 #include <linux/can.h> 22 #include <linux/can/dev.h> 23 #include <linux/can/error.h> 24 #include <linux/can/led.h> 25 26 /* driver constants */ 27 #define MAX_RX_URBS 20 28 #define MAX_TX_URBS 20 29 #define RX_BUFFER_SIZE 64 30 31 /* vendor and product id */ 32 #define USB_8DEV_VENDOR_ID 0x0483 33 #define USB_8DEV_PRODUCT_ID 0x1234 34 35 /* endpoints */ 36 enum usb_8dev_endpoint { 37 USB_8DEV_ENDP_DATA_RX = 1, 38 USB_8DEV_ENDP_DATA_TX, 39 USB_8DEV_ENDP_CMD_RX, 40 USB_8DEV_ENDP_CMD_TX 41 }; 42 43 /* device CAN clock */ 44 #define USB_8DEV_ABP_CLOCK 32000000 45 46 /* setup flags */ 47 #define USB_8DEV_SILENT 0x01 48 #define USB_8DEV_LOOPBACK 0x02 49 #define USB_8DEV_DISABLE_AUTO_RESTRANS 0x04 50 #define USB_8DEV_STATUS_FRAME 0x08 51 52 /* commands */ 53 enum usb_8dev_cmd { 54 USB_8DEV_RESET = 1, 55 USB_8DEV_OPEN, 56 USB_8DEV_CLOSE, 57 USB_8DEV_SET_SPEED, 58 USB_8DEV_SET_MASK_FILTER, 59 USB_8DEV_GET_STATUS, 60 USB_8DEV_GET_STATISTICS, 61 USB_8DEV_GET_SERIAL, 62 USB_8DEV_GET_SOFTW_VER, 63 USB_8DEV_GET_HARDW_VER, 64 USB_8DEV_RESET_TIMESTAMP, 65 USB_8DEV_GET_SOFTW_HARDW_VER 66 }; 67 68 /* command options */ 69 #define USB_8DEV_BAUD_MANUAL 0x09 70 #define USB_8DEV_CMD_START 0x11 71 #define USB_8DEV_CMD_END 0x22 72 73 #define USB_8DEV_CMD_SUCCESS 0 74 #define USB_8DEV_CMD_ERROR 255 75 76 #define USB_8DEV_CMD_TIMEOUT 1000 77 78 /* frames */ 79 #define USB_8DEV_DATA_START 0x55 80 #define USB_8DEV_DATA_END 0xAA 81 82 #define USB_8DEV_TYPE_CAN_FRAME 0 83 #define USB_8DEV_TYPE_ERROR_FRAME 3 84 85 #define USB_8DEV_EXTID 0x01 86 #define USB_8DEV_RTR 0x02 87 #define USB_8DEV_ERR_FLAG 0x04 88 89 /* status */ 90 #define USB_8DEV_STATUSMSG_OK 0x00 /* Normal condition. */ 91 #define USB_8DEV_STATUSMSG_OVERRUN 0x01 /* Overrun occurred when sending */ 92 #define USB_8DEV_STATUSMSG_BUSLIGHT 0x02 /* Error counter has reached 96 */ 93 #define USB_8DEV_STATUSMSG_BUSHEAVY 0x03 /* Error count. has reached 128 */ 94 #define USB_8DEV_STATUSMSG_BUSOFF 0x04 /* Device is in BUSOFF */ 95 #define USB_8DEV_STATUSMSG_STUFF 0x20 /* Stuff Error */ 96 #define USB_8DEV_STATUSMSG_FORM 0x21 /* Form Error */ 97 #define USB_8DEV_STATUSMSG_ACK 0x23 /* Ack Error */ 98 #define USB_8DEV_STATUSMSG_BIT0 0x24 /* Bit1 Error */ 99 #define USB_8DEV_STATUSMSG_BIT1 0x25 /* Bit0 Error */ 100 #define USB_8DEV_STATUSMSG_CRC 0x27 /* CRC Error */ 101 102 #define USB_8DEV_RP_MASK 0x7F /* Mask for Receive Error Bit */ 103 104 105 /* table of devices that work with this driver */ 106 static const struct usb_device_id usb_8dev_table[] = { 107 { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) }, 108 { } /* Terminating entry */ 109 }; 110 111 MODULE_DEVICE_TABLE(usb, usb_8dev_table); 112 113 struct usb_8dev_tx_urb_context { 114 struct usb_8dev_priv *priv; 115 116 u32 echo_index; 117 u8 dlc; 118 }; 119 120 /* Structure to hold all of our device specific stuff */ 121 struct usb_8dev_priv { 122 struct can_priv can; /* must be the first member */ 123 124 struct sk_buff *echo_skb[MAX_TX_URBS]; 125 126 struct usb_device *udev; 127 struct net_device *netdev; 128 129 atomic_t active_tx_urbs; 130 struct usb_anchor tx_submitted; 131 struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS]; 132 133 struct usb_anchor rx_submitted; 134 135 struct can_berr_counter bec; 136 137 u8 *cmd_msg_buffer; 138 139 struct mutex usb_8dev_cmd_lock; 140 void *rxbuf[MAX_RX_URBS]; 141 dma_addr_t rxbuf_dma[MAX_RX_URBS]; 142 }; 143 144 /* tx frame */ 145 struct __packed usb_8dev_tx_msg { 146 u8 begin; 147 u8 flags; /* RTR and EXT_ID flag */ 148 __be32 id; /* upper 3 bits not used */ 149 u8 dlc; /* data length code 0-8 bytes */ 150 u8 data[8]; /* 64-bit data */ 151 u8 end; 152 }; 153 154 /* rx frame */ 155 struct __packed usb_8dev_rx_msg { 156 u8 begin; 157 u8 type; /* frame type */ 158 u8 flags; /* RTR and EXT_ID flag */ 159 __be32 id; /* upper 3 bits not used */ 160 u8 dlc; /* data length code 0-8 bytes */ 161 u8 data[8]; /* 64-bit data */ 162 __be32 timestamp; /* 32-bit timestamp */ 163 u8 end; 164 }; 165 166 /* command frame */ 167 struct __packed usb_8dev_cmd_msg { 168 u8 begin; 169 u8 channel; /* unknown - always 0 */ 170 u8 command; /* command to execute */ 171 u8 opt1; /* optional parameter / return value */ 172 u8 opt2; /* optional parameter 2 */ 173 u8 data[10]; /* optional parameter and data */ 174 u8 end; 175 }; 176 177 static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size) 178 { 179 int actual_length; 180 181 return usb_bulk_msg(priv->udev, 182 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX), 183 msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT); 184 } 185 186 static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size, 187 int *actual_length) 188 { 189 return usb_bulk_msg(priv->udev, 190 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX), 191 msg, size, actual_length, USB_8DEV_CMD_TIMEOUT); 192 } 193 194 /* Send command to device and receive result. 195 * Command was successful when opt1 = 0. 196 */ 197 static int usb_8dev_send_cmd(struct usb_8dev_priv *priv, 198 struct usb_8dev_cmd_msg *out, 199 struct usb_8dev_cmd_msg *in) 200 { 201 int err; 202 int num_bytes_read; 203 struct net_device *netdev; 204 205 netdev = priv->netdev; 206 207 out->begin = USB_8DEV_CMD_START; 208 out->end = USB_8DEV_CMD_END; 209 210 mutex_lock(&priv->usb_8dev_cmd_lock); 211 212 memcpy(priv->cmd_msg_buffer, out, 213 sizeof(struct usb_8dev_cmd_msg)); 214 215 err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer, 216 sizeof(struct usb_8dev_cmd_msg)); 217 if (err < 0) { 218 netdev_err(netdev, "sending command message failed\n"); 219 goto failed; 220 } 221 222 err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer, 223 sizeof(struct usb_8dev_cmd_msg), 224 &num_bytes_read); 225 if (err < 0) { 226 netdev_err(netdev, "no command message answer\n"); 227 goto failed; 228 } 229 230 memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg)); 231 232 if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END || 233 num_bytes_read != 16 || in->opt1 != 0) 234 err = -EPROTO; 235 236 failed: 237 mutex_unlock(&priv->usb_8dev_cmd_lock); 238 return err; 239 } 240 241 /* Send open command to device */ 242 static int usb_8dev_cmd_open(struct usb_8dev_priv *priv) 243 { 244 struct can_bittiming *bt = &priv->can.bittiming; 245 struct usb_8dev_cmd_msg outmsg; 246 struct usb_8dev_cmd_msg inmsg; 247 u32 ctrlmode = priv->can.ctrlmode; 248 u32 flags = USB_8DEV_STATUS_FRAME; 249 __be32 beflags; 250 __be16 bebrp; 251 252 memset(&outmsg, 0, sizeof(outmsg)); 253 outmsg.command = USB_8DEV_OPEN; 254 outmsg.opt1 = USB_8DEV_BAUD_MANUAL; 255 outmsg.data[0] = bt->prop_seg + bt->phase_seg1; 256 outmsg.data[1] = bt->phase_seg2; 257 outmsg.data[2] = bt->sjw; 258 259 /* BRP */ 260 bebrp = cpu_to_be16((u16)bt->brp); 261 memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp)); 262 263 /* flags */ 264 if (ctrlmode & CAN_CTRLMODE_LOOPBACK) 265 flags |= USB_8DEV_LOOPBACK; 266 if (ctrlmode & CAN_CTRLMODE_LISTENONLY) 267 flags |= USB_8DEV_SILENT; 268 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) 269 flags |= USB_8DEV_DISABLE_AUTO_RESTRANS; 270 271 beflags = cpu_to_be32(flags); 272 memcpy(&outmsg.data[5], &beflags, sizeof(beflags)); 273 274 return usb_8dev_send_cmd(priv, &outmsg, &inmsg); 275 } 276 277 /* Send close command to device */ 278 static int usb_8dev_cmd_close(struct usb_8dev_priv *priv) 279 { 280 struct usb_8dev_cmd_msg inmsg; 281 struct usb_8dev_cmd_msg outmsg = { 282 .channel = 0, 283 .command = USB_8DEV_CLOSE, 284 .opt1 = 0, 285 .opt2 = 0 286 }; 287 288 return usb_8dev_send_cmd(priv, &outmsg, &inmsg); 289 } 290 291 /* Get firmware and hardware version */ 292 static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res) 293 { 294 struct usb_8dev_cmd_msg inmsg; 295 struct usb_8dev_cmd_msg outmsg = { 296 .channel = 0, 297 .command = USB_8DEV_GET_SOFTW_HARDW_VER, 298 .opt1 = 0, 299 .opt2 = 0 300 }; 301 302 int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg); 303 if (err) 304 return err; 305 306 *res = be32_to_cpup((__be32 *)inmsg.data); 307 308 return err; 309 } 310 311 /* Set network device mode 312 * 313 * Maybe we should leave this function empty, because the device 314 * set mode variable with open command. 315 */ 316 static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode) 317 { 318 struct usb_8dev_priv *priv = netdev_priv(netdev); 319 int err = 0; 320 321 switch (mode) { 322 case CAN_MODE_START: 323 err = usb_8dev_cmd_open(priv); 324 if (err) 325 netdev_warn(netdev, "couldn't start device"); 326 break; 327 328 default: 329 return -EOPNOTSUPP; 330 } 331 332 return err; 333 } 334 335 /* Read error/status frames */ 336 static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv, 337 struct usb_8dev_rx_msg *msg) 338 { 339 struct can_frame *cf; 340 struct sk_buff *skb; 341 struct net_device_stats *stats = &priv->netdev->stats; 342 343 /* Error message: 344 * byte 0: Status 345 * byte 1: bit 7: Receive Passive 346 * byte 1: bit 0-6: Receive Error Counter 347 * byte 2: Transmit Error Counter 348 * byte 3: Always 0 (maybe reserved for future use) 349 */ 350 351 u8 state = msg->data[0]; 352 u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK; 353 u8 txerr = msg->data[2]; 354 int rx_errors = 0; 355 int tx_errors = 0; 356 357 skb = alloc_can_err_skb(priv->netdev, &cf); 358 if (!skb) 359 return; 360 361 switch (state) { 362 case USB_8DEV_STATUSMSG_OK: 363 priv->can.state = CAN_STATE_ERROR_ACTIVE; 364 cf->can_id |= CAN_ERR_PROT; 365 cf->data[2] = CAN_ERR_PROT_ACTIVE; 366 break; 367 case USB_8DEV_STATUSMSG_BUSOFF: 368 priv->can.state = CAN_STATE_BUS_OFF; 369 cf->can_id |= CAN_ERR_BUSOFF; 370 priv->can.can_stats.bus_off++; 371 can_bus_off(priv->netdev); 372 break; 373 case USB_8DEV_STATUSMSG_OVERRUN: 374 case USB_8DEV_STATUSMSG_BUSLIGHT: 375 case USB_8DEV_STATUSMSG_BUSHEAVY: 376 cf->can_id |= CAN_ERR_CRTL; 377 break; 378 default: 379 priv->can.state = CAN_STATE_ERROR_WARNING; 380 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 381 priv->can.can_stats.bus_error++; 382 break; 383 } 384 385 switch (state) { 386 case USB_8DEV_STATUSMSG_OK: 387 case USB_8DEV_STATUSMSG_BUSOFF: 388 break; 389 case USB_8DEV_STATUSMSG_ACK: 390 cf->can_id |= CAN_ERR_ACK; 391 tx_errors = 1; 392 break; 393 case USB_8DEV_STATUSMSG_CRC: 394 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 395 rx_errors = 1; 396 break; 397 case USB_8DEV_STATUSMSG_BIT0: 398 cf->data[2] |= CAN_ERR_PROT_BIT0; 399 tx_errors = 1; 400 break; 401 case USB_8DEV_STATUSMSG_BIT1: 402 cf->data[2] |= CAN_ERR_PROT_BIT1; 403 tx_errors = 1; 404 break; 405 case USB_8DEV_STATUSMSG_FORM: 406 cf->data[2] |= CAN_ERR_PROT_FORM; 407 rx_errors = 1; 408 break; 409 case USB_8DEV_STATUSMSG_STUFF: 410 cf->data[2] |= CAN_ERR_PROT_STUFF; 411 rx_errors = 1; 412 break; 413 case USB_8DEV_STATUSMSG_OVERRUN: 414 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 415 stats->rx_over_errors++; 416 rx_errors = 1; 417 break; 418 case USB_8DEV_STATUSMSG_BUSLIGHT: 419 priv->can.state = CAN_STATE_ERROR_WARNING; 420 cf->data[1] = (txerr > rxerr) ? 421 CAN_ERR_CRTL_TX_WARNING : 422 CAN_ERR_CRTL_RX_WARNING; 423 priv->can.can_stats.error_warning++; 424 break; 425 case USB_8DEV_STATUSMSG_BUSHEAVY: 426 priv->can.state = CAN_STATE_ERROR_PASSIVE; 427 cf->data[1] = (txerr > rxerr) ? 428 CAN_ERR_CRTL_TX_PASSIVE : 429 CAN_ERR_CRTL_RX_PASSIVE; 430 priv->can.can_stats.error_passive++; 431 break; 432 default: 433 netdev_warn(priv->netdev, 434 "Unknown status/error message (%d)\n", state); 435 break; 436 } 437 438 if (tx_errors) { 439 cf->data[2] |= CAN_ERR_PROT_TX; 440 stats->tx_errors++; 441 } 442 443 if (rx_errors) 444 stats->rx_errors++; 445 446 cf->data[6] = txerr; 447 cf->data[7] = rxerr; 448 449 priv->bec.txerr = txerr; 450 priv->bec.rxerr = rxerr; 451 452 stats->rx_packets++; 453 stats->rx_bytes += cf->len; 454 netif_rx(skb); 455 } 456 457 /* Read data and status frames */ 458 static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv, 459 struct usb_8dev_rx_msg *msg) 460 { 461 struct can_frame *cf; 462 struct sk_buff *skb; 463 struct net_device_stats *stats = &priv->netdev->stats; 464 465 if (msg->type == USB_8DEV_TYPE_ERROR_FRAME && 466 msg->flags == USB_8DEV_ERR_FLAG) { 467 usb_8dev_rx_err_msg(priv, msg); 468 } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) { 469 skb = alloc_can_skb(priv->netdev, &cf); 470 if (!skb) 471 return; 472 473 cf->can_id = be32_to_cpu(msg->id); 474 can_frame_set_cc_len(cf, msg->dlc & 0xF, priv->can.ctrlmode); 475 476 if (msg->flags & USB_8DEV_EXTID) 477 cf->can_id |= CAN_EFF_FLAG; 478 479 if (msg->flags & USB_8DEV_RTR) 480 cf->can_id |= CAN_RTR_FLAG; 481 else 482 memcpy(cf->data, msg->data, cf->len); 483 484 stats->rx_packets++; 485 stats->rx_bytes += cf->len; 486 netif_rx(skb); 487 488 can_led_event(priv->netdev, CAN_LED_EVENT_RX); 489 } else { 490 netdev_warn(priv->netdev, "frame type %d unknown", 491 msg->type); 492 } 493 494 } 495 496 /* Callback for reading data from device 497 * 498 * Check urb status, call read function and resubmit urb read operation. 499 */ 500 static void usb_8dev_read_bulk_callback(struct urb *urb) 501 { 502 struct usb_8dev_priv *priv = urb->context; 503 struct net_device *netdev; 504 int retval; 505 int pos = 0; 506 507 netdev = priv->netdev; 508 509 if (!netif_device_present(netdev)) 510 return; 511 512 switch (urb->status) { 513 case 0: /* success */ 514 break; 515 516 case -ENOENT: 517 case -EPIPE: 518 case -EPROTO: 519 case -ESHUTDOWN: 520 return; 521 522 default: 523 netdev_info(netdev, "Rx URB aborted (%d)\n", 524 urb->status); 525 goto resubmit_urb; 526 } 527 528 while (pos < urb->actual_length) { 529 struct usb_8dev_rx_msg *msg; 530 531 if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) { 532 netdev_err(priv->netdev, "format error\n"); 533 break; 534 } 535 536 msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos); 537 usb_8dev_rx_can_msg(priv, msg); 538 539 pos += sizeof(struct usb_8dev_rx_msg); 540 } 541 542 resubmit_urb: 543 usb_fill_bulk_urb(urb, priv->udev, 544 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX), 545 urb->transfer_buffer, RX_BUFFER_SIZE, 546 usb_8dev_read_bulk_callback, priv); 547 548 retval = usb_submit_urb(urb, GFP_ATOMIC); 549 550 if (retval == -ENODEV) 551 netif_device_detach(netdev); 552 else if (retval) 553 netdev_err(netdev, 554 "failed resubmitting read bulk urb: %d\n", retval); 555 } 556 557 /* Callback handler for write operations 558 * 559 * Free allocated buffers, check transmit status and 560 * calculate statistic. 561 */ 562 static void usb_8dev_write_bulk_callback(struct urb *urb) 563 { 564 struct usb_8dev_tx_urb_context *context = urb->context; 565 struct usb_8dev_priv *priv; 566 struct net_device *netdev; 567 568 BUG_ON(!context); 569 570 priv = context->priv; 571 netdev = priv->netdev; 572 573 /* free up our allocated buffer */ 574 usb_free_coherent(urb->dev, urb->transfer_buffer_length, 575 urb->transfer_buffer, urb->transfer_dma); 576 577 atomic_dec(&priv->active_tx_urbs); 578 579 if (!netif_device_present(netdev)) 580 return; 581 582 if (urb->status) 583 netdev_info(netdev, "Tx URB aborted (%d)\n", 584 urb->status); 585 586 netdev->stats.tx_packets++; 587 netdev->stats.tx_bytes += context->dlc; 588 589 can_get_echo_skb(netdev, context->echo_index, NULL); 590 591 can_led_event(netdev, CAN_LED_EVENT_TX); 592 593 /* Release context */ 594 context->echo_index = MAX_TX_URBS; 595 596 netif_wake_queue(netdev); 597 } 598 599 /* Send data to device */ 600 static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb, 601 struct net_device *netdev) 602 { 603 struct usb_8dev_priv *priv = netdev_priv(netdev); 604 struct net_device_stats *stats = &netdev->stats; 605 struct can_frame *cf = (struct can_frame *) skb->data; 606 struct usb_8dev_tx_msg *msg; 607 struct urb *urb; 608 struct usb_8dev_tx_urb_context *context = NULL; 609 u8 *buf; 610 int i, err; 611 size_t size = sizeof(struct usb_8dev_tx_msg); 612 613 if (can_dropped_invalid_skb(netdev, skb)) 614 return NETDEV_TX_OK; 615 616 /* create a URB, and a buffer for it, and copy the data to the URB */ 617 urb = usb_alloc_urb(0, GFP_ATOMIC); 618 if (!urb) 619 goto nomem; 620 621 buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC, 622 &urb->transfer_dma); 623 if (!buf) { 624 netdev_err(netdev, "No memory left for USB buffer\n"); 625 goto nomembuf; 626 } 627 628 memset(buf, 0, size); 629 630 msg = (struct usb_8dev_tx_msg *)buf; 631 msg->begin = USB_8DEV_DATA_START; 632 msg->flags = 0x00; 633 634 if (cf->can_id & CAN_RTR_FLAG) 635 msg->flags |= USB_8DEV_RTR; 636 637 if (cf->can_id & CAN_EFF_FLAG) 638 msg->flags |= USB_8DEV_EXTID; 639 640 msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK); 641 msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode); 642 memcpy(msg->data, cf->data, cf->len); 643 msg->end = USB_8DEV_DATA_END; 644 645 for (i = 0; i < MAX_TX_URBS; i++) { 646 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) { 647 context = &priv->tx_contexts[i]; 648 break; 649 } 650 } 651 652 /* May never happen! When this happens we'd more URBs in flight as 653 * allowed (MAX_TX_URBS). 654 */ 655 if (!context) 656 goto nofreecontext; 657 658 context->priv = priv; 659 context->echo_index = i; 660 context->dlc = cf->len; 661 662 usb_fill_bulk_urb(urb, priv->udev, 663 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX), 664 buf, size, usb_8dev_write_bulk_callback, context); 665 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 666 usb_anchor_urb(urb, &priv->tx_submitted); 667 668 can_put_echo_skb(skb, netdev, context->echo_index, 0); 669 670 atomic_inc(&priv->active_tx_urbs); 671 672 err = usb_submit_urb(urb, GFP_ATOMIC); 673 if (unlikely(err)) 674 goto failed; 675 else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS) 676 /* Slow down tx path */ 677 netif_stop_queue(netdev); 678 679 /* Release our reference to this URB, the USB core will eventually free 680 * it entirely. 681 */ 682 usb_free_urb(urb); 683 684 return NETDEV_TX_OK; 685 686 nofreecontext: 687 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma); 688 usb_free_urb(urb); 689 690 netdev_warn(netdev, "couldn't find free context"); 691 692 return NETDEV_TX_BUSY; 693 694 failed: 695 can_free_echo_skb(netdev, context->echo_index, NULL); 696 697 usb_unanchor_urb(urb); 698 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma); 699 700 atomic_dec(&priv->active_tx_urbs); 701 702 if (err == -ENODEV) 703 netif_device_detach(netdev); 704 else 705 netdev_warn(netdev, "failed tx_urb %d\n", err); 706 707 nomembuf: 708 usb_free_urb(urb); 709 710 nomem: 711 dev_kfree_skb(skb); 712 stats->tx_dropped++; 713 714 return NETDEV_TX_OK; 715 } 716 717 static int usb_8dev_get_berr_counter(const struct net_device *netdev, 718 struct can_berr_counter *bec) 719 { 720 struct usb_8dev_priv *priv = netdev_priv(netdev); 721 722 bec->txerr = priv->bec.txerr; 723 bec->rxerr = priv->bec.rxerr; 724 725 return 0; 726 } 727 728 /* Start USB device */ 729 static int usb_8dev_start(struct usb_8dev_priv *priv) 730 { 731 struct net_device *netdev = priv->netdev; 732 int err, i; 733 734 for (i = 0; i < MAX_RX_URBS; i++) { 735 struct urb *urb = NULL; 736 u8 *buf; 737 dma_addr_t buf_dma; 738 739 /* create a URB, and a buffer for it */ 740 urb = usb_alloc_urb(0, GFP_KERNEL); 741 if (!urb) { 742 err = -ENOMEM; 743 break; 744 } 745 746 buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL, 747 &buf_dma); 748 if (!buf) { 749 netdev_err(netdev, "No memory left for USB buffer\n"); 750 usb_free_urb(urb); 751 err = -ENOMEM; 752 break; 753 } 754 755 urb->transfer_dma = buf_dma; 756 757 usb_fill_bulk_urb(urb, priv->udev, 758 usb_rcvbulkpipe(priv->udev, 759 USB_8DEV_ENDP_DATA_RX), 760 buf, RX_BUFFER_SIZE, 761 usb_8dev_read_bulk_callback, priv); 762 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 763 usb_anchor_urb(urb, &priv->rx_submitted); 764 765 err = usb_submit_urb(urb, GFP_KERNEL); 766 if (err) { 767 usb_unanchor_urb(urb); 768 usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf, 769 urb->transfer_dma); 770 usb_free_urb(urb); 771 break; 772 } 773 774 priv->rxbuf[i] = buf; 775 priv->rxbuf_dma[i] = buf_dma; 776 777 /* Drop reference, USB core will take care of freeing it */ 778 usb_free_urb(urb); 779 } 780 781 /* Did we submit any URBs */ 782 if (i == 0) { 783 netdev_warn(netdev, "couldn't setup read URBs\n"); 784 return err; 785 } 786 787 /* Warn if we've couldn't transmit all the URBs */ 788 if (i < MAX_RX_URBS) 789 netdev_warn(netdev, "rx performance may be slow\n"); 790 791 err = usb_8dev_cmd_open(priv); 792 if (err) 793 goto failed; 794 795 priv->can.state = CAN_STATE_ERROR_ACTIVE; 796 797 return 0; 798 799 failed: 800 if (err == -ENODEV) 801 netif_device_detach(priv->netdev); 802 803 netdev_warn(netdev, "couldn't submit control: %d\n", err); 804 805 return err; 806 } 807 808 /* Open USB device */ 809 static int usb_8dev_open(struct net_device *netdev) 810 { 811 struct usb_8dev_priv *priv = netdev_priv(netdev); 812 int err; 813 814 /* common open */ 815 err = open_candev(netdev); 816 if (err) 817 return err; 818 819 can_led_event(netdev, CAN_LED_EVENT_OPEN); 820 821 /* finally start device */ 822 err = usb_8dev_start(priv); 823 if (err) { 824 if (err == -ENODEV) 825 netif_device_detach(priv->netdev); 826 827 netdev_warn(netdev, "couldn't start device: %d\n", 828 err); 829 830 close_candev(netdev); 831 832 return err; 833 } 834 835 netif_start_queue(netdev); 836 837 return 0; 838 } 839 840 static void unlink_all_urbs(struct usb_8dev_priv *priv) 841 { 842 int i; 843 844 usb_kill_anchored_urbs(&priv->rx_submitted); 845 846 for (i = 0; i < MAX_RX_URBS; ++i) 847 usb_free_coherent(priv->udev, RX_BUFFER_SIZE, 848 priv->rxbuf[i], priv->rxbuf_dma[i]); 849 850 usb_kill_anchored_urbs(&priv->tx_submitted); 851 atomic_set(&priv->active_tx_urbs, 0); 852 853 for (i = 0; i < MAX_TX_URBS; i++) 854 priv->tx_contexts[i].echo_index = MAX_TX_URBS; 855 } 856 857 /* Close USB device */ 858 static int usb_8dev_close(struct net_device *netdev) 859 { 860 struct usb_8dev_priv *priv = netdev_priv(netdev); 861 int err = 0; 862 863 /* Send CLOSE command to CAN controller */ 864 err = usb_8dev_cmd_close(priv); 865 if (err) 866 netdev_warn(netdev, "couldn't stop device"); 867 868 priv->can.state = CAN_STATE_STOPPED; 869 870 netif_stop_queue(netdev); 871 872 /* Stop polling */ 873 unlink_all_urbs(priv); 874 875 close_candev(netdev); 876 877 can_led_event(netdev, CAN_LED_EVENT_STOP); 878 879 return err; 880 } 881 882 static const struct net_device_ops usb_8dev_netdev_ops = { 883 .ndo_open = usb_8dev_open, 884 .ndo_stop = usb_8dev_close, 885 .ndo_start_xmit = usb_8dev_start_xmit, 886 .ndo_change_mtu = can_change_mtu, 887 }; 888 889 static const struct can_bittiming_const usb_8dev_bittiming_const = { 890 .name = "usb_8dev", 891 .tseg1_min = 1, 892 .tseg1_max = 16, 893 .tseg2_min = 1, 894 .tseg2_max = 8, 895 .sjw_max = 4, 896 .brp_min = 1, 897 .brp_max = 1024, 898 .brp_inc = 1, 899 }; 900 901 /* Probe USB device 902 * 903 * Check device and firmware. 904 * Set supported modes and bittiming constants. 905 * Allocate some memory. 906 */ 907 static int usb_8dev_probe(struct usb_interface *intf, 908 const struct usb_device_id *id) 909 { 910 struct net_device *netdev; 911 struct usb_8dev_priv *priv; 912 int i, err = -ENOMEM; 913 u32 version; 914 char buf[18]; 915 struct usb_device *usbdev = interface_to_usbdev(intf); 916 917 /* product id looks strange, better we also check iProduct string */ 918 if (usb_string(usbdev, usbdev->descriptor.iProduct, buf, 919 sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) { 920 dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n"); 921 return -ENODEV; 922 } 923 924 netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS); 925 if (!netdev) { 926 dev_err(&intf->dev, "Couldn't alloc candev\n"); 927 return -ENOMEM; 928 } 929 930 priv = netdev_priv(netdev); 931 932 priv->udev = usbdev; 933 priv->netdev = netdev; 934 935 priv->can.state = CAN_STATE_STOPPED; 936 priv->can.clock.freq = USB_8DEV_ABP_CLOCK; 937 priv->can.bittiming_const = &usb_8dev_bittiming_const; 938 priv->can.do_set_mode = usb_8dev_set_mode; 939 priv->can.do_get_berr_counter = usb_8dev_get_berr_counter; 940 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | 941 CAN_CTRLMODE_LISTENONLY | 942 CAN_CTRLMODE_ONE_SHOT | 943 CAN_CTRLMODE_CC_LEN8_DLC; 944 945 netdev->netdev_ops = &usb_8dev_netdev_ops; 946 947 netdev->flags |= IFF_ECHO; /* we support local echo */ 948 949 init_usb_anchor(&priv->rx_submitted); 950 951 init_usb_anchor(&priv->tx_submitted); 952 atomic_set(&priv->active_tx_urbs, 0); 953 954 for (i = 0; i < MAX_TX_URBS; i++) 955 priv->tx_contexts[i].echo_index = MAX_TX_URBS; 956 957 priv->cmd_msg_buffer = devm_kzalloc(&intf->dev, sizeof(struct usb_8dev_cmd_msg), 958 GFP_KERNEL); 959 if (!priv->cmd_msg_buffer) 960 goto cleanup_candev; 961 962 usb_set_intfdata(intf, priv); 963 964 SET_NETDEV_DEV(netdev, &intf->dev); 965 966 mutex_init(&priv->usb_8dev_cmd_lock); 967 968 err = register_candev(netdev); 969 if (err) { 970 netdev_err(netdev, 971 "couldn't register CAN device: %d\n", err); 972 goto cleanup_candev; 973 } 974 975 err = usb_8dev_cmd_version(priv, &version); 976 if (err) { 977 netdev_err(netdev, "can't get firmware version\n"); 978 goto cleanup_unregister_candev; 979 } else { 980 netdev_info(netdev, 981 "firmware: %d.%d, hardware: %d.%d\n", 982 (version>>24) & 0xff, (version>>16) & 0xff, 983 (version>>8) & 0xff, version & 0xff); 984 } 985 986 devm_can_led_init(netdev); 987 988 return 0; 989 990 cleanup_unregister_candev: 991 unregister_netdev(priv->netdev); 992 993 cleanup_candev: 994 free_candev(netdev); 995 996 return err; 997 998 } 999 1000 /* Called by the usb core when driver is unloaded or device is removed */ 1001 static void usb_8dev_disconnect(struct usb_interface *intf) 1002 { 1003 struct usb_8dev_priv *priv = usb_get_intfdata(intf); 1004 1005 usb_set_intfdata(intf, NULL); 1006 1007 if (priv) { 1008 netdev_info(priv->netdev, "device disconnected\n"); 1009 1010 unregister_netdev(priv->netdev); 1011 unlink_all_urbs(priv); 1012 free_candev(priv->netdev); 1013 } 1014 1015 } 1016 1017 static struct usb_driver usb_8dev_driver = { 1018 .name = "usb_8dev", 1019 .probe = usb_8dev_probe, 1020 .disconnect = usb_8dev_disconnect, 1021 .id_table = usb_8dev_table, 1022 }; 1023 1024 module_usb_driver(usb_8dev_driver); 1025 1026 MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>"); 1027 MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces"); 1028 MODULE_LICENSE("GPL v2"); 1029