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