1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * usb.c - Hardware dependent module for USB 4 * 5 * Copyright (C) 2013-2015 Microchip Technology Germany II GmbH & Co. KG 6 */ 7 8 #include <linux/module.h> 9 #include <linux/fs.h> 10 #include <linux/usb.h> 11 #include <linux/slab.h> 12 #include <linux/init.h> 13 #include <linux/cdev.h> 14 #include <linux/device.h> 15 #include <linux/list.h> 16 #include <linux/completion.h> 17 #include <linux/mutex.h> 18 #include <linux/spinlock.h> 19 #include <linux/interrupt.h> 20 #include <linux/workqueue.h> 21 #include <linux/sysfs.h> 22 #include <linux/dma-mapping.h> 23 #include <linux/etherdevice.h> 24 #include <linux/uaccess.h> 25 #include <linux/most.h> 26 27 #define USB_MTU 512 28 #define NO_ISOCHRONOUS_URB 0 29 #define AV_PACKETS_PER_XACT 2 30 #define BUF_CHAIN_SIZE 0xFFFF 31 #define MAX_NUM_ENDPOINTS 30 32 #define MAX_SUFFIX_LEN 10 33 #define MAX_STRING_LEN 80 34 #define MAX_BUF_SIZE 0xFFFF 35 36 #define USB_VENDOR_ID_SMSC 0x0424 /* VID: SMSC */ 37 #define USB_DEV_ID_BRDG 0xC001 /* PID: USB Bridge */ 38 #define USB_DEV_ID_OS81118 0xCF18 /* PID: USB OS81118 */ 39 #define USB_DEV_ID_OS81119 0xCF19 /* PID: USB OS81119 */ 40 #define USB_DEV_ID_OS81210 0xCF30 /* PID: USB OS81210 */ 41 /* DRCI Addresses */ 42 #define DRCI_REG_NI_STATE 0x0100 43 #define DRCI_REG_PACKET_BW 0x0101 44 #define DRCI_REG_NODE_ADDR 0x0102 45 #define DRCI_REG_NODE_POS 0x0103 46 #define DRCI_REG_MEP_FILTER 0x0140 47 #define DRCI_REG_HASH_TBL0 0x0141 48 #define DRCI_REG_HASH_TBL1 0x0142 49 #define DRCI_REG_HASH_TBL2 0x0143 50 #define DRCI_REG_HASH_TBL3 0x0144 51 #define DRCI_REG_HW_ADDR_HI 0x0145 52 #define DRCI_REG_HW_ADDR_MI 0x0146 53 #define DRCI_REG_HW_ADDR_LO 0x0147 54 #define DRCI_REG_BASE 0x1100 55 #define DRCI_COMMAND 0x02 56 #define DRCI_READ_REQ 0xA0 57 #define DRCI_WRITE_REQ 0xA1 58 59 /** 60 * struct most_dci_obj - Direct Communication Interface 61 * @kobj:position in sysfs 62 * @usb_device: pointer to the usb device 63 * @reg_addr: register address for arbitrary DCI access 64 */ 65 struct most_dci_obj { 66 struct device dev; 67 struct usb_device *usb_device; 68 u16 reg_addr; 69 }; 70 71 #define to_dci_obj(p) container_of(p, struct most_dci_obj, dev) 72 73 struct most_dev; 74 75 struct clear_hold_work { 76 struct work_struct ws; 77 struct most_dev *mdev; 78 unsigned int channel; 79 int pipe; 80 }; 81 82 #define to_clear_hold_work(w) container_of(w, struct clear_hold_work, ws) 83 84 /** 85 * struct most_dev - holds all usb interface specific stuff 86 * @usb_device: pointer to usb device 87 * @iface: hardware interface 88 * @cap: channel capabilities 89 * @conf: channel configuration 90 * @dci: direct communication interface of hardware 91 * @ep_address: endpoint address table 92 * @description: device description 93 * @suffix: suffix for channel name 94 * @channel_lock: synchronize channel access 95 * @padding_active: indicates channel uses padding 96 * @is_channel_healthy: health status table of each channel 97 * @busy_urbs: list of anchored items 98 * @io_mutex: synchronize I/O with disconnect 99 * @link_stat_timer: timer for link status reports 100 * @poll_work_obj: work for polling link status 101 */ 102 struct most_dev { 103 struct device dev; 104 struct usb_device *usb_device; 105 struct most_interface iface; 106 struct most_channel_capability *cap; 107 struct most_channel_config *conf; 108 struct most_dci_obj *dci; 109 u8 *ep_address; 110 char description[MAX_STRING_LEN]; 111 char suffix[MAX_NUM_ENDPOINTS][MAX_SUFFIX_LEN]; 112 spinlock_t channel_lock[MAX_NUM_ENDPOINTS]; /* sync channel access */ 113 bool padding_active[MAX_NUM_ENDPOINTS]; 114 bool is_channel_healthy[MAX_NUM_ENDPOINTS]; 115 struct clear_hold_work clear_work[MAX_NUM_ENDPOINTS]; 116 struct usb_anchor *busy_urbs; 117 struct mutex io_mutex; 118 struct timer_list link_stat_timer; 119 struct work_struct poll_work_obj; 120 void (*on_netinfo)(struct most_interface *most_iface, 121 unsigned char link_state, unsigned char *addrs); 122 }; 123 124 #define to_mdev(d) container_of(d, struct most_dev, iface) 125 #define to_mdev_from_dev(d) container_of(d, struct most_dev, dev) 126 #define to_mdev_from_work(w) container_of(w, struct most_dev, poll_work_obj) 127 128 static void wq_clear_halt(struct work_struct *wq_obj); 129 static void wq_netinfo(struct work_struct *wq_obj); 130 131 /** 132 * drci_rd_reg - read a DCI register 133 * @dev: usb device 134 * @reg: register address 135 * @buf: buffer to store data 136 * 137 * This is reads data from INIC's direct register communication interface 138 */ 139 static inline int drci_rd_reg(struct usb_device *dev, u16 reg, u16 *buf) 140 { 141 int retval; 142 __le16 *dma_buf; 143 u8 req_type = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE; 144 145 dma_buf = kzalloc(sizeof(*dma_buf), GFP_KERNEL); 146 if (!dma_buf) 147 return -ENOMEM; 148 149 retval = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 150 DRCI_READ_REQ, req_type, 151 0x0000, 152 reg, dma_buf, sizeof(*dma_buf), 153 USB_CTRL_GET_TIMEOUT); 154 *buf = le16_to_cpu(*dma_buf); 155 kfree(dma_buf); 156 157 if (retval < 0) 158 return retval; 159 return 0; 160 } 161 162 /** 163 * drci_wr_reg - write a DCI register 164 * @dev: usb device 165 * @reg: register address 166 * @data: data to write 167 * 168 * This is writes data to INIC's direct register communication interface 169 */ 170 static inline int drci_wr_reg(struct usb_device *dev, u16 reg, u16 data) 171 { 172 return usb_control_msg(dev, 173 usb_sndctrlpipe(dev, 0), 174 DRCI_WRITE_REQ, 175 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 176 data, 177 reg, 178 NULL, 179 0, 180 USB_CTRL_SET_TIMEOUT); 181 } 182 183 static inline int start_sync_ep(struct usb_device *usb_dev, u16 ep) 184 { 185 return drci_wr_reg(usb_dev, DRCI_REG_BASE + DRCI_COMMAND + ep * 16, 1); 186 } 187 188 /** 189 * get_stream_frame_size - calculate frame size of current configuration 190 * @dev: device structure 191 * @cfg: channel configuration 192 */ 193 static unsigned int get_stream_frame_size(struct device *dev, 194 struct most_channel_config *cfg) 195 { 196 unsigned int frame_size; 197 unsigned int sub_size = cfg->subbuffer_size; 198 199 if (!sub_size) { 200 dev_warn(dev, "Misconfig: Subbuffer size zero.\n"); 201 return 0; 202 } 203 switch (cfg->data_type) { 204 case MOST_CH_ISOC: 205 frame_size = AV_PACKETS_PER_XACT * sub_size; 206 break; 207 case MOST_CH_SYNC: 208 if (cfg->packets_per_xact == 0) { 209 dev_warn(dev, "Misconfig: Packets per XACT zero\n"); 210 frame_size = 0; 211 } else if (cfg->packets_per_xact == 0xFF) { 212 frame_size = (USB_MTU / sub_size) * sub_size; 213 } else { 214 frame_size = cfg->packets_per_xact * sub_size; 215 } 216 break; 217 default: 218 dev_warn(dev, "Query frame size of non-streaming channel\n"); 219 frame_size = 0; 220 break; 221 } 222 return frame_size; 223 } 224 225 /** 226 * hdm_poison_channel - mark buffers of this channel as invalid 227 * @iface: pointer to the interface 228 * @channel: channel ID 229 * 230 * This unlinks all URBs submitted to the HCD, 231 * calls the associated completion function of the core and removes 232 * them from the list. 233 * 234 * Returns 0 on success or error code otherwise. 235 */ 236 static int hdm_poison_channel(struct most_interface *iface, int channel) 237 { 238 struct most_dev *mdev = to_mdev(iface); 239 unsigned long flags; 240 spinlock_t *lock; /* temp. lock */ 241 242 if (channel < 0 || channel >= iface->num_channels) { 243 dev_warn(&mdev->usb_device->dev, "Channel ID out of range.\n"); 244 return -ECHRNG; 245 } 246 247 lock = mdev->channel_lock + channel; 248 spin_lock_irqsave(lock, flags); 249 mdev->is_channel_healthy[channel] = false; 250 spin_unlock_irqrestore(lock, flags); 251 252 cancel_work_sync(&mdev->clear_work[channel].ws); 253 254 mutex_lock(&mdev->io_mutex); 255 usb_kill_anchored_urbs(&mdev->busy_urbs[channel]); 256 if (mdev->padding_active[channel]) 257 mdev->padding_active[channel] = false; 258 259 if (mdev->conf[channel].data_type == MOST_CH_ASYNC) { 260 del_timer_sync(&mdev->link_stat_timer); 261 cancel_work_sync(&mdev->poll_work_obj); 262 } 263 mutex_unlock(&mdev->io_mutex); 264 return 0; 265 } 266 267 /** 268 * hdm_add_padding - add padding bytes 269 * @mdev: most device 270 * @channel: channel ID 271 * @mbo: buffer object 272 * 273 * This inserts the INIC hardware specific padding bytes into a streaming 274 * channel's buffer 275 */ 276 static int hdm_add_padding(struct most_dev *mdev, int channel, struct mbo *mbo) 277 { 278 struct most_channel_config *conf = &mdev->conf[channel]; 279 unsigned int frame_size = get_stream_frame_size(&mdev->dev, conf); 280 unsigned int j, num_frames; 281 282 if (!frame_size) 283 return -EINVAL; 284 num_frames = mbo->buffer_length / frame_size; 285 286 if (num_frames < 1) { 287 dev_err(&mdev->usb_device->dev, 288 "Missed minimal transfer unit.\n"); 289 return -EINVAL; 290 } 291 292 for (j = num_frames - 1; j > 0; j--) 293 memmove(mbo->virt_address + j * USB_MTU, 294 mbo->virt_address + j * frame_size, 295 frame_size); 296 mbo->buffer_length = num_frames * USB_MTU; 297 return 0; 298 } 299 300 /** 301 * hdm_remove_padding - remove padding bytes 302 * @mdev: most device 303 * @channel: channel ID 304 * @mbo: buffer object 305 * 306 * This takes the INIC hardware specific padding bytes off a streaming 307 * channel's buffer. 308 */ 309 static int hdm_remove_padding(struct most_dev *mdev, int channel, 310 struct mbo *mbo) 311 { 312 struct most_channel_config *const conf = &mdev->conf[channel]; 313 unsigned int frame_size = get_stream_frame_size(&mdev->dev, conf); 314 unsigned int j, num_frames; 315 316 if (!frame_size) 317 return -EINVAL; 318 num_frames = mbo->processed_length / USB_MTU; 319 320 for (j = 1; j < num_frames; j++) 321 memmove(mbo->virt_address + frame_size * j, 322 mbo->virt_address + USB_MTU * j, 323 frame_size); 324 325 mbo->processed_length = frame_size * num_frames; 326 return 0; 327 } 328 329 /** 330 * hdm_write_completion - completion function for submitted Tx URBs 331 * @urb: the URB that has been completed 332 * 333 * This checks the status of the completed URB. In case the URB has been 334 * unlinked before, it is immediately freed. On any other error the MBO 335 * transfer flag is set. On success it frees allocated resources and calls 336 * the completion function. 337 * 338 * Context: interrupt! 339 */ 340 static void hdm_write_completion(struct urb *urb) 341 { 342 struct mbo *mbo = urb->context; 343 struct most_dev *mdev = to_mdev(mbo->ifp); 344 unsigned int channel = mbo->hdm_channel_id; 345 spinlock_t *lock = mdev->channel_lock + channel; 346 unsigned long flags; 347 348 spin_lock_irqsave(lock, flags); 349 350 mbo->processed_length = 0; 351 mbo->status = MBO_E_INVAL; 352 if (likely(mdev->is_channel_healthy[channel])) { 353 switch (urb->status) { 354 case 0: 355 case -ESHUTDOWN: 356 mbo->processed_length = urb->actual_length; 357 mbo->status = MBO_SUCCESS; 358 break; 359 case -EPIPE: 360 dev_warn(&mdev->usb_device->dev, 361 "Broken pipe on ep%02x\n", 362 mdev->ep_address[channel]); 363 mdev->is_channel_healthy[channel] = false; 364 mdev->clear_work[channel].pipe = urb->pipe; 365 schedule_work(&mdev->clear_work[channel].ws); 366 break; 367 case -ENODEV: 368 case -EPROTO: 369 mbo->status = MBO_E_CLOSE; 370 break; 371 } 372 } 373 374 spin_unlock_irqrestore(lock, flags); 375 376 if (likely(mbo->complete)) 377 mbo->complete(mbo); 378 usb_free_urb(urb); 379 } 380 381 /** 382 * hdm_read_completion - completion function for submitted Rx URBs 383 * @urb: the URB that has been completed 384 * 385 * This checks the status of the completed URB. In case the URB has been 386 * unlinked before it is immediately freed. On any other error the MBO transfer 387 * flag is set. On success it frees allocated resources, removes 388 * padding bytes -if necessary- and calls the completion function. 389 * 390 * Context: interrupt! 391 */ 392 static void hdm_read_completion(struct urb *urb) 393 { 394 struct mbo *mbo = urb->context; 395 struct most_dev *mdev = to_mdev(mbo->ifp); 396 unsigned int channel = mbo->hdm_channel_id; 397 struct device *dev = &mdev->usb_device->dev; 398 spinlock_t *lock = mdev->channel_lock + channel; 399 unsigned long flags; 400 401 spin_lock_irqsave(lock, flags); 402 403 mbo->processed_length = 0; 404 mbo->status = MBO_E_INVAL; 405 if (likely(mdev->is_channel_healthy[channel])) { 406 switch (urb->status) { 407 case 0: 408 case -ESHUTDOWN: 409 mbo->processed_length = urb->actual_length; 410 mbo->status = MBO_SUCCESS; 411 if (mdev->padding_active[channel] && 412 hdm_remove_padding(mdev, channel, mbo)) { 413 mbo->processed_length = 0; 414 mbo->status = MBO_E_INVAL; 415 } 416 break; 417 case -EPIPE: 418 dev_warn(dev, "Broken pipe on ep%02x\n", 419 mdev->ep_address[channel]); 420 mdev->is_channel_healthy[channel] = false; 421 mdev->clear_work[channel].pipe = urb->pipe; 422 schedule_work(&mdev->clear_work[channel].ws); 423 break; 424 case -ENODEV: 425 case -EPROTO: 426 mbo->status = MBO_E_CLOSE; 427 break; 428 case -EOVERFLOW: 429 dev_warn(dev, "Babble on ep%02x\n", 430 mdev->ep_address[channel]); 431 break; 432 } 433 } 434 435 spin_unlock_irqrestore(lock, flags); 436 437 if (likely(mbo->complete)) 438 mbo->complete(mbo); 439 usb_free_urb(urb); 440 } 441 442 /** 443 * hdm_enqueue - receive a buffer to be used for data transfer 444 * @iface: interface to enqueue to 445 * @channel: ID of the channel 446 * @mbo: pointer to the buffer object 447 * 448 * This allocates a new URB and fills it according to the channel 449 * that is being used for transmission of data. Before the URB is 450 * submitted it is stored in the private anchor list. 451 * 452 * Returns 0 on success. On any error the URB is freed and a error code 453 * is returned. 454 * 455 * Context: Could in _some_ cases be interrupt! 456 */ 457 static int hdm_enqueue(struct most_interface *iface, int channel, 458 struct mbo *mbo) 459 { 460 struct most_dev *mdev = to_mdev(iface); 461 struct most_channel_config *conf; 462 int retval = 0; 463 struct urb *urb; 464 unsigned long length; 465 void *virt_address; 466 467 if (!mbo) 468 return -EINVAL; 469 if (iface->num_channels <= channel || channel < 0) 470 return -ECHRNG; 471 472 urb = usb_alloc_urb(NO_ISOCHRONOUS_URB, GFP_KERNEL); 473 if (!urb) 474 return -ENOMEM; 475 476 conf = &mdev->conf[channel]; 477 478 mutex_lock(&mdev->io_mutex); 479 if (!mdev->usb_device) { 480 retval = -ENODEV; 481 goto err_free_urb; 482 } 483 484 if ((conf->direction & MOST_CH_TX) && mdev->padding_active[channel] && 485 hdm_add_padding(mdev, channel, mbo)) { 486 retval = -EINVAL; 487 goto err_free_urb; 488 } 489 490 urb->transfer_dma = mbo->bus_address; 491 virt_address = mbo->virt_address; 492 length = mbo->buffer_length; 493 494 if (conf->direction & MOST_CH_TX) { 495 usb_fill_bulk_urb(urb, mdev->usb_device, 496 usb_sndbulkpipe(mdev->usb_device, 497 mdev->ep_address[channel]), 498 virt_address, 499 length, 500 hdm_write_completion, 501 mbo); 502 if (conf->data_type != MOST_CH_ISOC && 503 conf->data_type != MOST_CH_SYNC) 504 urb->transfer_flags |= URB_ZERO_PACKET; 505 } else { 506 usb_fill_bulk_urb(urb, mdev->usb_device, 507 usb_rcvbulkpipe(mdev->usb_device, 508 mdev->ep_address[channel]), 509 virt_address, 510 length + conf->extra_len, 511 hdm_read_completion, 512 mbo); 513 } 514 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 515 516 usb_anchor_urb(urb, &mdev->busy_urbs[channel]); 517 518 retval = usb_submit_urb(urb, GFP_KERNEL); 519 if (retval) { 520 dev_err(&mdev->usb_device->dev, 521 "URB submit failed with error %d.\n", retval); 522 goto err_unanchor_urb; 523 } 524 mutex_unlock(&mdev->io_mutex); 525 return 0; 526 527 err_unanchor_urb: 528 usb_unanchor_urb(urb); 529 err_free_urb: 530 usb_free_urb(urb); 531 mutex_unlock(&mdev->io_mutex); 532 return retval; 533 } 534 535 static void *hdm_dma_alloc(struct mbo *mbo, u32 size) 536 { 537 struct most_dev *mdev = to_mdev(mbo->ifp); 538 539 return usb_alloc_coherent(mdev->usb_device, size, GFP_KERNEL, 540 &mbo->bus_address); 541 } 542 543 static void hdm_dma_free(struct mbo *mbo, u32 size) 544 { 545 struct most_dev *mdev = to_mdev(mbo->ifp); 546 547 usb_free_coherent(mdev->usb_device, size, mbo->virt_address, 548 mbo->bus_address); 549 } 550 551 /** 552 * hdm_configure_channel - receive channel configuration from core 553 * @iface: interface 554 * @channel: channel ID 555 * @conf: structure that holds the configuration information 556 * 557 * The attached network interface controller (NIC) supports a padding mode 558 * to avoid short packets on USB, hence increasing the performance due to a 559 * lower interrupt load. This mode is default for synchronous data and can 560 * be switched on for isochronous data. In case padding is active the 561 * driver needs to know the frame size of the payload in order to calculate 562 * the number of bytes it needs to pad when transmitting or to cut off when 563 * receiving data. 564 * 565 */ 566 static int hdm_configure_channel(struct most_interface *iface, int channel, 567 struct most_channel_config *conf) 568 { 569 unsigned int num_frames; 570 unsigned int frame_size; 571 struct most_dev *mdev = to_mdev(iface); 572 struct device *dev = &mdev->usb_device->dev; 573 574 if (!conf) { 575 dev_err(dev, "Bad config pointer.\n"); 576 return -EINVAL; 577 } 578 if (channel < 0 || channel >= iface->num_channels) { 579 dev_err(dev, "Channel ID out of range.\n"); 580 return -EINVAL; 581 } 582 583 mdev->is_channel_healthy[channel] = true; 584 mdev->clear_work[channel].channel = channel; 585 mdev->clear_work[channel].mdev = mdev; 586 INIT_WORK(&mdev->clear_work[channel].ws, wq_clear_halt); 587 588 if (!conf->num_buffers || !conf->buffer_size) { 589 dev_err(dev, "Misconfig: buffer size or #buffers zero.\n"); 590 return -EINVAL; 591 } 592 593 if (conf->data_type != MOST_CH_SYNC && 594 !(conf->data_type == MOST_CH_ISOC && 595 conf->packets_per_xact != 0xFF)) { 596 mdev->padding_active[channel] = false; 597 /* 598 * Since the NIC's padding mode is not going to be 599 * used, we can skip the frame size calculations and 600 * move directly on to exit. 601 */ 602 goto exit; 603 } 604 605 mdev->padding_active[channel] = true; 606 607 frame_size = get_stream_frame_size(&mdev->dev, conf); 608 if (frame_size == 0 || frame_size > USB_MTU) { 609 dev_warn(dev, "Misconfig: frame size wrong\n"); 610 return -EINVAL; 611 } 612 613 num_frames = conf->buffer_size / frame_size; 614 615 if (conf->buffer_size % frame_size) { 616 u16 old_size = conf->buffer_size; 617 618 conf->buffer_size = num_frames * frame_size; 619 dev_warn(dev, "%s: fixed buffer size (%d -> %d)\n", 620 mdev->suffix[channel], old_size, conf->buffer_size); 621 } 622 623 /* calculate extra length to comply w/ HW padding */ 624 conf->extra_len = num_frames * (USB_MTU - frame_size); 625 626 exit: 627 mdev->conf[channel] = *conf; 628 if (conf->data_type == MOST_CH_ASYNC) { 629 u16 ep = mdev->ep_address[channel]; 630 631 if (start_sync_ep(mdev->usb_device, ep) < 0) 632 dev_warn(dev, "sync for ep%02x failed", ep); 633 } 634 return 0; 635 } 636 637 /** 638 * hdm_request_netinfo - request network information 639 * @iface: pointer to interface 640 * @channel: channel ID 641 * 642 * This is used as trigger to set up the link status timer that 643 * polls for the NI state of the INIC every 2 seconds. 644 * 645 */ 646 static void hdm_request_netinfo(struct most_interface *iface, int channel, 647 void (*on_netinfo)(struct most_interface *, 648 unsigned char, 649 unsigned char *)) 650 { 651 struct most_dev *mdev = to_mdev(iface); 652 653 mdev->on_netinfo = on_netinfo; 654 if (!on_netinfo) 655 return; 656 657 mdev->link_stat_timer.expires = jiffies + HZ; 658 mod_timer(&mdev->link_stat_timer, mdev->link_stat_timer.expires); 659 } 660 661 /** 662 * link_stat_timer_handler - schedule work obtaining mac address and link status 663 * @data: pointer to USB device instance 664 * 665 * The handler runs in interrupt context. That's why we need to defer the 666 * tasks to a work queue. 667 */ 668 static void link_stat_timer_handler(struct timer_list *t) 669 { 670 struct most_dev *mdev = from_timer(mdev, t, link_stat_timer); 671 672 schedule_work(&mdev->poll_work_obj); 673 mdev->link_stat_timer.expires = jiffies + (2 * HZ); 674 add_timer(&mdev->link_stat_timer); 675 } 676 677 /** 678 * wq_netinfo - work queue function to deliver latest networking information 679 * @wq_obj: object that holds data for our deferred work to do 680 * 681 * This retrieves the network interface status of the USB INIC 682 */ 683 static void wq_netinfo(struct work_struct *wq_obj) 684 { 685 struct most_dev *mdev = to_mdev_from_work(wq_obj); 686 struct usb_device *usb_device = mdev->usb_device; 687 struct device *dev = &usb_device->dev; 688 u16 hi, mi, lo, link; 689 u8 hw_addr[6]; 690 691 if (drci_rd_reg(usb_device, DRCI_REG_HW_ADDR_HI, &hi)) { 692 dev_err(dev, "Vendor request 'hw_addr_hi' failed\n"); 693 return; 694 } 695 696 if (drci_rd_reg(usb_device, DRCI_REG_HW_ADDR_MI, &mi)) { 697 dev_err(dev, "Vendor request 'hw_addr_mid' failed\n"); 698 return; 699 } 700 701 if (drci_rd_reg(usb_device, DRCI_REG_HW_ADDR_LO, &lo)) { 702 dev_err(dev, "Vendor request 'hw_addr_low' failed\n"); 703 return; 704 } 705 706 if (drci_rd_reg(usb_device, DRCI_REG_NI_STATE, &link)) { 707 dev_err(dev, "Vendor request 'link status' failed\n"); 708 return; 709 } 710 711 hw_addr[0] = hi >> 8; 712 hw_addr[1] = hi; 713 hw_addr[2] = mi >> 8; 714 hw_addr[3] = mi; 715 hw_addr[4] = lo >> 8; 716 hw_addr[5] = lo; 717 718 if (mdev->on_netinfo) 719 mdev->on_netinfo(&mdev->iface, link, hw_addr); 720 } 721 722 /** 723 * wq_clear_halt - work queue function 724 * @wq_obj: work_struct object to execute 725 * 726 * This sends a clear_halt to the given USB pipe. 727 */ 728 static void wq_clear_halt(struct work_struct *wq_obj) 729 { 730 struct clear_hold_work *clear_work = to_clear_hold_work(wq_obj); 731 struct most_dev *mdev = clear_work->mdev; 732 unsigned int channel = clear_work->channel; 733 int pipe = clear_work->pipe; 734 int snd_pipe; 735 int peer; 736 737 mutex_lock(&mdev->io_mutex); 738 most_stop_enqueue(&mdev->iface, channel); 739 usb_kill_anchored_urbs(&mdev->busy_urbs[channel]); 740 if (usb_clear_halt(mdev->usb_device, pipe)) 741 dev_warn(&mdev->usb_device->dev, "Failed to reset endpoint.\n"); 742 743 /* If the functional Stall condition has been set on an 744 * asynchronous rx channel, we need to clear the tx channel 745 * too, since the hardware runs its clean-up sequence on both 746 * channels, as they are physically one on the network. 747 * 748 * The USB interface that exposes the asynchronous channels 749 * contains always two endpoints, and two only. 750 */ 751 if (mdev->conf[channel].data_type == MOST_CH_ASYNC && 752 mdev->conf[channel].direction == MOST_CH_RX) { 753 if (channel == 0) 754 peer = 1; 755 else 756 peer = 0; 757 snd_pipe = usb_sndbulkpipe(mdev->usb_device, 758 mdev->ep_address[peer]); 759 usb_clear_halt(mdev->usb_device, snd_pipe); 760 } 761 mdev->is_channel_healthy[channel] = true; 762 most_resume_enqueue(&mdev->iface, channel); 763 mutex_unlock(&mdev->io_mutex); 764 } 765 766 /** 767 * hdm_usb_fops - file operation table for USB driver 768 */ 769 static const struct file_operations hdm_usb_fops = { 770 .owner = THIS_MODULE, 771 }; 772 773 /** 774 * usb_device_id - ID table for HCD device probing 775 */ 776 static const struct usb_device_id usbid[] = { 777 { USB_DEVICE(USB_VENDOR_ID_SMSC, USB_DEV_ID_BRDG), }, 778 { USB_DEVICE(USB_VENDOR_ID_SMSC, USB_DEV_ID_OS81118), }, 779 { USB_DEVICE(USB_VENDOR_ID_SMSC, USB_DEV_ID_OS81119), }, 780 { USB_DEVICE(USB_VENDOR_ID_SMSC, USB_DEV_ID_OS81210), }, 781 { } /* Terminating entry */ 782 }; 783 784 struct regs { 785 const char *name; 786 u16 reg; 787 }; 788 789 static const struct regs ro_regs[] = { 790 { "ni_state", DRCI_REG_NI_STATE }, 791 { "packet_bandwidth", DRCI_REG_PACKET_BW }, 792 { "node_address", DRCI_REG_NODE_ADDR }, 793 { "node_position", DRCI_REG_NODE_POS }, 794 }; 795 796 static const struct regs rw_regs[] = { 797 { "mep_filter", DRCI_REG_MEP_FILTER }, 798 { "mep_hash0", DRCI_REG_HASH_TBL0 }, 799 { "mep_hash1", DRCI_REG_HASH_TBL1 }, 800 { "mep_hash2", DRCI_REG_HASH_TBL2 }, 801 { "mep_hash3", DRCI_REG_HASH_TBL3 }, 802 { "mep_eui48_hi", DRCI_REG_HW_ADDR_HI }, 803 { "mep_eui48_mi", DRCI_REG_HW_ADDR_MI }, 804 { "mep_eui48_lo", DRCI_REG_HW_ADDR_LO }, 805 }; 806 807 static int get_stat_reg_addr(const struct regs *regs, int size, 808 const char *name, u16 *reg_addr) 809 { 810 int i; 811 812 for (i = 0; i < size; i++) { 813 if (sysfs_streq(name, regs[i].name)) { 814 *reg_addr = regs[i].reg; 815 return 0; 816 } 817 } 818 return -EINVAL; 819 } 820 821 #define get_static_reg_addr(regs, name, reg_addr) \ 822 get_stat_reg_addr(regs, ARRAY_SIZE(regs), name, reg_addr) 823 824 static ssize_t value_show(struct device *dev, struct device_attribute *attr, 825 char *buf) 826 { 827 const char *name = attr->attr.name; 828 struct most_dci_obj *dci_obj = to_dci_obj(dev); 829 u16 val; 830 u16 reg_addr; 831 int err; 832 833 if (sysfs_streq(name, "arb_address")) 834 return sysfs_emit(buf, "%04x\n", dci_obj->reg_addr); 835 836 if (sysfs_streq(name, "arb_value")) 837 reg_addr = dci_obj->reg_addr; 838 else if (get_static_reg_addr(ro_regs, name, ®_addr) && 839 get_static_reg_addr(rw_regs, name, ®_addr)) 840 return -EINVAL; 841 842 err = drci_rd_reg(dci_obj->usb_device, reg_addr, &val); 843 if (err < 0) 844 return err; 845 846 return sysfs_emit(buf, "%04x\n", val); 847 } 848 849 static ssize_t value_store(struct device *dev, struct device_attribute *attr, 850 const char *buf, size_t count) 851 { 852 u16 val; 853 u16 reg_addr; 854 const char *name = attr->attr.name; 855 struct most_dci_obj *dci_obj = to_dci_obj(dev); 856 struct usb_device *usb_dev = dci_obj->usb_device; 857 int err; 858 859 err = kstrtou16(buf, 16, &val); 860 if (err) 861 return err; 862 863 if (sysfs_streq(name, "arb_address")) { 864 dci_obj->reg_addr = val; 865 return count; 866 } 867 868 if (sysfs_streq(name, "arb_value")) 869 err = drci_wr_reg(usb_dev, dci_obj->reg_addr, val); 870 else if (sysfs_streq(name, "sync_ep")) 871 err = start_sync_ep(usb_dev, val); 872 else if (!get_static_reg_addr(rw_regs, name, ®_addr)) 873 err = drci_wr_reg(usb_dev, reg_addr, val); 874 else 875 return -EINVAL; 876 877 if (err < 0) 878 return err; 879 880 return count; 881 } 882 883 static DEVICE_ATTR(ni_state, 0444, value_show, NULL); 884 static DEVICE_ATTR(packet_bandwidth, 0444, value_show, NULL); 885 static DEVICE_ATTR(node_address, 0444, value_show, NULL); 886 static DEVICE_ATTR(node_position, 0444, value_show, NULL); 887 static DEVICE_ATTR(sync_ep, 0200, NULL, value_store); 888 static DEVICE_ATTR(mep_filter, 0644, value_show, value_store); 889 static DEVICE_ATTR(mep_hash0, 0644, value_show, value_store); 890 static DEVICE_ATTR(mep_hash1, 0644, value_show, value_store); 891 static DEVICE_ATTR(mep_hash2, 0644, value_show, value_store); 892 static DEVICE_ATTR(mep_hash3, 0644, value_show, value_store); 893 static DEVICE_ATTR(mep_eui48_hi, 0644, value_show, value_store); 894 static DEVICE_ATTR(mep_eui48_mi, 0644, value_show, value_store); 895 static DEVICE_ATTR(mep_eui48_lo, 0644, value_show, value_store); 896 static DEVICE_ATTR(arb_address, 0644, value_show, value_store); 897 static DEVICE_ATTR(arb_value, 0644, value_show, value_store); 898 899 static struct attribute *dci_attrs[] = { 900 &dev_attr_ni_state.attr, 901 &dev_attr_packet_bandwidth.attr, 902 &dev_attr_node_address.attr, 903 &dev_attr_node_position.attr, 904 &dev_attr_sync_ep.attr, 905 &dev_attr_mep_filter.attr, 906 &dev_attr_mep_hash0.attr, 907 &dev_attr_mep_hash1.attr, 908 &dev_attr_mep_hash2.attr, 909 &dev_attr_mep_hash3.attr, 910 &dev_attr_mep_eui48_hi.attr, 911 &dev_attr_mep_eui48_mi.attr, 912 &dev_attr_mep_eui48_lo.attr, 913 &dev_attr_arb_address.attr, 914 &dev_attr_arb_value.attr, 915 NULL, 916 }; 917 918 ATTRIBUTE_GROUPS(dci); 919 920 static void release_dci(struct device *dev) 921 { 922 struct most_dci_obj *dci = to_dci_obj(dev); 923 924 put_device(dev->parent); 925 kfree(dci); 926 } 927 928 static void release_mdev(struct device *dev) 929 { 930 struct most_dev *mdev = to_mdev_from_dev(dev); 931 932 kfree(mdev); 933 } 934 /** 935 * hdm_probe - probe function of USB device driver 936 * @interface: Interface of the attached USB device 937 * @id: Pointer to the USB ID table. 938 * 939 * This allocates and initializes the device instance, adds the new 940 * entry to the internal list, scans the USB descriptors and registers 941 * the interface with the core. 942 * Additionally, the DCI objects are created and the hardware is sync'd. 943 * 944 * Return 0 on success. In case of an error a negative number is returned. 945 */ 946 static int 947 hdm_probe(struct usb_interface *interface, const struct usb_device_id *id) 948 { 949 struct usb_host_interface *usb_iface_desc = interface->cur_altsetting; 950 struct usb_device *usb_dev = interface_to_usbdev(interface); 951 struct device *dev = &usb_dev->dev; 952 struct most_dev *mdev; 953 unsigned int i; 954 unsigned int num_endpoints; 955 struct most_channel_capability *tmp_cap; 956 struct usb_endpoint_descriptor *ep_desc; 957 int ret = -ENOMEM; 958 959 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); 960 if (!mdev) 961 return -ENOMEM; 962 963 usb_set_intfdata(interface, mdev); 964 num_endpoints = usb_iface_desc->desc.bNumEndpoints; 965 if (num_endpoints > MAX_NUM_ENDPOINTS) { 966 kfree(mdev); 967 return -EINVAL; 968 } 969 mutex_init(&mdev->io_mutex); 970 INIT_WORK(&mdev->poll_work_obj, wq_netinfo); 971 timer_setup(&mdev->link_stat_timer, link_stat_timer_handler, 0); 972 973 mdev->usb_device = usb_dev; 974 mdev->link_stat_timer.expires = jiffies + (2 * HZ); 975 976 mdev->iface.mod = hdm_usb_fops.owner; 977 mdev->iface.dev = &mdev->dev; 978 mdev->iface.driver_dev = &interface->dev; 979 mdev->iface.interface = ITYPE_USB; 980 mdev->iface.configure = hdm_configure_channel; 981 mdev->iface.request_netinfo = hdm_request_netinfo; 982 mdev->iface.enqueue = hdm_enqueue; 983 mdev->iface.poison_channel = hdm_poison_channel; 984 mdev->iface.dma_alloc = hdm_dma_alloc; 985 mdev->iface.dma_free = hdm_dma_free; 986 mdev->iface.description = mdev->description; 987 mdev->iface.num_channels = num_endpoints; 988 989 snprintf(mdev->description, sizeof(mdev->description), 990 "%d-%s:%d.%d", 991 usb_dev->bus->busnum, 992 usb_dev->devpath, 993 usb_dev->config->desc.bConfigurationValue, 994 usb_iface_desc->desc.bInterfaceNumber); 995 996 mdev->dev.init_name = mdev->description; 997 mdev->dev.parent = &interface->dev; 998 mdev->dev.release = release_mdev; 999 mdev->conf = kcalloc(num_endpoints, sizeof(*mdev->conf), GFP_KERNEL); 1000 if (!mdev->conf) 1001 goto err_free_mdev; 1002 1003 mdev->cap = kcalloc(num_endpoints, sizeof(*mdev->cap), GFP_KERNEL); 1004 if (!mdev->cap) 1005 goto err_free_conf; 1006 1007 mdev->iface.channel_vector = mdev->cap; 1008 mdev->ep_address = 1009 kcalloc(num_endpoints, sizeof(*mdev->ep_address), GFP_KERNEL); 1010 if (!mdev->ep_address) 1011 goto err_free_cap; 1012 1013 mdev->busy_urbs = 1014 kcalloc(num_endpoints, sizeof(*mdev->busy_urbs), GFP_KERNEL); 1015 if (!mdev->busy_urbs) 1016 goto err_free_ep_address; 1017 1018 tmp_cap = mdev->cap; 1019 for (i = 0; i < num_endpoints; i++) { 1020 ep_desc = &usb_iface_desc->endpoint[i].desc; 1021 mdev->ep_address[i] = ep_desc->bEndpointAddress; 1022 mdev->padding_active[i] = false; 1023 mdev->is_channel_healthy[i] = true; 1024 1025 snprintf(&mdev->suffix[i][0], MAX_SUFFIX_LEN, "ep%02x", 1026 mdev->ep_address[i]); 1027 1028 tmp_cap->name_suffix = &mdev->suffix[i][0]; 1029 tmp_cap->buffer_size_packet = MAX_BUF_SIZE; 1030 tmp_cap->buffer_size_streaming = MAX_BUF_SIZE; 1031 tmp_cap->num_buffers_packet = BUF_CHAIN_SIZE; 1032 tmp_cap->num_buffers_streaming = BUF_CHAIN_SIZE; 1033 tmp_cap->data_type = MOST_CH_CONTROL | MOST_CH_ASYNC | 1034 MOST_CH_ISOC | MOST_CH_SYNC; 1035 if (usb_endpoint_dir_in(ep_desc)) 1036 tmp_cap->direction = MOST_CH_RX; 1037 else 1038 tmp_cap->direction = MOST_CH_TX; 1039 tmp_cap++; 1040 init_usb_anchor(&mdev->busy_urbs[i]); 1041 spin_lock_init(&mdev->channel_lock[i]); 1042 } 1043 dev_dbg(dev, "claimed gadget: Vendor=%4.4x ProdID=%4.4x Bus=%02x Device=%02x\n", 1044 le16_to_cpu(usb_dev->descriptor.idVendor), 1045 le16_to_cpu(usb_dev->descriptor.idProduct), 1046 usb_dev->bus->busnum, 1047 usb_dev->devnum); 1048 1049 dev_dbg(dev, "device path: /sys/bus/usb/devices/%d-%s:%d.%d\n", 1050 usb_dev->bus->busnum, 1051 usb_dev->devpath, 1052 usb_dev->config->desc.bConfigurationValue, 1053 usb_iface_desc->desc.bInterfaceNumber); 1054 1055 ret = most_register_interface(&mdev->iface); 1056 if (ret) 1057 goto err_free_busy_urbs; 1058 1059 mutex_lock(&mdev->io_mutex); 1060 if (le16_to_cpu(usb_dev->descriptor.idProduct) == USB_DEV_ID_OS81118 || 1061 le16_to_cpu(usb_dev->descriptor.idProduct) == USB_DEV_ID_OS81119 || 1062 le16_to_cpu(usb_dev->descriptor.idProduct) == USB_DEV_ID_OS81210) { 1063 mdev->dci = kzalloc(sizeof(*mdev->dci), GFP_KERNEL); 1064 if (!mdev->dci) { 1065 mutex_unlock(&mdev->io_mutex); 1066 most_deregister_interface(&mdev->iface); 1067 ret = -ENOMEM; 1068 goto err_free_busy_urbs; 1069 } 1070 1071 mdev->dci->dev.init_name = "dci"; 1072 mdev->dci->dev.parent = get_device(mdev->iface.dev); 1073 mdev->dci->dev.groups = dci_groups; 1074 mdev->dci->dev.release = release_dci; 1075 if (device_register(&mdev->dci->dev)) { 1076 mutex_unlock(&mdev->io_mutex); 1077 most_deregister_interface(&mdev->iface); 1078 ret = -ENOMEM; 1079 goto err_free_dci; 1080 } 1081 mdev->dci->usb_device = mdev->usb_device; 1082 } 1083 mutex_unlock(&mdev->io_mutex); 1084 return 0; 1085 err_free_dci: 1086 put_device(&mdev->dci->dev); 1087 err_free_busy_urbs: 1088 kfree(mdev->busy_urbs); 1089 err_free_ep_address: 1090 kfree(mdev->ep_address); 1091 err_free_cap: 1092 kfree(mdev->cap); 1093 err_free_conf: 1094 kfree(mdev->conf); 1095 err_free_mdev: 1096 put_device(&mdev->dev); 1097 return ret; 1098 } 1099 1100 /** 1101 * hdm_disconnect - disconnect function of USB device driver 1102 * @interface: Interface of the attached USB device 1103 * 1104 * This deregisters the interface with the core, removes the kernel timer 1105 * and frees resources. 1106 * 1107 * Context: hub kernel thread 1108 */ 1109 static void hdm_disconnect(struct usb_interface *interface) 1110 { 1111 struct most_dev *mdev = usb_get_intfdata(interface); 1112 1113 mutex_lock(&mdev->io_mutex); 1114 usb_set_intfdata(interface, NULL); 1115 mdev->usb_device = NULL; 1116 mutex_unlock(&mdev->io_mutex); 1117 1118 del_timer_sync(&mdev->link_stat_timer); 1119 cancel_work_sync(&mdev->poll_work_obj); 1120 1121 if (mdev->dci) 1122 device_unregister(&mdev->dci->dev); 1123 most_deregister_interface(&mdev->iface); 1124 1125 kfree(mdev->busy_urbs); 1126 kfree(mdev->cap); 1127 kfree(mdev->conf); 1128 kfree(mdev->ep_address); 1129 put_device(&mdev->dci->dev); 1130 put_device(&mdev->dev); 1131 } 1132 1133 static int hdm_suspend(struct usb_interface *interface, pm_message_t message) 1134 { 1135 struct most_dev *mdev = usb_get_intfdata(interface); 1136 int i; 1137 1138 mutex_lock(&mdev->io_mutex); 1139 for (i = 0; i < mdev->iface.num_channels; i++) { 1140 most_stop_enqueue(&mdev->iface, i); 1141 usb_kill_anchored_urbs(&mdev->busy_urbs[i]); 1142 } 1143 mutex_unlock(&mdev->io_mutex); 1144 return 0; 1145 } 1146 1147 static int hdm_resume(struct usb_interface *interface) 1148 { 1149 struct most_dev *mdev = usb_get_intfdata(interface); 1150 int i; 1151 1152 mutex_lock(&mdev->io_mutex); 1153 for (i = 0; i < mdev->iface.num_channels; i++) 1154 most_resume_enqueue(&mdev->iface, i); 1155 mutex_unlock(&mdev->io_mutex); 1156 return 0; 1157 } 1158 1159 static struct usb_driver hdm_usb = { 1160 .name = "hdm_usb", 1161 .id_table = usbid, 1162 .probe = hdm_probe, 1163 .disconnect = hdm_disconnect, 1164 .resume = hdm_resume, 1165 .suspend = hdm_suspend, 1166 }; 1167 1168 module_usb_driver(hdm_usb); 1169 MODULE_LICENSE("GPL"); 1170 MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>"); 1171 MODULE_DESCRIPTION("HDM_4_USB"); 1172