1172 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * usb.c - Hardware dependent module for USB4 *5 * Copyright (C) 2013-2015 Microchip Technology Germany II GmbH & Co. KG6 */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 51228#define NO_ISOCHRONOUS_URB 029#define AV_PACKETS_PER_XACT 230#define BUF_CHAIN_SIZE 0xFFFF31#define MAX_NUM_ENDPOINTS 3032#define MAX_SUFFIX_LEN 1033#define MAX_STRING_LEN 8034#define MAX_BUF_SIZE 0xFFFF35 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 0x010043#define DRCI_REG_PACKET_BW 0x010144#define DRCI_REG_NODE_ADDR 0x010245#define DRCI_REG_NODE_POS 0x010346#define DRCI_REG_MEP_FILTER 0x014047#define DRCI_REG_HASH_TBL0 0x014148#define DRCI_REG_HASH_TBL1 0x014249#define DRCI_REG_HASH_TBL2 0x014350#define DRCI_REG_HASH_TBL3 0x014451#define DRCI_REG_HW_ADDR_HI 0x014552#define DRCI_REG_HW_ADDR_MI 0x014653#define DRCI_REG_HW_ADDR_LO 0x014754#define DRCI_REG_BASE 0x110055#define DRCI_COMMAND 0x0256#define DRCI_READ_REQ 0xA057#define DRCI_WRITE_REQ 0xA158 59/**60 * struct most_dci_obj - Direct Communication Interface61 * @kobj:position in sysfs62 * @usb_device: pointer to the usb device63 * @reg_addr: register address for arbitrary DCI access64 */65struct 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 73struct most_dev;74 75struct 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 stuff86 * @usb_device: pointer to usb device87 * @iface: hardware interface88 * @cap: channel capabilities89 * @conf: channel configuration90 * @dci: direct communication interface of hardware91 * @ep_address: endpoint address table92 * @description: device description93 * @suffix: suffix for channel name94 * @channel_lock: synchronize channel access95 * @padding_active: indicates channel uses padding96 * @is_channel_healthy: health status table of each channel97 * @busy_urbs: list of anchored items98 * @io_mutex: synchronize I/O with disconnect99 * @link_stat_timer: timer for link status reports100 * @poll_work_obj: work for polling link status101 */102struct 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 128static void wq_clear_halt(struct work_struct *wq_obj);129static void wq_netinfo(struct work_struct *wq_obj);130 131/**132 * drci_rd_reg - read a DCI register133 * @dev: usb device134 * @reg: register address135 * @buf: buffer to store data136 *137 * This is reads data from INIC's direct register communication interface138 */139static 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 register164 * @dev: usb device165 * @reg: register address166 * @data: data to write167 *168 * This is writes data to INIC's direct register communication interface169 */170static 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 183static 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 configuration190 * @dev: device structure191 * @cfg: channel configuration192 */193static 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 invalid227 * @iface: pointer to the interface228 * @channel: channel ID229 *230 * This unlinks all URBs submitted to the HCD,231 * calls the associated completion function of the core and removes232 * them from the list.233 *234 * Returns 0 on success or error code otherwise.235 */236static 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 bytes269 * @mdev: most device270 * @channel: channel ID271 * @mbo: buffer object272 *273 * This inserts the INIC hardware specific padding bytes into a streaming274 * channel's buffer275 */276static 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 bytes302 * @mdev: most device303 * @channel: channel ID304 * @mbo: buffer object305 *306 * This takes the INIC hardware specific padding bytes off a streaming307 * channel's buffer.308 */309static 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 URBs331 * @urb: the URB that has been completed332 *333 * This checks the status of the completed URB. In case the URB has been334 * unlinked before, it is immediately freed. On any other error the MBO335 * transfer flag is set. On success it frees allocated resources and calls336 * the completion function.337 *338 * Context: interrupt!339 */340static 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 URBs383 * @urb: the URB that has been completed384 *385 * This checks the status of the completed URB. In case the URB has been386 * unlinked before it is immediately freed. On any other error the MBO transfer387 * flag is set. On success it frees allocated resources, removes388 * padding bytes -if necessary- and calls the completion function.389 *390 * Context: interrupt!391 */392static 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 transfer444 * @iface: interface to enqueue to445 * @channel: ID of the channel446 * @mbo: pointer to the buffer object447 *448 * This allocates a new URB and fills it according to the channel449 * that is being used for transmission of data. Before the URB is450 * 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 code453 * is returned.454 *455 * Context: Could in _some_ cases be interrupt!456 */457static 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 527err_unanchor_urb:528 usb_unanchor_urb(urb);529err_free_urb:530 usb_free_urb(urb);531 mutex_unlock(&mdev->io_mutex);532 return retval;533}534 535static 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 543static 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 core553 * @iface: interface554 * @channel: channel ID555 * @conf: structure that holds the configuration information556 *557 * The attached network interface controller (NIC) supports a padding mode558 * to avoid short packets on USB, hence increasing the performance due to a559 * lower interrupt load. This mode is default for synchronous data and can560 * be switched on for isochronous data. In case padding is active the561 * driver needs to know the frame size of the payload in order to calculate562 * the number of bytes it needs to pad when transmitting or to cut off when563 * receiving data.564 *565 */566static 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 be599 * used, we can skip the frame size calculations and600 * 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 626exit: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 information639 * @iface: pointer to interface640 * @channel: channel ID641 *642 * This is used as trigger to set up the link status timer that643 * polls for the NI state of the INIC every 2 seconds.644 *645 */646static 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 status663 * @t: pointer to timer_list which holds a pointer to the USB device instance664 *665 * The handler runs in interrupt context. That's why we need to defer the666 * tasks to a work queue.667 */668static 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 information679 * @wq_obj: object that holds data for our deferred work to do680 *681 * This retrieves the network interface status of the USB INIC682 */683static 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 function724 * @wq_obj: work_struct object to execute725 *726 * This sends a clear_halt to the given USB pipe.727 */728static 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 an744 * asynchronous rx channel, we need to clear the tx channel745 * too, since the hardware runs its clean-up sequence on both746 * channels, as they are physically one on the network.747 *748 * The USB interface that exposes the asynchronous channels749 * 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 else756 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 driver768 */769static const struct file_operations hdm_usb_fops = {770 .owner = THIS_MODULE,771};772 773/*774 * usb_device_id - ID table for HCD device probing775 */776static 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 784struct regs {785 const char *name;786 u16 reg;787};788 789static 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 796static 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 807static 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 824static 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 849static 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 else875 return -EINVAL;876 877 if (err < 0)878 return err;879 880 return count;881}882 883static DEVICE_ATTR(ni_state, 0444, value_show, NULL);884static DEVICE_ATTR(packet_bandwidth, 0444, value_show, NULL);885static DEVICE_ATTR(node_address, 0444, value_show, NULL);886static DEVICE_ATTR(node_position, 0444, value_show, NULL);887static DEVICE_ATTR(sync_ep, 0200, NULL, value_store);888static DEVICE_ATTR(mep_filter, 0644, value_show, value_store);889static DEVICE_ATTR(mep_hash0, 0644, value_show, value_store);890static DEVICE_ATTR(mep_hash1, 0644, value_show, value_store);891static DEVICE_ATTR(mep_hash2, 0644, value_show, value_store);892static DEVICE_ATTR(mep_hash3, 0644, value_show, value_store);893static DEVICE_ATTR(mep_eui48_hi, 0644, value_show, value_store);894static DEVICE_ATTR(mep_eui48_mi, 0644, value_show, value_store);895static DEVICE_ATTR(mep_eui48_lo, 0644, value_show, value_store);896static DEVICE_ATTR(arb_address, 0644, value_show, value_store);897static DEVICE_ATTR(arb_value, 0644, value_show, value_store);898 899static 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 918ATTRIBUTE_GROUPS(dci);919 920static 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 928static 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 driver936 * @interface: Interface of the attached USB device937 * @id: Pointer to the USB ID table.938 *939 * This allocates and initializes the device instance, adds the new940 * entry to the internal list, scans the USB descriptors and registers941 * 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 */946static int947hdm_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 else1038 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;1085err_free_dci:1086 put_device(&mdev->dci->dev);1087err_free_busy_urbs:1088 kfree(mdev->busy_urbs);1089err_free_ep_address:1090 kfree(mdev->ep_address);1091err_free_cap:1092 kfree(mdev->cap);1093err_free_conf:1094 kfree(mdev->conf);1095err_free_mdev:1096 put_device(&mdev->dev);1097 return ret;1098}1099 1100/**1101 * hdm_disconnect - disconnect function of USB device driver1102 * @interface: Interface of the attached USB device1103 *1104 * This deregisters the interface with the core, removes the kernel timer1105 * and frees resources.1106 *1107 * Context: hub kernel thread1108 */1109static 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 1133static 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 1147static 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 1159static 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 1168module_usb_driver(hdm_usb);1169MODULE_LICENSE("GPL");1170MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");1171MODULE_DESCRIPTION("HDM_4_USB");1172