1// SPDX-License-Identifier: GPL-2.0 2 3/* Driver for Theobroma Systems UCAN devices, Protocol Version 3 4 * 5 * Copyright (C) 2018 Theobroma Systems Design und Consulting GmbH 6 * 7 * 8 * General Description: 9 * 10 * The USB Device uses three Endpoints: 11 * 12 * CONTROL Endpoint: Is used the setup the device (start, stop, 13 * info, configure). 14 * 15 * IN Endpoint: The device sends CAN Frame Messages and Device 16 * Information using the IN endpoint. 17 * 18 * OUT Endpoint: The driver sends configuration requests, and CAN 19 * Frames on the out endpoint. 20 * 21 * Error Handling: 22 * 23 * If error reporting is turned on the device encodes error into CAN 24 * error frames (see uapi/linux/can/error.h) and sends it using the 25 * IN Endpoint. The driver updates statistics and forward it. 26 */ 27 28#include <linux/can.h> 29#include <linux/can/dev.h> 30#include <linux/can/error.h> 31#include <linux/ethtool.h> 32#include <linux/module.h> 33#include <linux/netdevice.h> 34#include <linux/signal.h> 35#include <linux/skbuff.h> 36#include <linux/slab.h> 37#include <linux/usb.h> 38 39#define UCAN_DRIVER_NAME "ucan" 40#define UCAN_MAX_RX_URBS 8 41/* the CAN controller needs a while to enable/disable the bus */ 42#define UCAN_USB_CTL_PIPE_TIMEOUT 1000 43/* this driver currently supports protocol version 3 only */ 44#define UCAN_PROTOCOL_VERSION_MIN 3 45#define UCAN_PROTOCOL_VERSION_MAX 3 46 47/* UCAN Message Definitions 48 * ------------------------ 49 * 50 * ucan_message_out_t and ucan_message_in_t define the messages 51 * transmitted on the OUT and IN endpoint. 52 * 53 * Multibyte fields are transmitted with little endianness 54 * 55 * INTR Endpoint: a single uint32_t storing the current space in the fifo 56 * 57 * OUT Endpoint: single message of type ucan_message_out_t is 58 * transmitted on the out endpoint 59 * 60 * IN Endpoint: multiple messages ucan_message_in_t concateted in 61 * the following way: 62 * 63 * m[n].len <=> the length if message n(including the header in bytes) 64 * m[n] is is aligned to a 4 byte boundary, hence 65 * offset(m[0]) := 0; 66 * offset(m[n+1]) := offset(m[n]) + (m[n].len + 3) & 3 67 * 68 * this implies that 69 * offset(m[n]) % 4 <=> 0 70 */ 71 72/* Device Global Commands */ 73enum { 74 UCAN_DEVICE_GET_FW_STRING = 0, 75}; 76 77/* UCAN Commands */ 78enum { 79 /* start the can transceiver - val defines the operation mode */ 80 UCAN_COMMAND_START = 0, 81 /* cancel pending transmissions and stop the can transceiver */ 82 UCAN_COMMAND_STOP = 1, 83 /* send can transceiver into low-power sleep mode */ 84 UCAN_COMMAND_SLEEP = 2, 85 /* wake up can transceiver from low-power sleep mode */ 86 UCAN_COMMAND_WAKEUP = 3, 87 /* reset the can transceiver */ 88 UCAN_COMMAND_RESET = 4, 89 /* get piece of info from the can transceiver - subcmd defines what 90 * piece 91 */ 92 UCAN_COMMAND_GET = 5, 93 /* clear or disable hardware filter - subcmd defines which of the two */ 94 UCAN_COMMAND_FILTER = 6, 95 /* Setup bittiming */ 96 UCAN_COMMAND_SET_BITTIMING = 7, 97 /* recover from bus-off state */ 98 UCAN_COMMAND_RESTART = 8, 99}; 100 101/* UCAN_COMMAND_START and UCAN_COMMAND_GET_INFO operation modes (bitmap). 102 * Undefined bits must be set to 0. 103 */ 104enum { 105 UCAN_MODE_LOOPBACK = BIT(0), 106 UCAN_MODE_SILENT = BIT(1), 107 UCAN_MODE_3_SAMPLES = BIT(2), 108 UCAN_MODE_ONE_SHOT = BIT(3), 109 UCAN_MODE_BERR_REPORT = BIT(4), 110}; 111 112/* UCAN_COMMAND_GET subcommands */ 113enum { 114 UCAN_COMMAND_GET_INFO = 0, 115 UCAN_COMMAND_GET_PROTOCOL_VERSION = 1, 116}; 117 118/* UCAN_COMMAND_FILTER subcommands */ 119enum { 120 UCAN_FILTER_CLEAR = 0, 121 UCAN_FILTER_DISABLE = 1, 122 UCAN_FILTER_ENABLE = 2, 123}; 124 125/* OUT endpoint message types */ 126enum { 127 UCAN_OUT_TX = 2, /* transmit a CAN frame */ 128}; 129 130/* IN endpoint message types */ 131enum { 132 UCAN_IN_TX_COMPLETE = 1, /* CAN frame transmission completed */ 133 UCAN_IN_RX = 2, /* CAN frame received */ 134}; 135 136struct ucan_ctl_cmd_start { 137 __le16 mode; /* OR-ing any of UCAN_MODE_* */ 138} __packed; 139 140struct ucan_ctl_cmd_set_bittiming { 141 __le32 tq; /* Time quanta (TQ) in nanoseconds */ 142 __le16 brp; /* TQ Prescaler */ 143 __le16 sample_point; /* Samplepoint on tenth percent */ 144 u8 prop_seg; /* Propagation segment in TQs */ 145 u8 phase_seg1; /* Phase buffer segment 1 in TQs */ 146 u8 phase_seg2; /* Phase buffer segment 2 in TQs */ 147 u8 sjw; /* Synchronisation jump width in TQs */ 148} __packed; 149 150struct ucan_ctl_cmd_device_info { 151 __le32 freq; /* Clock Frequency for tq generation */ 152 u8 tx_fifo; /* Size of the transmission fifo */ 153 u8 sjw_max; /* can_bittiming fields... */ 154 u8 tseg1_min; 155 u8 tseg1_max; 156 u8 tseg2_min; 157 u8 tseg2_max; 158 __le16 brp_inc; 159 __le32 brp_min; 160 __le32 brp_max; /* ...can_bittiming fields */ 161 __le16 ctrlmodes; /* supported control modes */ 162 __le16 hwfilter; /* Number of HW filter banks */ 163 __le16 rxmboxes; /* Number of receive Mailboxes */ 164} __packed; 165 166struct ucan_ctl_cmd_get_protocol_version { 167 __le32 version; 168} __packed; 169 170union ucan_ctl_payload { 171 /* Setup Bittiming 172 * bmRequest == UCAN_COMMAND_START 173 */ 174 struct ucan_ctl_cmd_start cmd_start; 175 /* Setup Bittiming 176 * bmRequest == UCAN_COMMAND_SET_BITTIMING 177 */ 178 struct ucan_ctl_cmd_set_bittiming cmd_set_bittiming; 179 /* Get Device Information 180 * bmRequest == UCAN_COMMAND_GET; wValue = UCAN_COMMAND_GET_INFO 181 */ 182 struct ucan_ctl_cmd_device_info cmd_get_device_info; 183 /* Get Protocol Version 184 * bmRequest == UCAN_COMMAND_GET; 185 * wValue = UCAN_COMMAND_GET_PROTOCOL_VERSION 186 */ 187 struct ucan_ctl_cmd_get_protocol_version cmd_get_protocol_version; 188 189 u8 raw[128]; 190} __packed; 191 192enum { 193 UCAN_TX_COMPLETE_SUCCESS = BIT(0), 194}; 195 196/* Transmission Complete within ucan_message_in */ 197struct ucan_tx_complete_entry_t { 198 u8 echo_index; 199 u8 flags; 200} __packed __aligned(0x2); 201 202/* CAN Data message format within ucan_message_in/out */ 203struct ucan_can_msg { 204 /* note DLC is computed by 205 * msg.len - sizeof (msg.len) 206 * - sizeof (msg.type) 207 * - sizeof (msg.can_msg.id) 208 */ 209 __le32 id; 210 211 union { 212 u8 data[CAN_MAX_DLEN]; /* Data of CAN frames */ 213 u8 dlc; /* RTR dlc */ 214 }; 215} __packed; 216 217/* OUT Endpoint, outbound messages */ 218struct ucan_message_out { 219 __le16 len; /* Length of the content include header */ 220 u8 type; /* UCAN_OUT_TX and friends */ 221 u8 subtype; /* command sub type */ 222 223 union { 224 /* Transmit CAN frame 225 * (type == UCAN_TX) && ((msg.can_msg.id & CAN_RTR_FLAG) == 0) 226 * subtype stores the echo id 227 */ 228 struct ucan_can_msg can_msg; 229 } msg; 230} __packed __aligned(0x4); 231 232/* IN Endpoint, inbound messages */ 233struct ucan_message_in { 234 __le16 len; /* Length of the content include header */ 235 u8 type; /* UCAN_IN_RX and friends */ 236 u8 subtype; /* command sub type */ 237 238 union { 239 /* CAN Frame received 240 * (type == UCAN_IN_RX) 241 * && ((msg.can_msg.id & CAN_RTR_FLAG) == 0) 242 */ 243 struct ucan_can_msg can_msg; 244 245 /* CAN transmission complete 246 * (type == UCAN_IN_TX_COMPLETE) 247 */ 248 DECLARE_FLEX_ARRAY(struct ucan_tx_complete_entry_t, 249 can_tx_complete_msg); 250 } __aligned(0x4) msg; 251} __packed __aligned(0x4); 252 253/* Macros to calculate message lengths */ 254#define UCAN_OUT_HDR_SIZE offsetof(struct ucan_message_out, msg) 255 256#define UCAN_IN_HDR_SIZE offsetof(struct ucan_message_in, msg) 257#define UCAN_IN_LEN(member) (UCAN_OUT_HDR_SIZE + sizeof(member)) 258 259struct ucan_priv; 260 261/* Context Information for transmission URBs */ 262struct ucan_urb_context { 263 struct ucan_priv *up; 264 bool allocated; 265}; 266 267/* Information reported by the USB device */ 268struct ucan_device_info { 269 struct can_bittiming_const bittiming_const; 270 u8 tx_fifo; 271}; 272 273/* Driver private data */ 274struct ucan_priv { 275 /* must be the first member */ 276 struct can_priv can; 277 278 /* linux USB device structures */ 279 struct usb_device *udev; 280 struct net_device *netdev; 281 282 /* lock for can->echo_skb (used around 283 * can_put/get/free_echo_skb 284 */ 285 spinlock_t echo_skb_lock; 286 287 /* usb device information */ 288 u8 intf_index; 289 u8 in_ep_addr; 290 u8 out_ep_addr; 291 u16 in_ep_size; 292 293 /* transmission and reception buffers */ 294 struct usb_anchor rx_urbs; 295 struct usb_anchor tx_urbs; 296 297 union ucan_ctl_payload *ctl_msg_buffer; 298 struct ucan_device_info device_info; 299 300 /* transmission control information and locks */ 301 spinlock_t context_lock; 302 unsigned int available_tx_urbs; 303 struct ucan_urb_context *context_array; 304}; 305 306static u8 ucan_can_cc_dlc2len(struct ucan_can_msg *msg, u16 len) 307{ 308 if (le32_to_cpu(msg->id) & CAN_RTR_FLAG) 309 return can_cc_dlc2len(msg->dlc); 310 else 311 return can_cc_dlc2len(len - (UCAN_IN_HDR_SIZE + sizeof(msg->id))); 312} 313 314static void ucan_release_context_array(struct ucan_priv *up) 315{ 316 if (!up->context_array) 317 return; 318 319 /* lock is not needed because, driver is currently opening or closing */ 320 up->available_tx_urbs = 0; 321 322 kfree(up->context_array); 323 up->context_array = NULL; 324} 325 326static int ucan_alloc_context_array(struct ucan_priv *up) 327{ 328 int i; 329 330 /* release contexts if any */ 331 ucan_release_context_array(up); 332 333 up->context_array = kcalloc(up->device_info.tx_fifo, 334 sizeof(*up->context_array), 335 GFP_KERNEL); 336 if (!up->context_array) { 337 netdev_err(up->netdev, 338 "Not enough memory to allocate tx contexts\n"); 339 return -ENOMEM; 340 } 341 342 for (i = 0; i < up->device_info.tx_fifo; i++) { 343 up->context_array[i].allocated = false; 344 up->context_array[i].up = up; 345 } 346 347 /* lock is not needed because, driver is currently opening */ 348 up->available_tx_urbs = up->device_info.tx_fifo; 349 350 return 0; 351} 352 353static struct ucan_urb_context *ucan_alloc_context(struct ucan_priv *up) 354{ 355 int i; 356 unsigned long flags; 357 struct ucan_urb_context *ret = NULL; 358 359 if (WARN_ON_ONCE(!up->context_array)) 360 return NULL; 361 362 /* execute context operation atomically */ 363 spin_lock_irqsave(&up->context_lock, flags); 364 365 for (i = 0; i < up->device_info.tx_fifo; i++) { 366 if (!up->context_array[i].allocated) { 367 /* update context */ 368 ret = &up->context_array[i]; 369 up->context_array[i].allocated = true; 370 371 /* stop queue if necessary */ 372 up->available_tx_urbs--; 373 if (!up->available_tx_urbs) 374 netif_stop_queue(up->netdev); 375 376 break; 377 } 378 } 379 380 spin_unlock_irqrestore(&up->context_lock, flags); 381 return ret; 382} 383 384static bool ucan_release_context(struct ucan_priv *up, 385 struct ucan_urb_context *ctx) 386{ 387 unsigned long flags; 388 bool ret = false; 389 390 if (WARN_ON_ONCE(!up->context_array)) 391 return false; 392 393 /* execute context operation atomically */ 394 spin_lock_irqsave(&up->context_lock, flags); 395 396 /* context was not allocated, maybe the device sent garbage */ 397 if (ctx->allocated) { 398 ctx->allocated = false; 399 400 /* check if the queue needs to be woken */ 401 if (!up->available_tx_urbs) 402 netif_wake_queue(up->netdev); 403 up->available_tx_urbs++; 404 405 ret = true; 406 } 407 408 spin_unlock_irqrestore(&up->context_lock, flags); 409 return ret; 410} 411 412static int ucan_ctrl_command_out(struct ucan_priv *up, 413 u8 cmd, u16 subcmd, u16 datalen) 414{ 415 return usb_control_msg(up->udev, 416 usb_sndctrlpipe(up->udev, 0), 417 cmd, 418 USB_DIR_OUT | USB_TYPE_VENDOR | 419 USB_RECIP_INTERFACE, 420 subcmd, 421 up->intf_index, 422 up->ctl_msg_buffer, 423 datalen, 424 UCAN_USB_CTL_PIPE_TIMEOUT); 425} 426 427static int ucan_device_request_in(struct ucan_priv *up, 428 u8 cmd, u16 subcmd, u16 datalen) 429{ 430 return usb_control_msg(up->udev, 431 usb_rcvctrlpipe(up->udev, 0), 432 cmd, 433 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 434 subcmd, 435 0, 436 up->ctl_msg_buffer, 437 datalen, 438 UCAN_USB_CTL_PIPE_TIMEOUT); 439} 440 441/* Parse the device information structure reported by the device and 442 * setup private variables accordingly 443 */ 444static void ucan_parse_device_info(struct ucan_priv *up, 445 struct ucan_ctl_cmd_device_info *device_info) 446{ 447 struct can_bittiming_const *bittiming = 448 &up->device_info.bittiming_const; 449 u16 ctrlmodes; 450 451 /* store the data */ 452 up->can.clock.freq = le32_to_cpu(device_info->freq); 453 up->device_info.tx_fifo = device_info->tx_fifo; 454 strcpy(bittiming->name, "ucan"); 455 bittiming->tseg1_min = device_info->tseg1_min; 456 bittiming->tseg1_max = device_info->tseg1_max; 457 bittiming->tseg2_min = device_info->tseg2_min; 458 bittiming->tseg2_max = device_info->tseg2_max; 459 bittiming->sjw_max = device_info->sjw_max; 460 bittiming->brp_min = le32_to_cpu(device_info->brp_min); 461 bittiming->brp_max = le32_to_cpu(device_info->brp_max); 462 bittiming->brp_inc = le16_to_cpu(device_info->brp_inc); 463 464 ctrlmodes = le16_to_cpu(device_info->ctrlmodes); 465 466 up->can.ctrlmode_supported = 0; 467 468 if (ctrlmodes & UCAN_MODE_LOOPBACK) 469 up->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; 470 if (ctrlmodes & UCAN_MODE_SILENT) 471 up->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 472 if (ctrlmodes & UCAN_MODE_3_SAMPLES) 473 up->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 474 if (ctrlmodes & UCAN_MODE_ONE_SHOT) 475 up->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; 476 if (ctrlmodes & UCAN_MODE_BERR_REPORT) 477 up->can.ctrlmode_supported |= CAN_CTRLMODE_BERR_REPORTING; 478} 479 480/* Handle a CAN error frame that we have received from the device. 481 * Returns true if the can state has changed. 482 */ 483static bool ucan_handle_error_frame(struct ucan_priv *up, 484 struct ucan_message_in *m, 485 canid_t canid) 486{ 487 enum can_state new_state = up->can.state; 488 struct net_device_stats *net_stats = &up->netdev->stats; 489 struct can_device_stats *can_stats = &up->can.can_stats; 490 491 if (canid & CAN_ERR_LOSTARB) 492 can_stats->arbitration_lost++; 493 494 if (canid & CAN_ERR_BUSERROR) 495 can_stats->bus_error++; 496 497 if (canid & CAN_ERR_ACK) 498 net_stats->tx_errors++; 499 500 if (canid & CAN_ERR_BUSOFF) 501 new_state = CAN_STATE_BUS_OFF; 502 503 /* controller problems, details in data[1] */ 504 if (canid & CAN_ERR_CRTL) { 505 u8 d1 = m->msg.can_msg.data[1]; 506 507 if (d1 & CAN_ERR_CRTL_RX_OVERFLOW) 508 net_stats->rx_over_errors++; 509 510 /* controller state bits: if multiple are set the worst wins */ 511 if (d1 & CAN_ERR_CRTL_ACTIVE) 512 new_state = CAN_STATE_ERROR_ACTIVE; 513 514 if (d1 & (CAN_ERR_CRTL_RX_WARNING | CAN_ERR_CRTL_TX_WARNING)) 515 new_state = CAN_STATE_ERROR_WARNING; 516 517 if (d1 & (CAN_ERR_CRTL_RX_PASSIVE | CAN_ERR_CRTL_TX_PASSIVE)) 518 new_state = CAN_STATE_ERROR_PASSIVE; 519 } 520 521 /* protocol error, details in data[2] */ 522 if (canid & CAN_ERR_PROT) { 523 u8 d2 = m->msg.can_msg.data[2]; 524 525 if (d2 & CAN_ERR_PROT_TX) 526 net_stats->tx_errors++; 527 else 528 net_stats->rx_errors++; 529 } 530 531 /* no state change - we are done */ 532 if (up->can.state == new_state) 533 return false; 534 535 /* we switched into a better state */ 536 if (up->can.state > new_state) { 537 up->can.state = new_state; 538 return true; 539 } 540 541 /* we switched into a worse state */ 542 up->can.state = new_state; 543 switch (new_state) { 544 case CAN_STATE_BUS_OFF: 545 can_stats->bus_off++; 546 can_bus_off(up->netdev); 547 break; 548 case CAN_STATE_ERROR_PASSIVE: 549 can_stats->error_passive++; 550 break; 551 case CAN_STATE_ERROR_WARNING: 552 can_stats->error_warning++; 553 break; 554 default: 555 break; 556 } 557 return true; 558} 559 560/* Callback on reception of a can frame via the IN endpoint 561 * 562 * This function allocates an skb and transferres it to the Linux 563 * network stack 564 */ 565static void ucan_rx_can_msg(struct ucan_priv *up, struct ucan_message_in *m) 566{ 567 int len; 568 canid_t canid; 569 struct can_frame *cf; 570 struct sk_buff *skb; 571 struct net_device_stats *stats = &up->netdev->stats; 572 573 /* get the contents of the length field */ 574 len = le16_to_cpu(m->len); 575 576 /* check sanity */ 577 if (len < UCAN_IN_HDR_SIZE + sizeof(m->msg.can_msg.id)) { 578 netdev_warn(up->netdev, "invalid input message len: %d\n", len); 579 return; 580 } 581 582 /* handle error frames */ 583 canid = le32_to_cpu(m->msg.can_msg.id); 584 if (canid & CAN_ERR_FLAG) { 585 bool busstate_changed = ucan_handle_error_frame(up, m, canid); 586 587 /* if berr-reporting is off only state changes get through */ 588 if (!(up->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) && 589 !busstate_changed) 590 return; 591 } else { 592 canid_t canid_mask; 593 /* compute the mask for canid */ 594 canid_mask = CAN_RTR_FLAG; 595 if (canid & CAN_EFF_FLAG) 596 canid_mask |= CAN_EFF_MASK | CAN_EFF_FLAG; 597 else 598 canid_mask |= CAN_SFF_MASK; 599 600 if (canid & ~canid_mask) 601 netdev_warn(up->netdev, 602 "unexpected bits set (canid %x, mask %x)", 603 canid, canid_mask); 604 605 canid &= canid_mask; 606 } 607 608 /* allocate skb */ 609 skb = alloc_can_skb(up->netdev, &cf); 610 if (!skb) 611 return; 612 613 /* fill the can frame */ 614 cf->can_id = canid; 615 616 /* compute DLC taking RTR_FLAG into account */ 617 cf->len = ucan_can_cc_dlc2len(&m->msg.can_msg, len); 618 619 /* copy the payload of non RTR frames */ 620 if (!(cf->can_id & CAN_RTR_FLAG) || (cf->can_id & CAN_ERR_FLAG)) 621 memcpy(cf->data, m->msg.can_msg.data, cf->len); 622 623 /* don't count error frames as real packets */ 624 if (!(cf->can_id & CAN_ERR_FLAG)) { 625 stats->rx_packets++; 626 if (!(cf->can_id & CAN_RTR_FLAG)) 627 stats->rx_bytes += cf->len; 628 } 629 630 /* pass it to Linux */ 631 netif_rx(skb); 632} 633 634/* callback indicating completed transmission */ 635static void ucan_tx_complete_msg(struct ucan_priv *up, 636 struct ucan_message_in *m) 637{ 638 unsigned long flags; 639 u16 count, i; 640 u8 echo_index; 641 u16 len = le16_to_cpu(m->len); 642 643 struct ucan_urb_context *context; 644 645 if (len < UCAN_IN_HDR_SIZE || (len % 2 != 0)) { 646 netdev_err(up->netdev, "invalid tx complete length\n"); 647 return; 648 } 649 650 count = (len - UCAN_IN_HDR_SIZE) / 2; 651 for (i = 0; i < count; i++) { 652 /* we did not submit such echo ids */ 653 echo_index = m->msg.can_tx_complete_msg[i].echo_index; 654 if (echo_index >= up->device_info.tx_fifo) { 655 up->netdev->stats.tx_errors++; 656 netdev_err(up->netdev, 657 "invalid echo_index %d received\n", 658 echo_index); 659 continue; 660 } 661 662 /* gather information from the context */ 663 context = &up->context_array[echo_index]; 664 665 /* Release context and restart queue if necessary. 666 * Also check if the context was allocated 667 */ 668 if (!ucan_release_context(up, context)) 669 continue; 670 671 spin_lock_irqsave(&up->echo_skb_lock, flags); 672 if (m->msg.can_tx_complete_msg[i].flags & 673 UCAN_TX_COMPLETE_SUCCESS) { 674 /* update statistics */ 675 up->netdev->stats.tx_packets++; 676 up->netdev->stats.tx_bytes += 677 can_get_echo_skb(up->netdev, echo_index, NULL); 678 } else { 679 up->netdev->stats.tx_dropped++; 680 can_free_echo_skb(up->netdev, echo_index, NULL); 681 } 682 spin_unlock_irqrestore(&up->echo_skb_lock, flags); 683 } 684} 685 686/* callback on reception of a USB message */ 687static void ucan_read_bulk_callback(struct urb *urb) 688{ 689 int ret; 690 int pos; 691 struct ucan_priv *up = urb->context; 692 struct net_device *netdev = up->netdev; 693 struct ucan_message_in *m; 694 695 /* the device is not up and the driver should not receive any 696 * data on the bulk in pipe 697 */ 698 if (WARN_ON(!up->context_array)) { 699 usb_free_coherent(up->udev, 700 up->in_ep_size, 701 urb->transfer_buffer, 702 urb->transfer_dma); 703 return; 704 } 705 706 /* check URB status */ 707 switch (urb->status) { 708 case 0: 709 break; 710 case -ENOENT: 711 case -EPIPE: 712 case -EPROTO: 713 case -ESHUTDOWN: 714 case -ETIME: 715 /* urb is not resubmitted -> free dma data */ 716 usb_free_coherent(up->udev, 717 up->in_ep_size, 718 urb->transfer_buffer, 719 urb->transfer_dma); 720 netdev_dbg(up->netdev, "not resubmitting urb; status: %d\n", 721 urb->status); 722 return; 723 default: 724 goto resubmit; 725 } 726 727 /* sanity check */ 728 if (!netif_device_present(netdev)) 729 return; 730 731 /* iterate over input */ 732 pos = 0; 733 while (pos < urb->actual_length) { 734 int len; 735 736 /* check sanity (length of header) */ 737 if ((urb->actual_length - pos) < UCAN_IN_HDR_SIZE) { 738 netdev_warn(up->netdev, 739 "invalid message (short; no hdr; l:%d)\n", 740 urb->actual_length); 741 goto resubmit; 742 } 743 744 /* setup the message address */ 745 m = (struct ucan_message_in *) 746 ((u8 *)urb->transfer_buffer + pos); 747 len = le16_to_cpu(m->len); 748 749 /* check sanity (length of content) */ 750 if (urb->actual_length - pos < len) { 751 netdev_warn(up->netdev, 752 "invalid message (short; no data; l:%d)\n", 753 urb->actual_length); 754 print_hex_dump(KERN_WARNING, 755 "raw data: ", 756 DUMP_PREFIX_ADDRESS, 757 16, 758 1, 759 urb->transfer_buffer, 760 urb->actual_length, 761 true); 762 763 goto resubmit; 764 } 765 766 switch (m->type) { 767 case UCAN_IN_RX: 768 ucan_rx_can_msg(up, m); 769 break; 770 case UCAN_IN_TX_COMPLETE: 771 ucan_tx_complete_msg(up, m); 772 break; 773 default: 774 netdev_warn(up->netdev, 775 "invalid message (type; t:%d)\n", 776 m->type); 777 break; 778 } 779 780 /* proceed to next message */ 781 pos += len; 782 /* align to 4 byte boundary */ 783 pos = round_up(pos, 4); 784 } 785 786resubmit: 787 /* resubmit urb when done */ 788 usb_fill_bulk_urb(urb, up->udev, 789 usb_rcvbulkpipe(up->udev, 790 up->in_ep_addr), 791 urb->transfer_buffer, 792 up->in_ep_size, 793 ucan_read_bulk_callback, 794 up); 795 796 usb_anchor_urb(urb, &up->rx_urbs); 797 ret = usb_submit_urb(urb, GFP_ATOMIC); 798 799 if (ret < 0) { 800 netdev_err(up->netdev, 801 "failed resubmitting read bulk urb: %d\n", 802 ret); 803 804 usb_unanchor_urb(urb); 805 usb_free_coherent(up->udev, 806 up->in_ep_size, 807 urb->transfer_buffer, 808 urb->transfer_dma); 809 810 if (ret == -ENODEV) 811 netif_device_detach(netdev); 812 } 813} 814 815/* callback after transmission of a USB message */ 816static void ucan_write_bulk_callback(struct urb *urb) 817{ 818 unsigned long flags; 819 struct ucan_priv *up; 820 struct ucan_urb_context *context = urb->context; 821 822 /* get the urb context */ 823 if (WARN_ON_ONCE(!context)) 824 return; 825 826 /* free up our allocated buffer */ 827 usb_free_coherent(urb->dev, 828 sizeof(struct ucan_message_out), 829 urb->transfer_buffer, 830 urb->transfer_dma); 831 832 up = context->up; 833 if (WARN_ON_ONCE(!up)) 834 return; 835 836 /* sanity check */ 837 if (!netif_device_present(up->netdev)) 838 return; 839 840 /* transmission failed (USB - the device will not send a TX complete) */ 841 if (urb->status) { 842 netdev_warn(up->netdev, 843 "failed to transmit USB message to device: %d\n", 844 urb->status); 845 846 /* update counters an cleanup */ 847 spin_lock_irqsave(&up->echo_skb_lock, flags); 848 can_free_echo_skb(up->netdev, context - up->context_array, NULL); 849 spin_unlock_irqrestore(&up->echo_skb_lock, flags); 850 851 up->netdev->stats.tx_dropped++; 852 853 /* release context and restart the queue if necessary */ 854 if (!ucan_release_context(up, context)) 855 netdev_err(up->netdev, 856 "urb failed, failed to release context\n"); 857 } 858} 859 860static void ucan_cleanup_rx_urbs(struct ucan_priv *up, struct urb **urbs) 861{ 862 int i; 863 864 for (i = 0; i < UCAN_MAX_RX_URBS; i++) { 865 if (urbs[i]) { 866 usb_unanchor_urb(urbs[i]); 867 usb_free_coherent(up->udev, 868 up->in_ep_size, 869 urbs[i]->transfer_buffer, 870 urbs[i]->transfer_dma); 871 usb_free_urb(urbs[i]); 872 } 873 } 874 875 memset(urbs, 0, sizeof(*urbs) * UCAN_MAX_RX_URBS); 876} 877 878static int ucan_prepare_and_anchor_rx_urbs(struct ucan_priv *up, 879 struct urb **urbs) 880{ 881 int i; 882 883 memset(urbs, 0, sizeof(*urbs) * UCAN_MAX_RX_URBS); 884 885 for (i = 0; i < UCAN_MAX_RX_URBS; i++) { 886 void *buf; 887 888 urbs[i] = usb_alloc_urb(0, GFP_KERNEL); 889 if (!urbs[i]) 890 goto err; 891 892 buf = usb_alloc_coherent(up->udev, 893 up->in_ep_size, 894 GFP_KERNEL, &urbs[i]->transfer_dma); 895 if (!buf) { 896 /* cleanup this urb */ 897 usb_free_urb(urbs[i]); 898 urbs[i] = NULL; 899 goto err; 900 } 901 902 usb_fill_bulk_urb(urbs[i], up->udev, 903 usb_rcvbulkpipe(up->udev, 904 up->in_ep_addr), 905 buf, 906 up->in_ep_size, 907 ucan_read_bulk_callback, 908 up); 909 910 urbs[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 911 912 usb_anchor_urb(urbs[i], &up->rx_urbs); 913 } 914 return 0; 915 916err: 917 /* cleanup other unsubmitted urbs */ 918 ucan_cleanup_rx_urbs(up, urbs); 919 return -ENOMEM; 920} 921 922/* Submits rx urbs with the semantic: Either submit all, or cleanup 923 * everything. I case of errors submitted urbs are killed and all urbs in 924 * the array are freed. I case of no errors every entry in the urb 925 * array is set to NULL. 926 */ 927static int ucan_submit_rx_urbs(struct ucan_priv *up, struct urb **urbs) 928{ 929 int i, ret; 930 931 /* Iterate over all urbs to submit. On success remove the urb 932 * from the list. 933 */ 934 for (i = 0; i < UCAN_MAX_RX_URBS; i++) { 935 ret = usb_submit_urb(urbs[i], GFP_KERNEL); 936 if (ret) { 937 netdev_err(up->netdev, 938 "could not submit urb; code: %d\n", 939 ret); 940 goto err; 941 } 942 943 /* Anchor URB and drop reference, USB core will take 944 * care of freeing it 945 */ 946 usb_free_urb(urbs[i]); 947 urbs[i] = NULL; 948 } 949 return 0; 950 951err: 952 /* Cleanup unsubmitted urbs */ 953 ucan_cleanup_rx_urbs(up, urbs); 954 955 /* Kill urbs that are already submitted */ 956 usb_kill_anchored_urbs(&up->rx_urbs); 957 958 return ret; 959} 960 961/* Open the network device */ 962static int ucan_open(struct net_device *netdev) 963{ 964 int ret, ret_cleanup; 965 u16 ctrlmode; 966 struct urb *urbs[UCAN_MAX_RX_URBS]; 967 struct ucan_priv *up = netdev_priv(netdev); 968 969 ret = ucan_alloc_context_array(up); 970 if (ret) 971 return ret; 972 973 /* Allocate and prepare IN URBS - allocated and anchored 974 * urbs are stored in urbs[] for clean 975 */ 976 ret = ucan_prepare_and_anchor_rx_urbs(up, urbs); 977 if (ret) 978 goto err_contexts; 979 980 /* Check the control mode */ 981 ctrlmode = 0; 982 if (up->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 983 ctrlmode |= UCAN_MODE_LOOPBACK; 984 if (up->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 985 ctrlmode |= UCAN_MODE_SILENT; 986 if (up->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 987 ctrlmode |= UCAN_MODE_3_SAMPLES; 988 if (up->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 989 ctrlmode |= UCAN_MODE_ONE_SHOT; 990 991 /* Enable this in any case - filtering is down within the 992 * receive path 993 */ 994 ctrlmode |= UCAN_MODE_BERR_REPORT; 995 up->ctl_msg_buffer->cmd_start.mode = cpu_to_le16(ctrlmode); 996 997 /* Driver is ready to receive data - start the USB device */ 998 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_START, 0, 2); 999 if (ret < 0) { 1000 netdev_err(up->netdev, 1001 "could not start device, code: %d\n", 1002 ret); 1003 goto err_reset; 1004 } 1005 1006 /* Call CAN layer open */ 1007 ret = open_candev(netdev); 1008 if (ret) 1009 goto err_stop; 1010 1011 /* Driver is ready to receive data. Submit RX URBS */ 1012 ret = ucan_submit_rx_urbs(up, urbs); 1013 if (ret) 1014 goto err_stop; 1015 1016 up->can.state = CAN_STATE_ERROR_ACTIVE; 1017 1018 /* Start the network queue */ 1019 netif_start_queue(netdev); 1020 1021 return 0; 1022 1023err_stop: 1024 /* The device have started already stop it */ 1025 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0); 1026 if (ret_cleanup < 0) 1027 netdev_err(up->netdev, 1028 "could not stop device, code: %d\n", 1029 ret_cleanup); 1030 1031err_reset: 1032 /* The device might have received data, reset it for 1033 * consistent state 1034 */ 1035 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0); 1036 if (ret_cleanup < 0) 1037 netdev_err(up->netdev, 1038 "could not reset device, code: %d\n", 1039 ret_cleanup); 1040 1041 /* clean up unsubmitted urbs */ 1042 ucan_cleanup_rx_urbs(up, urbs); 1043 1044err_contexts: 1045 ucan_release_context_array(up); 1046 return ret; 1047} 1048 1049static struct urb *ucan_prepare_tx_urb(struct ucan_priv *up, 1050 struct ucan_urb_context *context, 1051 struct can_frame *cf, 1052 u8 echo_index) 1053{ 1054 int mlen; 1055 struct urb *urb; 1056 struct ucan_message_out *m; 1057 1058 /* create a URB, and a buffer for it, and copy the data to the URB */ 1059 urb = usb_alloc_urb(0, GFP_ATOMIC); 1060 if (!urb) { 1061 netdev_err(up->netdev, "no memory left for URBs\n"); 1062 return NULL; 1063 } 1064 1065 m = usb_alloc_coherent(up->udev, 1066 sizeof(struct ucan_message_out), 1067 GFP_ATOMIC, 1068 &urb->transfer_dma); 1069 if (!m) { 1070 netdev_err(up->netdev, "no memory left for USB buffer\n"); 1071 usb_free_urb(urb); 1072 return NULL; 1073 } 1074 1075 /* build the USB message */ 1076 m->type = UCAN_OUT_TX; 1077 m->msg.can_msg.id = cpu_to_le32(cf->can_id); 1078 1079 if (cf->can_id & CAN_RTR_FLAG) { 1080 mlen = UCAN_OUT_HDR_SIZE + 1081 offsetof(struct ucan_can_msg, dlc) + 1082 sizeof(m->msg.can_msg.dlc); 1083 m->msg.can_msg.dlc = cf->len; 1084 } else { 1085 mlen = UCAN_OUT_HDR_SIZE + 1086 sizeof(m->msg.can_msg.id) + cf->len; 1087 memcpy(m->msg.can_msg.data, cf->data, cf->len); 1088 } 1089 m->len = cpu_to_le16(mlen); 1090 1091 m->subtype = echo_index; 1092 1093 /* build the urb */ 1094 usb_fill_bulk_urb(urb, up->udev, 1095 usb_sndbulkpipe(up->udev, 1096 up->out_ep_addr), 1097 m, mlen, ucan_write_bulk_callback, context); 1098 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1099 1100 return urb; 1101} 1102 1103static void ucan_clean_up_tx_urb(struct ucan_priv *up, struct urb *urb) 1104{ 1105 usb_free_coherent(up->udev, sizeof(struct ucan_message_out), 1106 urb->transfer_buffer, urb->transfer_dma); 1107 usb_free_urb(urb); 1108} 1109 1110/* callback when Linux needs to send a can frame */ 1111static netdev_tx_t ucan_start_xmit(struct sk_buff *skb, 1112 struct net_device *netdev) 1113{ 1114 unsigned long flags; 1115 int ret; 1116 u8 echo_index; 1117 struct urb *urb; 1118 struct ucan_urb_context *context; 1119 struct ucan_priv *up = netdev_priv(netdev); 1120 struct can_frame *cf = (struct can_frame *)skb->data; 1121 1122 /* check skb */ 1123 if (can_dev_dropped_skb(netdev, skb)) 1124 return NETDEV_TX_OK; 1125 1126 /* allocate a context and slow down tx path, if fifo state is low */ 1127 context = ucan_alloc_context(up); 1128 echo_index = context - up->context_array; 1129 1130 if (WARN_ON_ONCE(!context)) 1131 return NETDEV_TX_BUSY; 1132 1133 /* prepare urb for transmission */ 1134 urb = ucan_prepare_tx_urb(up, context, cf, echo_index); 1135 if (!urb) 1136 goto drop; 1137 1138 /* put the skb on can loopback stack */ 1139 spin_lock_irqsave(&up->echo_skb_lock, flags); 1140 can_put_echo_skb(skb, up->netdev, echo_index, 0); 1141 spin_unlock_irqrestore(&up->echo_skb_lock, flags); 1142 1143 /* transmit it */ 1144 usb_anchor_urb(urb, &up->tx_urbs); 1145 ret = usb_submit_urb(urb, GFP_ATOMIC); 1146 1147 /* cleanup urb */ 1148 if (ret) { 1149 /* on error, clean up */ 1150 usb_unanchor_urb(urb); 1151 ucan_clean_up_tx_urb(up, urb); 1152 if (!ucan_release_context(up, context)) 1153 netdev_err(up->netdev, 1154 "xmit err: failed to release context\n"); 1155 1156 /* remove the skb from the echo stack - this also 1157 * frees the skb 1158 */ 1159 spin_lock_irqsave(&up->echo_skb_lock, flags); 1160 can_free_echo_skb(up->netdev, echo_index, NULL); 1161 spin_unlock_irqrestore(&up->echo_skb_lock, flags); 1162 1163 if (ret == -ENODEV) { 1164 netif_device_detach(up->netdev); 1165 } else { 1166 netdev_warn(up->netdev, 1167 "xmit err: failed to submit urb %d\n", 1168 ret); 1169 up->netdev->stats.tx_dropped++; 1170 } 1171 return NETDEV_TX_OK; 1172 } 1173 1174 netif_trans_update(netdev); 1175 1176 /* release ref, as we do not need the urb anymore */ 1177 usb_free_urb(urb); 1178 1179 return NETDEV_TX_OK; 1180 1181drop: 1182 if (!ucan_release_context(up, context)) 1183 netdev_err(up->netdev, 1184 "xmit drop: failed to release context\n"); 1185 dev_kfree_skb(skb); 1186 up->netdev->stats.tx_dropped++; 1187 1188 return NETDEV_TX_OK; 1189} 1190 1191/* Device goes down 1192 * 1193 * Clean up used resources 1194 */ 1195static int ucan_close(struct net_device *netdev) 1196{ 1197 int ret; 1198 struct ucan_priv *up = netdev_priv(netdev); 1199 1200 up->can.state = CAN_STATE_STOPPED; 1201 1202 /* stop sending data */ 1203 usb_kill_anchored_urbs(&up->tx_urbs); 1204 1205 /* stop receiving data */ 1206 usb_kill_anchored_urbs(&up->rx_urbs); 1207 1208 /* stop and reset can device */ 1209 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0); 1210 if (ret < 0) 1211 netdev_err(up->netdev, 1212 "could not stop device, code: %d\n", 1213 ret); 1214 1215 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0); 1216 if (ret < 0) 1217 netdev_err(up->netdev, 1218 "could not reset device, code: %d\n", 1219 ret); 1220 1221 netif_stop_queue(netdev); 1222 1223 ucan_release_context_array(up); 1224 1225 close_candev(up->netdev); 1226 return 0; 1227} 1228 1229/* CAN driver callbacks */ 1230static const struct net_device_ops ucan_netdev_ops = { 1231 .ndo_open = ucan_open, 1232 .ndo_stop = ucan_close, 1233 .ndo_start_xmit = ucan_start_xmit, 1234 .ndo_change_mtu = can_change_mtu, 1235}; 1236 1237static const struct ethtool_ops ucan_ethtool_ops = { 1238 .get_ts_info = ethtool_op_get_ts_info, 1239}; 1240 1241/* Request to set bittiming 1242 * 1243 * This function generates an USB set bittiming message and transmits 1244 * it to the device 1245 */ 1246static int ucan_set_bittiming(struct net_device *netdev) 1247{ 1248 int ret; 1249 struct ucan_priv *up = netdev_priv(netdev); 1250 struct ucan_ctl_cmd_set_bittiming *cmd_set_bittiming; 1251 1252 cmd_set_bittiming = &up->ctl_msg_buffer->cmd_set_bittiming; 1253 cmd_set_bittiming->tq = cpu_to_le32(up->can.bittiming.tq); 1254 cmd_set_bittiming->brp = cpu_to_le16(up->can.bittiming.brp); 1255 cmd_set_bittiming->sample_point = 1256 cpu_to_le16(up->can.bittiming.sample_point); 1257 cmd_set_bittiming->prop_seg = up->can.bittiming.prop_seg; 1258 cmd_set_bittiming->phase_seg1 = up->can.bittiming.phase_seg1; 1259 cmd_set_bittiming->phase_seg2 = up->can.bittiming.phase_seg2; 1260 cmd_set_bittiming->sjw = up->can.bittiming.sjw; 1261 1262 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_SET_BITTIMING, 0, 1263 sizeof(*cmd_set_bittiming)); 1264 return (ret < 0) ? ret : 0; 1265} 1266 1267/* Restart the device to get it out of BUS-OFF state. 1268 * Called when the user runs "ip link set can1 type can restart". 1269 */ 1270static int ucan_set_mode(struct net_device *netdev, enum can_mode mode) 1271{ 1272 int ret; 1273 unsigned long flags; 1274 struct ucan_priv *up = netdev_priv(netdev); 1275 1276 switch (mode) { 1277 case CAN_MODE_START: 1278 netdev_dbg(up->netdev, "restarting device\n"); 1279 1280 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESTART, 0, 0); 1281 up->can.state = CAN_STATE_ERROR_ACTIVE; 1282 1283 /* check if queue can be restarted, 1284 * up->available_tx_urbs must be protected by the 1285 * lock 1286 */ 1287 spin_lock_irqsave(&up->context_lock, flags); 1288 1289 if (up->available_tx_urbs > 0) 1290 netif_wake_queue(up->netdev); 1291 1292 spin_unlock_irqrestore(&up->context_lock, flags); 1293 1294 return ret; 1295 default: 1296 return -EOPNOTSUPP; 1297 } 1298} 1299 1300/* Probe the device, reset it and gather general device information */ 1301static int ucan_probe(struct usb_interface *intf, 1302 const struct usb_device_id *id) 1303{ 1304 int ret; 1305 int i; 1306 u32 protocol_version; 1307 struct usb_device *udev; 1308 struct net_device *netdev; 1309 struct usb_host_interface *iface_desc; 1310 struct ucan_priv *up; 1311 struct usb_endpoint_descriptor *ep; 1312 u16 in_ep_size; 1313 u16 out_ep_size; 1314 u8 in_ep_addr; 1315 u8 out_ep_addr; 1316 union ucan_ctl_payload *ctl_msg_buffer; 1317 char firmware_str[sizeof(union ucan_ctl_payload) + 1]; 1318 1319 udev = interface_to_usbdev(intf); 1320 1321 /* Stage 1 - Interface Parsing 1322 * --------------------------- 1323 * 1324 * Identifie the device USB interface descriptor and its 1325 * endpoints. Probing is aborted on errors. 1326 */ 1327 1328 /* check if the interface is sane */ 1329 iface_desc = intf->cur_altsetting; 1330 if (!iface_desc) 1331 return -ENODEV; 1332 1333 dev_info(&udev->dev, 1334 "%s: probing device on interface #%d\n", 1335 UCAN_DRIVER_NAME, 1336 iface_desc->desc.bInterfaceNumber); 1337 1338 /* interface sanity check */ 1339 if (iface_desc->desc.bNumEndpoints != 2) { 1340 dev_err(&udev->dev, 1341 "%s: invalid EP count (%d)", 1342 UCAN_DRIVER_NAME, iface_desc->desc.bNumEndpoints); 1343 goto err_firmware_needs_update; 1344 } 1345 1346 /* check interface endpoints */ 1347 in_ep_addr = 0; 1348 out_ep_addr = 0; 1349 in_ep_size = 0; 1350 out_ep_size = 0; 1351 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { 1352 ep = &iface_desc->endpoint[i].desc; 1353 1354 if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != 0) && 1355 ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 1356 USB_ENDPOINT_XFER_BULK)) { 1357 /* In Endpoint */ 1358 in_ep_addr = ep->bEndpointAddress; 1359 in_ep_addr &= USB_ENDPOINT_NUMBER_MASK; 1360 in_ep_size = le16_to_cpu(ep->wMaxPacketSize); 1361 } else if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == 1362 0) && 1363 ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 1364 USB_ENDPOINT_XFER_BULK)) { 1365 /* Out Endpoint */ 1366 out_ep_addr = ep->bEndpointAddress; 1367 out_ep_addr &= USB_ENDPOINT_NUMBER_MASK; 1368 out_ep_size = le16_to_cpu(ep->wMaxPacketSize); 1369 } 1370 } 1371 1372 /* check if interface is sane */ 1373 if (!in_ep_addr || !out_ep_addr) { 1374 dev_err(&udev->dev, "%s: invalid endpoint configuration\n", 1375 UCAN_DRIVER_NAME); 1376 goto err_firmware_needs_update; 1377 } 1378 if (in_ep_size < sizeof(struct ucan_message_in)) { 1379 dev_err(&udev->dev, "%s: invalid in_ep MaxPacketSize\n", 1380 UCAN_DRIVER_NAME); 1381 goto err_firmware_needs_update; 1382 } 1383 if (out_ep_size < sizeof(struct ucan_message_out)) { 1384 dev_err(&udev->dev, "%s: invalid out_ep MaxPacketSize\n", 1385 UCAN_DRIVER_NAME); 1386 goto err_firmware_needs_update; 1387 } 1388 1389 /* Stage 2 - Device Identification 1390 * ------------------------------- 1391 * 1392 * The device interface seems to be a ucan device. Do further 1393 * compatibility checks. On error probing is aborted, on 1394 * success this stage leaves the ctl_msg_buffer with the 1395 * reported contents of a GET_INFO command (supported 1396 * bittimings, tx_fifo depth). This information is used in 1397 * Stage 3 for the final driver initialisation. 1398 */ 1399 1400 /* Prepare Memory for control transfers */ 1401 ctl_msg_buffer = devm_kzalloc(&udev->dev, 1402 sizeof(union ucan_ctl_payload), 1403 GFP_KERNEL); 1404 if (!ctl_msg_buffer) { 1405 dev_err(&udev->dev, 1406 "%s: failed to allocate control pipe memory\n", 1407 UCAN_DRIVER_NAME); 1408 return -ENOMEM; 1409 } 1410 1411 /* get protocol version 1412 * 1413 * note: ucan_ctrl_command_* wrappers cannot be used yet 1414 * because `up` is initialised in Stage 3 1415 */ 1416 ret = usb_control_msg(udev, 1417 usb_rcvctrlpipe(udev, 0), 1418 UCAN_COMMAND_GET, 1419 USB_DIR_IN | USB_TYPE_VENDOR | 1420 USB_RECIP_INTERFACE, 1421 UCAN_COMMAND_GET_PROTOCOL_VERSION, 1422 iface_desc->desc.bInterfaceNumber, 1423 ctl_msg_buffer, 1424 sizeof(union ucan_ctl_payload), 1425 UCAN_USB_CTL_PIPE_TIMEOUT); 1426 1427 /* older firmware version do not support this command - those 1428 * are not supported by this drive 1429 */ 1430 if (ret != 4) { 1431 dev_err(&udev->dev, 1432 "%s: could not read protocol version, ret=%d\n", 1433 UCAN_DRIVER_NAME, ret); 1434 if (ret >= 0) 1435 ret = -EINVAL; 1436 goto err_firmware_needs_update; 1437 } 1438 1439 /* this driver currently supports protocol version 3 only */ 1440 protocol_version = 1441 le32_to_cpu(ctl_msg_buffer->cmd_get_protocol_version.version); 1442 if (protocol_version < UCAN_PROTOCOL_VERSION_MIN || 1443 protocol_version > UCAN_PROTOCOL_VERSION_MAX) { 1444 dev_err(&udev->dev, 1445 "%s: device protocol version %d is not supported\n", 1446 UCAN_DRIVER_NAME, protocol_version); 1447 goto err_firmware_needs_update; 1448 } 1449 1450 /* request the device information and store it in ctl_msg_buffer 1451 * 1452 * note: ucan_ctrl_command_* wrappers cannot be used yet 1453 * because `up` is initialised in Stage 3 1454 */ 1455 ret = usb_control_msg(udev, 1456 usb_rcvctrlpipe(udev, 0), 1457 UCAN_COMMAND_GET, 1458 USB_DIR_IN | USB_TYPE_VENDOR | 1459 USB_RECIP_INTERFACE, 1460 UCAN_COMMAND_GET_INFO, 1461 iface_desc->desc.bInterfaceNumber, 1462 ctl_msg_buffer, 1463 sizeof(ctl_msg_buffer->cmd_get_device_info), 1464 UCAN_USB_CTL_PIPE_TIMEOUT); 1465 1466 if (ret < 0) { 1467 dev_err(&udev->dev, "%s: failed to retrieve device info\n", 1468 UCAN_DRIVER_NAME); 1469 goto err_firmware_needs_update; 1470 } 1471 if (ret < sizeof(ctl_msg_buffer->cmd_get_device_info)) { 1472 dev_err(&udev->dev, "%s: device reported invalid device info\n", 1473 UCAN_DRIVER_NAME); 1474 goto err_firmware_needs_update; 1475 } 1476 if (ctl_msg_buffer->cmd_get_device_info.tx_fifo == 0) { 1477 dev_err(&udev->dev, 1478 "%s: device reported invalid tx-fifo size\n", 1479 UCAN_DRIVER_NAME); 1480 goto err_firmware_needs_update; 1481 } 1482 1483 /* Stage 3 - Driver Initialisation 1484 * ------------------------------- 1485 * 1486 * Register device to Linux, prepare private structures and 1487 * reset the device. 1488 */ 1489 1490 /* allocate driver resources */ 1491 netdev = alloc_candev(sizeof(struct ucan_priv), 1492 ctl_msg_buffer->cmd_get_device_info.tx_fifo); 1493 if (!netdev) { 1494 dev_err(&udev->dev, 1495 "%s: cannot allocate candev\n", UCAN_DRIVER_NAME); 1496 return -ENOMEM; 1497 } 1498 1499 up = netdev_priv(netdev); 1500 1501 /* initialize data */ 1502 up->udev = udev; 1503 up->netdev = netdev; 1504 up->intf_index = iface_desc->desc.bInterfaceNumber; 1505 up->in_ep_addr = in_ep_addr; 1506 up->out_ep_addr = out_ep_addr; 1507 up->in_ep_size = in_ep_size; 1508 up->ctl_msg_buffer = ctl_msg_buffer; 1509 up->context_array = NULL; 1510 up->available_tx_urbs = 0; 1511 1512 up->can.state = CAN_STATE_STOPPED; 1513 up->can.bittiming_const = &up->device_info.bittiming_const; 1514 up->can.do_set_bittiming = ucan_set_bittiming; 1515 up->can.do_set_mode = &ucan_set_mode; 1516 spin_lock_init(&up->context_lock); 1517 spin_lock_init(&up->echo_skb_lock); 1518 netdev->netdev_ops = &ucan_netdev_ops; 1519 netdev->ethtool_ops = &ucan_ethtool_ops; 1520 1521 usb_set_intfdata(intf, up); 1522 SET_NETDEV_DEV(netdev, &intf->dev); 1523 1524 /* parse device information 1525 * the data retrieved in Stage 2 is still available in 1526 * up->ctl_msg_buffer 1527 */ 1528 ucan_parse_device_info(up, &ctl_msg_buffer->cmd_get_device_info); 1529 1530 /* just print some device information - if available */ 1531 ret = ucan_device_request_in(up, UCAN_DEVICE_GET_FW_STRING, 0, 1532 sizeof(union ucan_ctl_payload)); 1533 if (ret > 0) { 1534 /* copy string while ensuring zero termination */ 1535 strscpy(firmware_str, up->ctl_msg_buffer->raw, 1536 sizeof(union ucan_ctl_payload) + 1); 1537 } else { 1538 strcpy(firmware_str, "unknown"); 1539 } 1540 1541 /* device is compatible, reset it */ 1542 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0); 1543 if (ret < 0) 1544 goto err_free_candev; 1545 1546 init_usb_anchor(&up->rx_urbs); 1547 init_usb_anchor(&up->tx_urbs); 1548 1549 up->can.state = CAN_STATE_STOPPED; 1550 1551 /* register the device */ 1552 ret = register_candev(netdev); 1553 if (ret) 1554 goto err_free_candev; 1555 1556 /* initialisation complete, log device info */ 1557 netdev_info(up->netdev, "registered device\n"); 1558 netdev_info(up->netdev, "firmware string: %s\n", firmware_str); 1559 1560 /* success */ 1561 return 0; 1562 1563err_free_candev: 1564 free_candev(netdev); 1565 return ret; 1566 1567err_firmware_needs_update: 1568 dev_err(&udev->dev, 1569 "%s: probe failed; try to update the device firmware\n", 1570 UCAN_DRIVER_NAME); 1571 return -ENODEV; 1572} 1573 1574/* disconnect the device */ 1575static void ucan_disconnect(struct usb_interface *intf) 1576{ 1577 struct ucan_priv *up = usb_get_intfdata(intf); 1578 1579 usb_set_intfdata(intf, NULL); 1580 1581 if (up) { 1582 unregister_candev(up->netdev); 1583 free_candev(up->netdev); 1584 } 1585} 1586 1587static struct usb_device_id ucan_table[] = { 1588 /* Mule (soldered onto compute modules) */ 1589 {USB_DEVICE_INTERFACE_NUMBER(0x2294, 0x425a, 0)}, 1590 /* Seal (standalone USB stick) */ 1591 {USB_DEVICE_INTERFACE_NUMBER(0x2294, 0x425b, 0)}, 1592 {} /* Terminating entry */ 1593}; 1594 1595MODULE_DEVICE_TABLE(usb, ucan_table); 1596/* driver callbacks */ 1597static struct usb_driver ucan_driver = { 1598 .name = UCAN_DRIVER_NAME, 1599 .probe = ucan_probe, 1600 .disconnect = ucan_disconnect, 1601 .id_table = ucan_table, 1602}; 1603 1604module_usb_driver(ucan_driver); 1605 1606MODULE_LICENSE("GPL v2"); 1607MODULE_AUTHOR("Martin Elshuber <martin.elshuber@theobroma-systems.com>"); 1608MODULE_AUTHOR("Jakob Unterwurzacher <jakob.unterwurzacher@theobroma-systems.com>"); 1609MODULE_DESCRIPTION("Driver for Theobroma Systems UCAN devices"); 1610