| Message ID | 1411661254-5204-2-git-send-email-octavian.purdila@intel.com |
|---|---|
| State | Not Applicable |
| Headers | show |
On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO > Master Adapter DLN-2. Details about the device can be found here: > > https://www.diolan.com/i2c/i2c_interface.html. > > Information about the USB protocol can be found in the Programmer's > Reference Manual [1], see section 1.7. > > Because the hardware has a single transmit endpoint and a single > receive endpoint the communication between the various DLN2 drivers > and the hardware will be muxed/demuxed by this driver. > > Each DLN2 module will be identified by the handle field within the DLN2 > message header. If a DLN2 module issues multiple commands in parallel > they will be identified by the echo counter field in the message header. > > The DLN2 modules can use the dln2_transfer() function to issue a > command and wait for its response. They can also register a callback > that is going to be called when a specific event id is generated by > the device (e.g. GPIO interrupts). The device uses handle 0 for > sending events. > > [1] https://www.diolan.com/downloads/dln-api-manual.pdf > > Signed-off-by: Octavian Purdila <octavian.purdila@intel.com> > --- > drivers/mfd/Kconfig | 9 + > drivers/mfd/Makefile | 1 + > drivers/mfd/dln2.c | 751 +++++++++++++++++++++++++++++++++++++++++++++++ > include/linux/mfd/dln2.h | 67 +++++ > 4 files changed, 828 insertions(+) > create mode 100644 drivers/mfd/dln2.c > create mode 100644 include/linux/mfd/dln2.h [...] > +#define DLN2_HW_ID 0x200 > +#define DLN2_USB_TIMEOUT 200 /* in ms */ > +#define DLN2_MAX_RX_SLOTS 16 > +#define DLN2_MAX_URBS 16 > +#define DLN2_RX_BUF_SIZE 512 > + > +enum dln2_handle { > + DLN2_HANDLE_EVENT, This is the only handle that was fixed (0), right? Initialise this one explicitly in case any one ever tries to reorder them. > + DLN2_HANDLE_CTRL, > + DLN2_HANDLE_GPIO, > + DLN2_HANDLE_I2C, > + DLN2_HANDLES > +}; > + > +/* > + * Receive context used between the receive demultiplexer and the > + * transfer routine. While sending a request the transfer routine > + * will look for a free receive context and use it to wait for a > + * response and to receive the URB and thus the response data. > + */ > +struct dln2_rx_context { > + /* completion used to wait for a response */ > + struct completion done; > + > + /* if non-NULL the URB contains the response */ > + struct urb *urb; > + > + /* if true then this context is used to wait for a response */ > + bool in_use; > +}; > + > +/* > + * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We > + * use the handle header field to identify the module in > + * dln2_dev.mod_rx_slots and then the echo header field to index the > + * slots field and find the receive context for a particular request. > + */ > +struct dln2_mod_rx_slots { > + /* RX slots bitmap */ > + unsigned long bmap; > + > + /* used to wait for a free RX slot */ > + wait_queue_head_t wq; > + > + /* used to wait for an RX operation to complete */ > + struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS]; > + > + /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */ > + spinlock_t lock; > +}; > + > +struct dln2_dev { > + struct usb_device *usb_dev; > + struct usb_interface *interface; > + u8 ep_in; > + u8 ep_out; > + > + struct urb *rx_urb[DLN2_MAX_URBS]; > + void *rx_buf[DLN2_MAX_URBS]; > + > + struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES]; > + > + struct list_head event_cb_list; > + spinlock_t event_cb_lock; > + > + bool disconnect; > + int active_transfers; > + wait_queue_head_t disconnect_wq; > + spinlock_t disconnect_lock; > +}; > + > +struct dln2_event_cb_entry { > + struct list_head list; > + u16 id; > + struct platform_device *pdev; > + dln2_event_cb_t callback; > +}; > + > +int dln2_register_event_cb(struct platform_device *pdev, u16 id, > + dln2_event_cb_t rx_cb) > +{ > + struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); > + struct dln2_event_cb_entry *i, *new; > + unsigned long flags; > + int ret = 0; > + > + new = kmalloc(sizeof(*new), GFP_KERNEL); > + if (!new) > + return -ENOMEM; > + > + new->id = id; > + new->callback = rx_cb; > + new->pdev = pdev; > + > + spin_lock_irqsave(&dln2->event_cb_lock, flags); > + > + list_for_each_entry(i, &dln2->event_cb_list, list) { > + if (i->id == id) { > + ret = -EBUSY; > + break; > + } > + } > + > + if (!ret) > + list_add_rcu(&new->list, &dln2->event_cb_list); > + > + spin_unlock_irqrestore(&dln2->event_cb_lock, flags); > + > + if (ret) > + kfree(new); > + > + return ret; > +} > +EXPORT_SYMBOL(dln2_register_event_cb); > + > +void dln2_unregister_event_cb(struct platform_device *pdev, u16 id) > +{ > + struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); > + struct dln2_event_cb_entry *i; > + unsigned long flags; > + bool found = false; > + > + spin_lock_irqsave(&dln2->event_cb_lock, flags); > + > + list_for_each_entry(i, &dln2->event_cb_list, list) { > + if (i->id == id) { > + list_del_rcu(&i->list); > + found = true; > + break; > + } > + } > + > + spin_unlock_irqrestore(&dln2->event_cb_lock, flags); > + > + if (found) { > + synchronize_rcu(); > + kfree(i); > + } > +} > +EXPORT_SYMBOL(dln2_unregister_event_cb); > + > +static int dln2_submit_urb(struct dln2_dev *dln2, struct urb *urb, gfp_t gfp) > +{ > + int ret; > + struct device *dev = &dln2->interface->dev; > + > + ret = usb_submit_urb(urb, gfp); > + if (ret < 0) > + dev_err(dev, "failed to (re)submit RX URB: %d\n", ret); > + return ret; > +} > + > +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, > + u16 handle, u16 rx_slot) > +{ > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > + struct dln2_rx_context *rxc; > + struct device *dev = &dln2->interface->dev; > + > + spin_lock(&rxs->lock); > + > + rxc = &rxs->slots[rx_slot]; This can be done outside the lock, right? > + > + if (rxc->in_use && !rxc->urb) { > + rxc->urb = urb; > + complete(&rxc->done); > + /* URB will be resubmitted in free_rx_slot */ > + } else { > + dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot); > + dln2_submit_urb(dln2, urb, GFP_ATOMIC); And so can the resubmission. I think this might be easier to follow if you just do this inline in the completion handler, and always resubmit there before returning (unless the slot is in use). > + } > + > + spin_unlock(&rxs->lock); > +} > + > +static void dln2_run_rx_callbacks(struct dln2_dev *dln2, u16 id, u16 echo, > + void *data, int len) Rename this one dln2_run_event_callbacks to match your new names (much better by the way)? > +{ > + struct dln2_event_cb_entry *i; > + > + rcu_read_lock(); > + > + list_for_each_entry_rcu(i, &dln2->event_cb_list, list) > + if (i->id == id) > + i->callback(i->pdev, echo, data, len); > + > + rcu_read_unlock(); > +} > + > +static void dln2_rx(struct urb *urb) > +{ > + struct dln2_dev *dln2 = urb->context; > + struct dln2_header *hdr = urb->transfer_buffer; > + struct device *dev = &dln2->interface->dev; > + u16 id, echo, handle, size; > + u8 *data; > + int len; > + > + switch (urb->status) { > + case 0: > + /* success */ > + break; > + case -ECONNRESET: > + case -ENOENT: > + case -ESHUTDOWN: > + case -EPIPE: > + /* this urb is terminated, clean up */ > + dev_dbg(dev, "urb shutting down with status %d\n", urb->status); > + return; > + default: > + dev_dbg(dev, "nonzero urb status received %d\n", urb->status); > + goto out; > + } > + > + if (urb->actual_length < sizeof(struct dln2_header)) { > + dev_err(dev, "short response: %d\n", urb->actual_length); > + goto out; > + } > + > + handle = le16_to_cpu(hdr->handle); > + id = le16_to_cpu(hdr->id); > + echo = le16_to_cpu(hdr->echo); > + size = le16_to_cpu(hdr->size); > + > + if (size != urb->actual_length) { > + dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n", > + handle, id, echo, size, urb->actual_length); > + goto out; > + } > + > + if (handle >= DLN2_HANDLES) { > + dev_warn(dev, "RX: invalid handle %d\n", handle); > + goto out; > + } > + > + data = urb->transfer_buffer + sizeof(struct dln2_header); > + len = urb->actual_length - sizeof(struct dln2_header); > + > + if (handle == DLN2_HANDLE_EVENT) { > + dln2_run_rx_callbacks(dln2, id, echo, data, len); > + } else { > + dln2_rx_transfer(dln2, urb, handle, echo); > + /* URB will be re-submitted in dln2_rx_transfer */ This comment is a little misleading since the urb will not be resubmitted if the corresponding slot is in use. See my comment to dln2_rx_transfer above. > + return; > + } > + > +out: > + dln2_submit_urb(dln2, urb, GFP_ATOMIC); > +} > + > +static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf, > + int *obuf_len, gfp_t gfp) > +{ > + int len; > + void *buf; > + struct dln2_header *hdr; > + > + len = *obuf_len + sizeof(*hdr); > + buf = kmalloc(len, gfp); > + if (!buf) > + return NULL; > + > + hdr = (struct dln2_header *)buf; > + hdr->id = cpu_to_le16(cmd); > + hdr->size = cpu_to_le16(len); > + hdr->echo = cpu_to_le16(echo); > + hdr->handle = cpu_to_le16(handle); > + > + memcpy(buf + sizeof(*hdr), obuf, *obuf_len); > + > + *obuf_len = len; > + > + return buf; > +} > + > +static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo, > + const void *obuf, int obuf_len) > +{ > + int ret = 0; > + int len = obuf_len; > + void *buf; > + int actual; > + > + buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + > + ret = usb_bulk_msg(dln2->usb_dev, > + usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out), > + buf, len, &actual, DLN2_USB_TIMEOUT); > + > + kfree(buf); > + > + return ret; > +} > + > +static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot) > +{ > + struct dln2_mod_rx_slots *rxs; > + unsigned long flags; > + You could still check the global disconnect flag here to speed up disconnect (locking not needed). Return -ENODEV as I mentioned earlier. > + rxs = &dln2->mod_rx_slots[handle]; > + > + spin_lock_irqsave(&rxs->lock, flags); > + > + *slot = find_first_zero_bit(&rxs->bmap, DLN2_MAX_RX_SLOTS); > + > + if (*slot < DLN2_MAX_RX_SLOTS) { > + struct dln2_rx_context *rxc = &rxs->slots[*slot]; > + > + set_bit(*slot, &rxs->bmap); > + rxc->in_use = true; > + } > + > + spin_unlock_irqrestore(&rxs->lock, flags); > + > + return *slot < DLN2_MAX_RX_SLOTS; > +} > + > +static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle) > +{ > + int ret; > + int slot; > + > + /* > + * No need to timeout here, the wait is bounded by the timeout > + * in _dln2_transfer. > + */ > + ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq, > + find_free_slot(dln2, handle, &slot)); > + if (ret < 0) > + return ret; > + > + return slot; > +} > + > +static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot) > +{ > + struct dln2_mod_rx_slots *rxs; > + struct urb *urb = NULL; > + unsigned long flags; > + struct dln2_rx_context *rxc; > + > + rxs = &dln2->mod_rx_slots[handle]; > + > + spin_lock_irqsave(&rxs->lock, flags); > + > + clear_bit(slot, &rxs->bmap); > + > + rxc = &rxs->slots[slot]; > + rxc->in_use = false; > + urb = rxc->urb; > + rxc->urb = NULL; > + reinit_completion(&rxc->done); > + > + spin_unlock_irqrestore(&rxs->lock, flags); > + > + if (urb) > + dln2_submit_urb(dln2, urb, GFP_KERNEL); > + > + wake_up_interruptible(&rxs->wq); > +} > + > +static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd, > + const void *obuf, unsigned obuf_len, > + void *ibuf, unsigned *ibuf_len) > +{ > + int ret = 0; > + u16 result; > + int rx_slot; > + struct dln2_response *rsp; > + struct dln2_rx_context *rxc; > + struct device *dev; > + const int timeout = DLN2_USB_TIMEOUT * HZ / 1000; > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > + > + spin_lock(&dln2->disconnect_lock); > + if (!dln2->disconnect) > + dln2->active_transfers++; > + else > + ret = -ENODEV; > + spin_unlock(&dln2->disconnect_lock); > + > + if (ret) > + return ret; > + > + rx_slot = alloc_rx_slot(dln2, handle); > + if (rx_slot < 0) { > + ret = rx_slot; > + goto out_decr; > + } > + > + dev = &dln2->interface->dev; This can be done when declaring dev. > + > + ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len); > + if (ret < 0) { > + dev_err(dev, "USB write failed: %d\n", ret); > + goto out_free_rx_slot; > + } > + > + rxc = &rxs->slots[rx_slot]; > + > + ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout); > + if (ret <= 0) { > + if (!ret) > + ret = -ETIMEDOUT; > + goto out_free_rx_slot; > + } > + > + if (!rxc->urb) { > + ret = -ENODEV; > + goto out_free_rx_slot; > + } This can only happen if disconnected, right? Perhaps add a comment unless you want to the test the disconnected flag instead which would make it self-explanatory. > + > + /* if we got here we know that the response header has been checked */ > + rsp = rxc->urb->transfer_buffer; > + > + if (rsp->hdr.size < sizeof(*rsp)) { > + ret = -EPROTO; > + goto out_free_rx_slot; > + } > + > + result = le16_to_cpu(rsp->result); > + if (result) { > + dev_dbg(dev, "%d received response with error %d\n", > + handle, result); > + ret = -EREMOTEIO; > + goto out_free_rx_slot; > + } > + > + if (!ibuf) { > + ret = 0; > + goto out_free_rx_slot; > + } > + > + if (*ibuf_len > rsp->hdr.size - sizeof(*rsp)) > + *ibuf_len = rsp->hdr.size - sizeof(*rsp); > + > + memcpy(ibuf, rsp + 1, *ibuf_len); > + > +out_free_rx_slot: > + free_rx_slot(dln2, handle, rx_slot); > +out_decr: > + spin_lock(&dln2->disconnect_lock); > + dln2->active_transfers--; > + spin_unlock(&dln2->disconnect_lock); > + if (dln2->disconnect) > + wake_up(&dln2->disconnect_wq); > + > + return ret; > +} v> + > +int dln2_transfer(struct platform_device *pdev, u16 cmd, > + const void *obuf, unsigned obuf_len, > + void *ibuf, unsigned *ibuf_len) > +{ > + struct dln2_platform_data *dln2_pdata; > + struct dln2_dev *dln2; > + u16 h; > + > + dln2 = dev_get_drvdata(pdev->dev.parent); > + dln2_pdata = dev_get_platdata(&pdev->dev); > + h = dln2_pdata->handle; > + > + return _dln2_transfer(dln2, h, cmd, obuf, obuf_len, ibuf, ibuf_len); > +} > +EXPORT_SYMBOL(dln2_transfer); > + > +static int dln2_check_hw(struct dln2_dev *dln2) > +{ > + int ret; > + __le32 hw_type; > + int len = sizeof(hw_type); > + > + ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER, > + NULL, 0, &hw_type, &len); > + if (ret < 0) > + return ret; > + if (len < sizeof(hw_type)) > + return -EREMOTEIO; > + > + if (le32_to_cpu(hw_type) != DLN2_HW_ID) { > + dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n", > + le32_to_cpu(hw_type)); > + return -ENODEV; > + } > + > + return 0; > +} > + > +static int dln2_print_serialno(struct dln2_dev *dln2) > +{ > + int ret; > + __le32 serial_no; > + int len = sizeof(serial_no); > + struct device *dev = &dln2->interface->dev; > + > + ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0, > + &serial_no, &len); > + if (ret < 0) > + return ret; > + if (len < sizeof(serial_no)) > + return -EREMOTEIO; > + > + dev_info(dev, "Diolan DLN2 serial 0x%x\n", le32_to_cpu(serial_no)); > + > + return 0; > +} > + > +static int dln2_hw_init(struct dln2_dev *dln2) > +{ > + int ret; > + > + ret = dln2_check_hw(dln2); > + if (ret < 0) > + return ret; > + > + return dln2_print_serialno(dln2); > +} > + > +static void dln2_free_rx_urbs(struct dln2_dev *dln2) > +{ > + int i; > + > + for (i = 0; i < DLN2_MAX_URBS; i++) { > + usb_kill_urb(dln2->rx_urb[i]); > + usb_free_urb(dln2->rx_urb[i]); > + kfree(dln2->rx_buf[i]); > + } > +} > + > +static void dln2_free(struct dln2_dev *dln2) > +{ > + dln2_free_rx_urbs(dln2); > + usb_put_dev(dln2->usb_dev); > + kfree(dln2); > +} > + > +static int dln2_setup_rx_urbs(struct dln2_dev *dln2, > + struct usb_host_interface *hostif) > +{ > + int i; > + const int rx_max_size = DLN2_RX_BUF_SIZE; > + > + for (i = 0; i < DLN2_MAX_URBS; i++) { > + int ret; > + > + dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL); > + if (!dln2->rx_buf[i]) > + return -ENOMEM; > + > + dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL); > + if (!dln2->rx_urb[i]) > + return -ENOMEM; > + > + usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev, > + usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in), > + dln2->rx_buf[i], rx_max_size, dln2_rx, dln2); > + > + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); > + if (ret < 0) > + return ret; Is it really worth having this helper only to save a couple of lines on a dev_err? If you do all resubmissions on completion inline in the handler, you only have three places where usb_submit_urb is called. > + } > + > + return 0; > +} > + > +static struct dln2_platform_data dln2_pdata_gpio = { > + .handle = DLN2_HANDLE_GPIO, > +}; > + > +/* Only one I2C port seems to be supported on current hardware */ > +static struct dln2_platform_data dln2_pdata_i2c = { > + .handle = DLN2_HANDLE_I2C, > + .port = 0, > +}; > + > +static const struct mfd_cell dln2_devs[] = { > + { > + .name = "dln2-gpio", > + .platform_data = &dln2_pdata_gpio, > + .pdata_size = sizeof(struct dln2_platform_data), > + }, > + { > + .name = "dln2-i2c", > + .platform_data = &dln2_pdata_i2c, > + .pdata_size = sizeof(struct dln2_platform_data), > + }, > +}; > + > +static void dln2_disconnect(struct usb_interface *interface) > +{ > + struct dln2_dev *dln2 = usb_get_intfdata(interface); > + int i, j; > + > + /* don't allow starting new transfers */ > + spin_lock(&dln2->disconnect_lock); > + dln2->disconnect = true; > + spin_unlock(&dln2->disconnect_lock); > + > + /* cancel in progress transfers */ > + for (i = 0; i < DLN2_HANDLES; i++) { > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; > + unsigned long flags; > + > + spin_lock_irqsave(&rxs->lock, flags); > + > + /* cancel all response waiters */ > + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) { > + struct dln2_rx_context *rxc = &rxs->slots[j]; > + > + if (rxc->in_use) > + complete(&rxc->done); > + } > + > + spin_unlock_irqrestore(&rxs->lock, flags); > + } > + > + /* wait for transfers to end */ > + wait_event(dln2->disconnect_wq, !dln2->active_transfers); > + > + mfd_remove_devices(&interface->dev); > + > + dln2_free(dln2); > +} > + > +static int dln2_probe(struct usb_interface *interface, > + const struct usb_device_id *usb_id) > +{ > + struct usb_host_interface *hostif = interface->cur_altsetting; > + struct device *dev = &interface->dev; > + struct dln2_dev *dln2; > + int ret; > + int i, j; > + int id; > + > + if (hostif->desc.bInterfaceNumber != 0 || > + hostif->desc.bNumEndpoints < 2) > + return -ENODEV; > + > + dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL); > + if (!dln2) > + return -ENOMEM; > + > + dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress; > + dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress; > + dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface)); > + dln2->interface = interface; > + usb_set_intfdata(interface, dln2); > + init_waitqueue_head(&dln2->disconnect_wq); > + > + for (i = 0; i < DLN2_HANDLES; i++) { > + init_waitqueue_head(&dln2->mod_rx_slots[i].wq); > + spin_lock_init(&dln2->mod_rx_slots[i].lock); > + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) > + init_completion(&dln2->mod_rx_slots[i].slots[j].done); > + } > + > + spin_lock_init(&dln2->event_cb_lock); > + INIT_LIST_HEAD(&dln2->event_cb_list); > + > + ret = dln2_setup_rx_urbs(dln2, hostif); > + if (ret) { > + dln2_free(dln2); goto out_cleanup as mentioned earlier. > + return ret; > + } > + > + ret = dln2_hw_init(dln2); > + if (ret < 0) { > + dev_err(dev, "failed to initialize hardware\n"); > + goto out_cleanup; > + } > + > + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; After giving this some more thought, I think you should just use PLATFORM_DEVID_AUTO as id. I have submitted a series to fix the other USB MFD drivers and add a convenience helper to register hotpluggable MFDs here: http://marc.info/?l=linux-kernel&m=141172912516884&w=2 > + ret = mfd_add_devices(dev, id, dln2_devs, ARRAY_SIZE(dln2_devs), > + NULL, 0, NULL); > + if (ret != 0) { > + dev_err(dev, "failed to add mfd devices to core\n"); > + goto out_cleanup; > + } > + > + return 0; > + > +out_cleanup: > + dln2_free(dln2); > + > + return ret; > +} I'll try to take a quick look on the subdrivers on Monday. Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Fri, Oct 3, 2014 at 8:12 PM, Johan Hovold <johan@kernel.org> wrote: > > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > > This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO > > Master Adapter DLN-2. Details about the device can be found here: > > <snip> > > + > > + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); > > + if (ret < 0) > > + return ret; > > Is it really worth having this helper only to save a couple of lines on > a dev_err? If you do all resubmissions on completion inline in the > handler, you only have three places where usb_submit_urb is called. > I moved the completion in the handler as you suggested. I have kept the helper, would you prefer to remove it? <snip> > > + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; > > After giving this some more thought, I think you should just > use PLATFORM_DEVID_AUTO as id. I have submitted a series to fix the > other USB MFD drivers and add a convenience helper to register > hotpluggable MFDs here: > OK, I will use PLATFORM_DEVID_AUTO for now. If your series merges first and I have to resubmit mine, I will switch to using mfd_add_hotplug_devices. > I'll try to take a quick look on the subdrivers on Monday. > Thanks Johan. I have addressed the rest of the comments as well and I will send another series after your reviews on the sub-drivers. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Mon, Oct 06, 2014 at 03:17:22PM +0300, Octavian Purdila wrote: > On Fri, Oct 3, 2014 at 8:12 PM, Johan Hovold <johan@kernel.org> wrote: > > > > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > > > This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO > > > Master Adapter DLN-2. Details about the device can be found here: > > > > > <snip> > > > > + > > > + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); > > > + if (ret < 0) > > > + return ret; > > > > Is it really worth having this helper only to save a couple of lines on > > a dev_err? If you do all resubmissions on completion inline in the > > handler, you only have three places where usb_submit_urb is called. > > > > I moved the completion in the handler as you suggested. I have kept > the helper, would you prefer to remove it? Moved the "completion"? I was suggesting that the URB resubmission should be done inline the URB completion handler. [ "Completion" may be a little ambiguous. The URB callback is called an URB completion handler. Not be confused with the completion structures you use to wait for responses. ] It's fine to keep the helper as long as it's clear that the urb has been "cached" and should not be resubmitted (inline) in the completion handler in that case. > <snip> > > > > + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; > > > > After giving this some more thought, I think you should just > > use PLATFORM_DEVID_AUTO as id. I have submitted a series to fix the > > other USB MFD drivers and add a convenience helper to register > > hotpluggable MFDs here: > > > > OK, I will use PLATFORM_DEVID_AUTO for now. If your series merges > first and I have to resubmit mine, I will switch to using > mfd_add_hotplug_devices. Lee merged the helper function earlier today. Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Oct 7, 2014 at 8:10 PM, Johan Hovold <johan@kernel.org> wrote: > On Mon, Oct 06, 2014 at 03:17:22PM +0300, Octavian Purdila wrote: >> On Fri, Oct 3, 2014 at 8:12 PM, Johan Hovold <johan@kernel.org> wrote: >> > >> > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: >> > > This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO >> > > Master Adapter DLN-2. Details about the device can be found here: >> > > >> >> <snip> >> >> > > + >> > > + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); >> > > + if (ret < 0) >> > > + return ret; >> > >> > Is it really worth having this helper only to save a couple of lines on >> > a dev_err? If you do all resubmissions on completion inline in the >> > handler, you only have three places where usb_submit_urb is called. >> > >> >> I moved the completion in the handler as you suggested. I have kept >> the helper, would you prefer to remove it? > > Moved the "completion"? I was suggesting that the URB resubmission > should be done inline the URB completion handler. > > [ "Completion" may be a little ambiguous. The URB callback is called an > URB completion handler. Not be confused with the completion structures > you use to wait for responses. ] > Sorry, I meant to say resubmission instead of completion. > It's fine to keep the helper as long as it's clear that the urb has been > "cached" and should not be resubmitted (inline) in the completion > handler in that case. > Not sure I follow you here. I kept the helper and I call it from the completion handler, from free_rx_slot and from dln2_setup_rx_ubs. > >> <snip> >> >> > > + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; >> > >> > After giving this some more thought, I think you should just >> > use PLATFORM_DEVID_AUTO as id. I have submitted a series to fix the >> > other USB MFD drivers and add a convenience helper to register >> > hotpluggable MFDs here: >> > >> >> OK, I will use PLATFORM_DEVID_AUTO for now. If your series merges >> first and I have to resubmit mine, I will switch to using >> mfd_add_hotplug_devices. > > Lee merged the helper function earlier today. > Yep, noticed that, I did a rebase earlier. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, > + u16 handle, u16 rx_slot) > +{ > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > + struct dln2_rx_context *rxc; > + struct device *dev = &dln2->interface->dev; > + > + spin_lock(&rxs->lock); You must use spin_lock_irqsave here as you call it from the completion handler. > + > + rxc = &rxs->slots[rx_slot]; > + > + if (rxc->in_use && !rxc->urb) { > + rxc->urb = urb; > + complete(&rxc->done); > + /* URB will be resubmitted in free_rx_slot */ > + } else { > + dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot); > + dln2_submit_urb(dln2, urb, GFP_ATOMIC); > + } > + > + spin_unlock(&rxs->lock); > +} > +static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd, > + const void *obuf, unsigned obuf_len, > + void *ibuf, unsigned *ibuf_len) > +{ > + int ret = 0; > + u16 result; > + int rx_slot; > + struct dln2_response *rsp; > + struct dln2_rx_context *rxc; > + struct device *dev; > + const int timeout = DLN2_USB_TIMEOUT * HZ / 1000; > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > + > + spin_lock(&dln2->disconnect_lock); How did you test this version? You never initialise disconnect_lock so lockdep complains loudly when calling _dln2_transfer during probe. > + if (!dln2->disconnect) > + dln2->active_transfers++; > + else > + ret = -ENODEV; > + spin_unlock(&dln2->disconnect_lock); > + > + if (ret) > + return ret; > + > + rx_slot = alloc_rx_slot(dln2, handle); > + if (rx_slot < 0) { > + ret = rx_slot; > + goto out_decr; > + } > + > + dev = &dln2->interface->dev; > + > + ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len); > + if (ret < 0) { > + dev_err(dev, "USB write failed: %d\n", ret); > + goto out_free_rx_slot; > + } > + > + rxc = &rxs->slots[rx_slot]; > + > + ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout); > + if (ret <= 0) { > + if (!ret) > + ret = -ETIMEDOUT; > + goto out_free_rx_slot; > + } > + > + if (!rxc->urb) { > + ret = -ENODEV; > + goto out_free_rx_slot; > + } > + > + /* if we got here we know that the response header has been checked */ > + rsp = rxc->urb->transfer_buffer; > + > + if (rsp->hdr.size < sizeof(*rsp)) { > + ret = -EPROTO; > + goto out_free_rx_slot; > + } > + > + result = le16_to_cpu(rsp->result); > + if (result) { > + dev_dbg(dev, "%d received response with error %d\n", > + handle, result); > + ret = -EREMOTEIO; > + goto out_free_rx_slot; > + } > + > + if (!ibuf) { > + ret = 0; > + goto out_free_rx_slot; > + } > + > + if (*ibuf_len > rsp->hdr.size - sizeof(*rsp)) > + *ibuf_len = rsp->hdr.size - sizeof(*rsp); > + > + memcpy(ibuf, rsp + 1, *ibuf_len); > + > +out_free_rx_slot: > + free_rx_slot(dln2, handle, rx_slot); > +out_decr: > + spin_lock(&dln2->disconnect_lock); > + dln2->active_transfers--; > + spin_unlock(&dln2->disconnect_lock); > + if (dln2->disconnect) > + wake_up(&dln2->disconnect_wq); > + > + return ret; > +} > +static void dln2_disconnect(struct usb_interface *interface) > +{ > + struct dln2_dev *dln2 = usb_get_intfdata(interface); > + int i, j; > + > + /* don't allow starting new transfers */ > + spin_lock(&dln2->disconnect_lock); > + dln2->disconnect = true; > + spin_unlock(&dln2->disconnect_lock); > + > + /* cancel in progress transfers */ > + for (i = 0; i < DLN2_HANDLES; i++) { > + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; > + unsigned long flags; > + > + spin_lock_irqsave(&rxs->lock, flags); Just stick to spin_lock in this function. > + > + /* cancel all response waiters */ > + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) { > + struct dln2_rx_context *rxc = &rxs->slots[j]; > + > + if (rxc->in_use) > + complete(&rxc->done); > + } > + > + spin_unlock_irqrestore(&rxs->lock, flags); > + } > + > + /* wait for transfers to end */ > + wait_event(dln2->disconnect_wq, !dln2->active_transfers); > + > + mfd_remove_devices(&interface->dev); > + > + dln2_free(dln2); > +} > + > +static int dln2_probe(struct usb_interface *interface, > + const struct usb_device_id *usb_id) > +{ > + struct usb_host_interface *hostif = interface->cur_altsetting; > + struct device *dev = &interface->dev; > + struct dln2_dev *dln2; > + int ret; > + int i, j; > + int id; > + > + if (hostif->desc.bInterfaceNumber != 0 || > + hostif->desc.bNumEndpoints < 2) > + return -ENODEV; > + > + dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL); > + if (!dln2) > + return -ENOMEM; > + > + dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress; > + dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress; > + dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface)); > + dln2->interface = interface; > + usb_set_intfdata(interface, dln2); > + init_waitqueue_head(&dln2->disconnect_wq); > + > + for (i = 0; i < DLN2_HANDLES; i++) { > + init_waitqueue_head(&dln2->mod_rx_slots[i].wq); > + spin_lock_init(&dln2->mod_rx_slots[i].lock); > + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) > + init_completion(&dln2->mod_rx_slots[i].slots[j].done); > + } > + > + spin_lock_init(&dln2->event_cb_lock); > + INIT_LIST_HEAD(&dln2->event_cb_list); The disconnect_lock is never initialised, as mentioned above. > + > + ret = dln2_setup_rx_urbs(dln2, hostif); > + if (ret) { > + dln2_free(dln2); > + return ret; > + } > + > + ret = dln2_hw_init(dln2); > + if (ret < 0) { > + dev_err(dev, "failed to initialize hardware\n"); > + goto out_cleanup; > + } > + > + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; > + ret = mfd_add_devices(dev, id, dln2_devs, ARRAY_SIZE(dln2_devs), > + NULL, 0, NULL); > + if (ret != 0) { > + dev_err(dev, "failed to add mfd devices to core\n"); > + goto out_cleanup; > + } > + > + return 0; > + > +out_cleanup: > + dln2_free(dln2); > + > + return ret; > +} > + > +static const struct usb_device_id dln2_table[] = { > + { USB_DEVICE(0xa257, 0x2013) }, > + { } > +}; > + > +MODULE_DEVICE_TABLE(usb, dln2_table); > + > +static struct usb_driver dln2_driver = { > + .name = "usb-dln2", Just call the usb driver "dln2". > + .probe = dln2_probe, > + .disconnect = dln2_disconnect, > + .id_table = dln2_table, > +}; Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Oct 07, 2014 at 09:01:27PM +0300, Octavian Purdila wrote: > On Tue, Oct 7, 2014 at 8:10 PM, Johan Hovold <johan@kernel.org> wrote: > > On Mon, Oct 06, 2014 at 03:17:22PM +0300, Octavian Purdila wrote: > >> On Fri, Oct 3, 2014 at 8:12 PM, Johan Hovold <johan@kernel.org> wrote: > >> > > >> > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > >> > > This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO > >> > > Master Adapter DLN-2. Details about the device can be found here: > >> > > > >> > >> <snip> > >> > >> > > + > >> > > + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); > >> > > + if (ret < 0) > >> > > + return ret; > >> > > >> > Is it really worth having this helper only to save a couple of lines on > >> > a dev_err? If you do all resubmissions on completion inline in the > >> > handler, you only have three places where usb_submit_urb is called. > >> > >> I moved the completion in the handler as you suggested. I have kept > >> the helper, would you prefer to remove it? > > > > Moved the "completion"? I was suggesting that the URB resubmission > > should be done inline the URB completion handler. > > > > [ "Completion" may be a little ambiguous. The URB callback is called an > > URB completion handler. Not be confused with the completion structures > > you use to wait for responses. ] > > > > Sorry, I meant to say resubmission instead of completion. > > > It's fine to keep the helper as long as it's clear that the urb has been > > "cached" and should not be resubmitted (inline) in the completion > > handler in that case. > > Not sure I follow you here. I kept the helper and I call it from the > completion handler, from free_rx_slot and from dln2_setup_rx_ubs. Ah sorry, I was referring to your other helper dln2_rx_transfer(). I still think you should do away with the dln2_submit_urb() helper as it needlessly hides what's on going without any real gain. Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Oct 8, 2014 at 12:23 PM, Johan Hovold <johan@kernel.org> wrote: > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > >> +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, >> + u16 handle, u16 rx_slot) >> +{ >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; >> + struct dln2_rx_context *rxc; >> + struct device *dev = &dln2->interface->dev; >> + >> + spin_lock(&rxs->lock); > > You must use spin_lock_irqsave here as you call it from the completion > handler. Why? AFAICS the completion handler gets called from the HCD irq handler: [ 2.503945] Call Trace: [ 2.503945] <IRQ> [<ffffffff81a73d14>] dump_stack+0x4e/0x7a [ 2.503945] [<ffffffff81639fcb>] dln2_rx+0x1eb/0x2d0 [ 2.503945] [<ffffffff81742202>] __usb_hcd_giveback_urb+0x72/0x120 [ 2.503945] [<ffffffff817423cf>] usb_hcd_giveback_urb+0x3f/0x120 [ 2.503945] [<ffffffff81786ffa>] uhci_giveback_urb+0xaa/0x290 [ 2.503945] [<ffffffff811d36d7>] ? dma_pool_free+0xa7/0xd0 [ 2.503945] [<ffffffff81788fe3>] uhci_scan_schedule+0x493/0xb20 [ 2.503945] [<ffffffff81789c9e>] uhci_irq+0x9e/0x180 [ 2.503945] [<ffffffff81741546>] usb_hcd_irq+0x26/0x40 [ 2.503945] [<ffffffff8110e46e>] handle_irq_event_percpu+0x3e/0x1e0 [ 2.503945] [<ffffffff8110e64d>] handle_irq_event+0x3d/0x60 [ 2.503945] [<ffffffff811117f9>] handle_fasteoi_irq+0x99/0x160 [ 2.503945] [<ffffffff810492c2>] handle_irq+0x102/0x190 [ 2.503945] [<ffffffff810e493a>] ? atomic_notifier_call_chain+0x3a/0x50 [ 2.503945] [<ffffffff81a7fbcb>] do_IRQ+0x5b/0x100 [ 2.503945] [<ffffffff81a7dd6f>] common_interrupt+0x6f/0x6f [ 2.503945] <EOI> [<ffffffff810512ed>] ? default_idle+0x1d/0x100 > >> + >> + rxc = &rxs->slots[rx_slot]; >> + >> + if (rxc->in_use && !rxc->urb) { >> + rxc->urb = urb; >> + complete(&rxc->done); >> + /* URB will be resubmitted in free_rx_slot */ >> + } else { >> + dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot); >> + dln2_submit_urb(dln2, urb, GFP_ATOMIC); >> + } >> + >> + spin_unlock(&rxs->lock); >> +} > >> +static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd, >> + const void *obuf, unsigned obuf_len, >> + void *ibuf, unsigned *ibuf_len) >> +{ >> + int ret = 0; >> + u16 result; >> + int rx_slot; >> + struct dln2_response *rsp; >> + struct dln2_rx_context *rxc; >> + struct device *dev; >> + const int timeout = DLN2_USB_TIMEOUT * HZ / 1000; >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; >> + >> + spin_lock(&dln2->disconnect_lock); > > How did you test this version? You never initialise disconnect_lock so > lockdep complains loudly when calling _dln2_transfer during probe. > Oops, missed that as lockdep was not enable in the lastest test setup. >> + if (!dln2->disconnect) >> + dln2->active_transfers++; >> + else >> + ret = -ENODEV; >> + spin_unlock(&dln2->disconnect_lock); >> + >> + if (ret) >> + return ret; >> + >> + rx_slot = alloc_rx_slot(dln2, handle); >> + if (rx_slot < 0) { >> + ret = rx_slot; >> + goto out_decr; >> + } >> + >> + dev = &dln2->interface->dev; >> + >> + ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len); >> + if (ret < 0) { >> + dev_err(dev, "USB write failed: %d\n", ret); >> + goto out_free_rx_slot; >> + } >> + >> + rxc = &rxs->slots[rx_slot]; >> + >> + ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout); >> + if (ret <= 0) { >> + if (!ret) >> + ret = -ETIMEDOUT; >> + goto out_free_rx_slot; >> + } >> + >> + if (!rxc->urb) { >> + ret = -ENODEV; >> + goto out_free_rx_slot; >> + } >> + >> + /* if we got here we know that the response header has been checked */ >> + rsp = rxc->urb->transfer_buffer; >> + >> + if (rsp->hdr.size < sizeof(*rsp)) { >> + ret = -EPROTO; >> + goto out_free_rx_slot; >> + } >> + >> + result = le16_to_cpu(rsp->result); >> + if (result) { >> + dev_dbg(dev, "%d received response with error %d\n", >> + handle, result); >> + ret = -EREMOTEIO; >> + goto out_free_rx_slot; >> + } >> + >> + if (!ibuf) { >> + ret = 0; >> + goto out_free_rx_slot; >> + } >> + >> + if (*ibuf_len > rsp->hdr.size - sizeof(*rsp)) >> + *ibuf_len = rsp->hdr.size - sizeof(*rsp); >> + >> + memcpy(ibuf, rsp + 1, *ibuf_len); >> + >> +out_free_rx_slot: >> + free_rx_slot(dln2, handle, rx_slot); >> +out_decr: >> + spin_lock(&dln2->disconnect_lock); >> + dln2->active_transfers--; >> + spin_unlock(&dln2->disconnect_lock); >> + if (dln2->disconnect) >> + wake_up(&dln2->disconnect_wq); >> + >> + return ret; >> +} > >> +static void dln2_disconnect(struct usb_interface *interface) >> +{ >> + struct dln2_dev *dln2 = usb_get_intfdata(interface); >> + int i, j; >> + >> + /* don't allow starting new transfers */ >> + spin_lock(&dln2->disconnect_lock); >> + dln2->disconnect = true; >> + spin_unlock(&dln2->disconnect_lock); >> + >> + /* cancel in progress transfers */ >> + for (i = 0; i < DLN2_HANDLES; i++) { >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; >> + unsigned long flags; >> + >> + spin_lock_irqsave(&rxs->lock, flags); > > Just stick to spin_lock in this function. > AFAICS disconnect is called from a kernel thread. Are there guarantees that we can't get a call to the completion routine while we are running it? -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Oct 08, 2014 at 01:54:07PM +0300, Octavian Purdila wrote: > On Wed, Oct 8, 2014 at 12:23 PM, Johan Hovold <johan@kernel.org> wrote: > > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > > > >> +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, > >> + u16 handle, u16 rx_slot) > >> +{ > >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > >> + struct dln2_rx_context *rxc; > >> + struct device *dev = &dln2->interface->dev; > >> + > >> + spin_lock(&rxs->lock); > > > > You must use spin_lock_irqsave here as you call it from the completion > > handler. > > Why? AFAICS the completion handler gets called from the HCD irq handler: The completion handler is currently called with local interrupts disabled but that is about to change once all drivers have been updated: http://marc.info/?l=linux-usb&m=137353360511003&w=2 In this case you could probably get away with not disabling interrupts anyway, but using the irqsave versions would make it obvious. > >> +static void dln2_disconnect(struct usb_interface *interface) > >> +{ > >> + struct dln2_dev *dln2 = usb_get_intfdata(interface); > >> + int i, j; > >> + > >> + /* don't allow starting new transfers */ > >> + spin_lock(&dln2->disconnect_lock); > >> + dln2->disconnect = true; > >> + spin_unlock(&dln2->disconnect_lock); > >> + > >> + /* cancel in progress transfers */ > >> + for (i = 0; i < DLN2_HANDLES; i++) { > >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; > >> + unsigned long flags; > >> + > >> + spin_lock_irqsave(&rxs->lock, flags); > > > > Just stick to spin_lock in this function. > > AFAICS disconnect is called from a kernel thread. Are there guarantees > that we can't get a call to the completion routine while we are > running it? Brain fart, nevermind. Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Oct 8, 2014 at 3:04 PM, Johan Hovold <johan@kernel.org> wrote: > On Wed, Oct 08, 2014 at 01:54:07PM +0300, Octavian Purdila wrote: >> On Wed, Oct 8, 2014 at 12:23 PM, Johan Hovold <johan@kernel.org> wrote: >> > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: >> > >> >> +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, >> >> + u16 handle, u16 rx_slot) >> >> +{ >> >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; >> >> + struct dln2_rx_context *rxc; >> >> + struct device *dev = &dln2->interface->dev; >> >> + >> >> + spin_lock(&rxs->lock); >> > >> > You must use spin_lock_irqsave here as you call it from the completion >> > handler. >> >> Why? AFAICS the completion handler gets called from the HCD irq handler: > > The completion handler is currently called with local interrupts > disabled but that is about to change once all drivers have been updated: > > http://marc.info/?l=linux-usb&m=137353360511003&w=2 > > In this case you could probably get away with not disabling interrupts > anyway, but using the irqsave versions would make it obvious. > I was not assuming that interrupts are disabled while running the completion handler. Since that spinlock is not touched by any other interrupt context code I don't think irqsave is necessary. -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Oct 08, 2014 at 03:33:28PM +0300, Octavian Purdila wrote: > On Wed, Oct 8, 2014 at 3:04 PM, Johan Hovold <johan@kernel.org> wrote: > > On Wed, Oct 08, 2014 at 01:54:07PM +0300, Octavian Purdila wrote: > >> On Wed, Oct 8, 2014 at 12:23 PM, Johan Hovold <johan@kernel.org> wrote: > >> > On Thu, Sep 25, 2014 at 07:07:31PM +0300, Octavian Purdila wrote: > >> > > >> >> +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, > >> >> + u16 handle, u16 rx_slot) > >> >> +{ > >> >> + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; > >> >> + struct dln2_rx_context *rxc; > >> >> + struct device *dev = &dln2->interface->dev; > >> >> + > >> >> + spin_lock(&rxs->lock); > >> > > >> > You must use spin_lock_irqsave here as you call it from the completion > >> > handler. > >> > >> Why? AFAICS the completion handler gets called from the HCD irq handler: > > > > The completion handler is currently called with local interrupts > > disabled but that is about to change once all drivers have been updated: > > > > http://marc.info/?l=linux-usb&m=137353360511003&w=2 > > > > In this case you could probably get away with not disabling interrupts > > anyway, but using the irqsave versions would make it obvious. > > > > I was not assuming that interrupts are disabled while running the > completion handler. Since that spinlock is not touched by any other > interrupt context code I don't think irqsave is necessary. No, it isn't necessary so leave it as it is. But you are exporting interfaces to other drivers and it may appear to someone that those could possibly end up indirectly calling a function taking that lock in IRQ context. We know that isn't the case now, but I bet someone will post conversion patch for that spinlock at some point. ;) Johan -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index de5abf2..7bcf895 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -183,6 +183,15 @@ config MFD_DA9063 Additional drivers must be enabled in order to use the functionality of the device. +config MFD_DLN2 + tristate "Diolan DLN2 support" + select MFD_CORE + depends on USB + help + This adds support for Diolan USB-I2C/SPI/GPIO Master Adapter DLN-2. + Additional drivers must be enabled in order to use the functionality + of the device. + config MFD_MC13XXX tristate depends on (SPI_MASTER || I2C) diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index f001487..591988d 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -169,6 +169,7 @@ obj-$(CONFIG_MFD_AS3711) += as3711.o obj-$(CONFIG_MFD_AS3722) += as3722.o obj-$(CONFIG_MFD_STW481X) += stw481x.o obj-$(CONFIG_MFD_IPAQ_MICRO) += ipaq-micro.o +obj-$(CONFIG_MFD_DLN2) += dln2.o intel-soc-pmic-objs := intel_soc_pmic_core.o intel_soc_pmic_crc.o obj-$(CONFIG_INTEL_SOC_PMIC) += intel-soc-pmic.o diff --git a/drivers/mfd/dln2.c b/drivers/mfd/dln2.c new file mode 100644 index 0000000..3ff8c6d --- /dev/null +++ b/drivers/mfd/dln2.c @@ -0,0 +1,751 @@ +/* + * Driver for the Diolan DLN-2 USB adapter + * + * Copyright (c) 2014 Intel Corporation + * + * Derived from: + * i2c-diolan-u2c.c + * Copyright (c) 2010-2011 Ericsson AB + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, version 2. + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/types.h> +#include <linux/slab.h> +#include <linux/usb.h> +#include <linux/i2c.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/mfd/core.h> +#include <linux/mfd/dln2.h> +#include <linux/rculist.h> + +struct dln2_header { + __le16 size; + __le16 id; + __le16 echo; + __le16 handle; +} __packed; + +struct dln2_response { + struct dln2_header hdr; + __le16 result; +} __packed; + +#define DLN2_GENERIC_MODULE_ID 0x00 +#define DLN2_GENERIC_CMD(cmd) DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID) +#define CMD_GET_DEVICE_VER DLN2_GENERIC_CMD(0x30) +#define CMD_GET_DEVICE_SN DLN2_GENERIC_CMD(0x31) + +#define DLN2_HW_ID 0x200 +#define DLN2_USB_TIMEOUT 200 /* in ms */ +#define DLN2_MAX_RX_SLOTS 16 +#define DLN2_MAX_URBS 16 +#define DLN2_RX_BUF_SIZE 512 + +enum dln2_handle { + DLN2_HANDLE_EVENT, + DLN2_HANDLE_CTRL, + DLN2_HANDLE_GPIO, + DLN2_HANDLE_I2C, + DLN2_HANDLES +}; + +/* + * Receive context used between the receive demultiplexer and the + * transfer routine. While sending a request the transfer routine + * will look for a free receive context and use it to wait for a + * response and to receive the URB and thus the response data. + */ +struct dln2_rx_context { + /* completion used to wait for a response */ + struct completion done; + + /* if non-NULL the URB contains the response */ + struct urb *urb; + + /* if true then this context is used to wait for a response */ + bool in_use; +}; + +/* + * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We + * use the handle header field to identify the module in + * dln2_dev.mod_rx_slots and then the echo header field to index the + * slots field and find the receive context for a particular request. + */ +struct dln2_mod_rx_slots { + /* RX slots bitmap */ + unsigned long bmap; + + /* used to wait for a free RX slot */ + wait_queue_head_t wq; + + /* used to wait for an RX operation to complete */ + struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS]; + + /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */ + spinlock_t lock; +}; + +struct dln2_dev { + struct usb_device *usb_dev; + struct usb_interface *interface; + u8 ep_in; + u8 ep_out; + + struct urb *rx_urb[DLN2_MAX_URBS]; + void *rx_buf[DLN2_MAX_URBS]; + + struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES]; + + struct list_head event_cb_list; + spinlock_t event_cb_lock; + + bool disconnect; + int active_transfers; + wait_queue_head_t disconnect_wq; + spinlock_t disconnect_lock; +}; + +struct dln2_event_cb_entry { + struct list_head list; + u16 id; + struct platform_device *pdev; + dln2_event_cb_t callback; +}; + +int dln2_register_event_cb(struct platform_device *pdev, u16 id, + dln2_event_cb_t rx_cb) +{ + struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); + struct dln2_event_cb_entry *i, *new; + unsigned long flags; + int ret = 0; + + new = kmalloc(sizeof(*new), GFP_KERNEL); + if (!new) + return -ENOMEM; + + new->id = id; + new->callback = rx_cb; + new->pdev = pdev; + + spin_lock_irqsave(&dln2->event_cb_lock, flags); + + list_for_each_entry(i, &dln2->event_cb_list, list) { + if (i->id == id) { + ret = -EBUSY; + break; + } + } + + if (!ret) + list_add_rcu(&new->list, &dln2->event_cb_list); + + spin_unlock_irqrestore(&dln2->event_cb_lock, flags); + + if (ret) + kfree(new); + + return ret; +} +EXPORT_SYMBOL(dln2_register_event_cb); + +void dln2_unregister_event_cb(struct platform_device *pdev, u16 id) +{ + struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); + struct dln2_event_cb_entry *i; + unsigned long flags; + bool found = false; + + spin_lock_irqsave(&dln2->event_cb_lock, flags); + + list_for_each_entry(i, &dln2->event_cb_list, list) { + if (i->id == id) { + list_del_rcu(&i->list); + found = true; + break; + } + } + + spin_unlock_irqrestore(&dln2->event_cb_lock, flags); + + if (found) { + synchronize_rcu(); + kfree(i); + } +} +EXPORT_SYMBOL(dln2_unregister_event_cb); + +static int dln2_submit_urb(struct dln2_dev *dln2, struct urb *urb, gfp_t gfp) +{ + int ret; + struct device *dev = &dln2->interface->dev; + + ret = usb_submit_urb(urb, gfp); + if (ret < 0) + dev_err(dev, "failed to (re)submit RX URB: %d\n", ret); + return ret; +} + +static void dln2_rx_transfer(struct dln2_dev *dln2, struct urb *urb, + u16 handle, u16 rx_slot) +{ + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; + struct dln2_rx_context *rxc; + struct device *dev = &dln2->interface->dev; + + spin_lock(&rxs->lock); + + rxc = &rxs->slots[rx_slot]; + + if (rxc->in_use && !rxc->urb) { + rxc->urb = urb; + complete(&rxc->done); + /* URB will be resubmitted in free_rx_slot */ + } else { + dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot); + dln2_submit_urb(dln2, urb, GFP_ATOMIC); + } + + spin_unlock(&rxs->lock); +} + +static void dln2_run_rx_callbacks(struct dln2_dev *dln2, u16 id, u16 echo, + void *data, int len) +{ + struct dln2_event_cb_entry *i; + + rcu_read_lock(); + + list_for_each_entry_rcu(i, &dln2->event_cb_list, list) + if (i->id == id) + i->callback(i->pdev, echo, data, len); + + rcu_read_unlock(); +} + +static void dln2_rx(struct urb *urb) +{ + struct dln2_dev *dln2 = urb->context; + struct dln2_header *hdr = urb->transfer_buffer; + struct device *dev = &dln2->interface->dev; + u16 id, echo, handle, size; + u8 *data; + int len; + + switch (urb->status) { + case 0: + /* success */ + break; + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + case -EPIPE: + /* this urb is terminated, clean up */ + dev_dbg(dev, "urb shutting down with status %d\n", urb->status); + return; + default: + dev_dbg(dev, "nonzero urb status received %d\n", urb->status); + goto out; + } + + if (urb->actual_length < sizeof(struct dln2_header)) { + dev_err(dev, "short response: %d\n", urb->actual_length); + goto out; + } + + handle = le16_to_cpu(hdr->handle); + id = le16_to_cpu(hdr->id); + echo = le16_to_cpu(hdr->echo); + size = le16_to_cpu(hdr->size); + + if (size != urb->actual_length) { + dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n", + handle, id, echo, size, urb->actual_length); + goto out; + } + + if (handle >= DLN2_HANDLES) { + dev_warn(dev, "RX: invalid handle %d\n", handle); + goto out; + } + + data = urb->transfer_buffer + sizeof(struct dln2_header); + len = urb->actual_length - sizeof(struct dln2_header); + + if (handle == DLN2_HANDLE_EVENT) { + dln2_run_rx_callbacks(dln2, id, echo, data, len); + } else { + dln2_rx_transfer(dln2, urb, handle, echo); + /* URB will be re-submitted in dln2_rx_transfer */ + return; + } + +out: + dln2_submit_urb(dln2, urb, GFP_ATOMIC); +} + +static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf, + int *obuf_len, gfp_t gfp) +{ + int len; + void *buf; + struct dln2_header *hdr; + + len = *obuf_len + sizeof(*hdr); + buf = kmalloc(len, gfp); + if (!buf) + return NULL; + + hdr = (struct dln2_header *)buf; + hdr->id = cpu_to_le16(cmd); + hdr->size = cpu_to_le16(len); + hdr->echo = cpu_to_le16(echo); + hdr->handle = cpu_to_le16(handle); + + memcpy(buf + sizeof(*hdr), obuf, *obuf_len); + + *obuf_len = len; + + return buf; +} + +static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo, + const void *obuf, int obuf_len) +{ + int ret = 0; + int len = obuf_len; + void *buf; + int actual; + + buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + ret = usb_bulk_msg(dln2->usb_dev, + usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out), + buf, len, &actual, DLN2_USB_TIMEOUT); + + kfree(buf); + + return ret; +} + +static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot) +{ + struct dln2_mod_rx_slots *rxs; + unsigned long flags; + + rxs = &dln2->mod_rx_slots[handle]; + + spin_lock_irqsave(&rxs->lock, flags); + + *slot = find_first_zero_bit(&rxs->bmap, DLN2_MAX_RX_SLOTS); + + if (*slot < DLN2_MAX_RX_SLOTS) { + struct dln2_rx_context *rxc = &rxs->slots[*slot]; + + set_bit(*slot, &rxs->bmap); + rxc->in_use = true; + } + + spin_unlock_irqrestore(&rxs->lock, flags); + + return *slot < DLN2_MAX_RX_SLOTS; +} + +static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle) +{ + int ret; + int slot; + + /* + * No need to timeout here, the wait is bounded by the timeout + * in _dln2_transfer. + */ + ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq, + find_free_slot(dln2, handle, &slot)); + if (ret < 0) + return ret; + + return slot; +} + +static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot) +{ + struct dln2_mod_rx_slots *rxs; + struct urb *urb = NULL; + unsigned long flags; + struct dln2_rx_context *rxc; + + rxs = &dln2->mod_rx_slots[handle]; + + spin_lock_irqsave(&rxs->lock, flags); + + clear_bit(slot, &rxs->bmap); + + rxc = &rxs->slots[slot]; + rxc->in_use = false; + urb = rxc->urb; + rxc->urb = NULL; + reinit_completion(&rxc->done); + + spin_unlock_irqrestore(&rxs->lock, flags); + + if (urb) + dln2_submit_urb(dln2, urb, GFP_KERNEL); + + wake_up_interruptible(&rxs->wq); +} + +static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd, + const void *obuf, unsigned obuf_len, + void *ibuf, unsigned *ibuf_len) +{ + int ret = 0; + u16 result; + int rx_slot; + struct dln2_response *rsp; + struct dln2_rx_context *rxc; + struct device *dev; + const int timeout = DLN2_USB_TIMEOUT * HZ / 1000; + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; + + spin_lock(&dln2->disconnect_lock); + if (!dln2->disconnect) + dln2->active_transfers++; + else + ret = -ENODEV; + spin_unlock(&dln2->disconnect_lock); + + if (ret) + return ret; + + rx_slot = alloc_rx_slot(dln2, handle); + if (rx_slot < 0) { + ret = rx_slot; + goto out_decr; + } + + dev = &dln2->interface->dev; + + ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len); + if (ret < 0) { + dev_err(dev, "USB write failed: %d\n", ret); + goto out_free_rx_slot; + } + + rxc = &rxs->slots[rx_slot]; + + ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout); + if (ret <= 0) { + if (!ret) + ret = -ETIMEDOUT; + goto out_free_rx_slot; + } + + if (!rxc->urb) { + ret = -ENODEV; + goto out_free_rx_slot; + } + + /* if we got here we know that the response header has been checked */ + rsp = rxc->urb->transfer_buffer; + + if (rsp->hdr.size < sizeof(*rsp)) { + ret = -EPROTO; + goto out_free_rx_slot; + } + + result = le16_to_cpu(rsp->result); + if (result) { + dev_dbg(dev, "%d received response with error %d\n", + handle, result); + ret = -EREMOTEIO; + goto out_free_rx_slot; + } + + if (!ibuf) { + ret = 0; + goto out_free_rx_slot; + } + + if (*ibuf_len > rsp->hdr.size - sizeof(*rsp)) + *ibuf_len = rsp->hdr.size - sizeof(*rsp); + + memcpy(ibuf, rsp + 1, *ibuf_len); + +out_free_rx_slot: + free_rx_slot(dln2, handle, rx_slot); +out_decr: + spin_lock(&dln2->disconnect_lock); + dln2->active_transfers--; + spin_unlock(&dln2->disconnect_lock); + if (dln2->disconnect) + wake_up(&dln2->disconnect_wq); + + return ret; +} + +int dln2_transfer(struct platform_device *pdev, u16 cmd, + const void *obuf, unsigned obuf_len, + void *ibuf, unsigned *ibuf_len) +{ + struct dln2_platform_data *dln2_pdata; + struct dln2_dev *dln2; + u16 h; + + dln2 = dev_get_drvdata(pdev->dev.parent); + dln2_pdata = dev_get_platdata(&pdev->dev); + h = dln2_pdata->handle; + + return _dln2_transfer(dln2, h, cmd, obuf, obuf_len, ibuf, ibuf_len); +} +EXPORT_SYMBOL(dln2_transfer); + +static int dln2_check_hw(struct dln2_dev *dln2) +{ + int ret; + __le32 hw_type; + int len = sizeof(hw_type); + + ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER, + NULL, 0, &hw_type, &len); + if (ret < 0) + return ret; + if (len < sizeof(hw_type)) + return -EREMOTEIO; + + if (le32_to_cpu(hw_type) != DLN2_HW_ID) { + dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n", + le32_to_cpu(hw_type)); + return -ENODEV; + } + + return 0; +} + +static int dln2_print_serialno(struct dln2_dev *dln2) +{ + int ret; + __le32 serial_no; + int len = sizeof(serial_no); + struct device *dev = &dln2->interface->dev; + + ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0, + &serial_no, &len); + if (ret < 0) + return ret; + if (len < sizeof(serial_no)) + return -EREMOTEIO; + + dev_info(dev, "Diolan DLN2 serial 0x%x\n", le32_to_cpu(serial_no)); + + return 0; +} + +static int dln2_hw_init(struct dln2_dev *dln2) +{ + int ret; + + ret = dln2_check_hw(dln2); + if (ret < 0) + return ret; + + return dln2_print_serialno(dln2); +} + +static void dln2_free_rx_urbs(struct dln2_dev *dln2) +{ + int i; + + for (i = 0; i < DLN2_MAX_URBS; i++) { + usb_kill_urb(dln2->rx_urb[i]); + usb_free_urb(dln2->rx_urb[i]); + kfree(dln2->rx_buf[i]); + } +} + +static void dln2_free(struct dln2_dev *dln2) +{ + dln2_free_rx_urbs(dln2); + usb_put_dev(dln2->usb_dev); + kfree(dln2); +} + +static int dln2_setup_rx_urbs(struct dln2_dev *dln2, + struct usb_host_interface *hostif) +{ + int i; + const int rx_max_size = DLN2_RX_BUF_SIZE; + + for (i = 0; i < DLN2_MAX_URBS; i++) { + int ret; + + dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL); + if (!dln2->rx_buf[i]) + return -ENOMEM; + + dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL); + if (!dln2->rx_urb[i]) + return -ENOMEM; + + usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev, + usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in), + dln2->rx_buf[i], rx_max_size, dln2_rx, dln2); + + ret = dln2_submit_urb(dln2, dln2->rx_urb[i], GFP_KERNEL); + if (ret < 0) + return ret; + } + + return 0; +} + +static struct dln2_platform_data dln2_pdata_gpio = { + .handle = DLN2_HANDLE_GPIO, +}; + +/* Only one I2C port seems to be supported on current hardware */ +static struct dln2_platform_data dln2_pdata_i2c = { + .handle = DLN2_HANDLE_I2C, + .port = 0, +}; + +static const struct mfd_cell dln2_devs[] = { + { + .name = "dln2-gpio", + .platform_data = &dln2_pdata_gpio, + .pdata_size = sizeof(struct dln2_platform_data), + }, + { + .name = "dln2-i2c", + .platform_data = &dln2_pdata_i2c, + .pdata_size = sizeof(struct dln2_platform_data), + }, +}; + +static void dln2_disconnect(struct usb_interface *interface) +{ + struct dln2_dev *dln2 = usb_get_intfdata(interface); + int i, j; + + /* don't allow starting new transfers */ + spin_lock(&dln2->disconnect_lock); + dln2->disconnect = true; + spin_unlock(&dln2->disconnect_lock); + + /* cancel in progress transfers */ + for (i = 0; i < DLN2_HANDLES; i++) { + struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; + unsigned long flags; + + spin_lock_irqsave(&rxs->lock, flags); + + /* cancel all response waiters */ + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) { + struct dln2_rx_context *rxc = &rxs->slots[j]; + + if (rxc->in_use) + complete(&rxc->done); + } + + spin_unlock_irqrestore(&rxs->lock, flags); + } + + /* wait for transfers to end */ + wait_event(dln2->disconnect_wq, !dln2->active_transfers); + + mfd_remove_devices(&interface->dev); + + dln2_free(dln2); +} + +static int dln2_probe(struct usb_interface *interface, + const struct usb_device_id *usb_id) +{ + struct usb_host_interface *hostif = interface->cur_altsetting; + struct device *dev = &interface->dev; + struct dln2_dev *dln2; + int ret; + int i, j; + int id; + + if (hostif->desc.bInterfaceNumber != 0 || + hostif->desc.bNumEndpoints < 2) + return -ENODEV; + + dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL); + if (!dln2) + return -ENOMEM; + + dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress; + dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress; + dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface)); + dln2->interface = interface; + usb_set_intfdata(interface, dln2); + init_waitqueue_head(&dln2->disconnect_wq); + + for (i = 0; i < DLN2_HANDLES; i++) { + init_waitqueue_head(&dln2->mod_rx_slots[i].wq); + spin_lock_init(&dln2->mod_rx_slots[i].lock); + for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) + init_completion(&dln2->mod_rx_slots[i].slots[j].done); + } + + spin_lock_init(&dln2->event_cb_lock); + INIT_LIST_HEAD(&dln2->event_cb_list); + + ret = dln2_setup_rx_urbs(dln2, hostif); + if (ret) { + dln2_free(dln2); + return ret; + } + + ret = dln2_hw_init(dln2); + if (ret < 0) { + dev_err(dev, "failed to initialize hardware\n"); + goto out_cleanup; + } + + id = dln2->usb_dev->bus->busnum << 8 | dln2->usb_dev->devnum; + ret = mfd_add_devices(dev, id, dln2_devs, ARRAY_SIZE(dln2_devs), + NULL, 0, NULL); + if (ret != 0) { + dev_err(dev, "failed to add mfd devices to core\n"); + goto out_cleanup; + } + + return 0; + +out_cleanup: + dln2_free(dln2); + + return ret; +} + +static const struct usb_device_id dln2_table[] = { + { USB_DEVICE(0xa257, 0x2013) }, + { } +}; + +MODULE_DEVICE_TABLE(usb, dln2_table); + +static struct usb_driver dln2_driver = { + .name = "usb-dln2", + .probe = dln2_probe, + .disconnect = dln2_disconnect, + .id_table = dln2_table, +}; + +module_usb_driver(dln2_driver); + +MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>"); +MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter"); +MODULE_LICENSE("GPL v2"); diff --git a/include/linux/mfd/dln2.h b/include/linux/mfd/dln2.h new file mode 100644 index 0000000..0b0d822 --- /dev/null +++ b/include/linux/mfd/dln2.h @@ -0,0 +1,67 @@ +#ifndef __LINUX_USB_DLN2_H +#define __LINUX_USB_DLN2_H + +#define DLN2_CMD(cmd, id) ((cmd) | ((id) << 8)) + +struct dln2_platform_data { + u16 handle; /* sub-driver handle (internally used only) */ + u8 port; /* I2C/SPI port */ +}; + +/** + * dln2_event_cb_t - event callback function signature + * + * @pdev - the sub-device that registered this callback + * @echo - the echo header field received in the message + * @data - the data payload + * @len - the data payload length + * + * The callback function is called in interrupt context and the data + * payload is only valid during the call. If the user needs later + * access of the data, it must copy it. + */ + +typedef void (*dln2_event_cb_t)(struct platform_device *pdev, u16 echo, + const void *data, int len); + +/** + * dl2n_register_event_cb - register a callback function for an event + * + * @pdev - the sub-device that registers the callback + * @event - the event for which to register a callback + * @event_cb - the callback function + * + * @return 0 in case of success, negative value in case of error + */ +int dln2_register_event_cb(struct platform_device *pdev, u16 event, + dln2_event_cb_t event_cb); + +/** + * dln2_unregister_event_cb - unregister the callback function for an event + * + * @pdev - the sub-device that registered the callback + * @event - the event for which to register a callback + */ +void dln2_unregister_event_cb(struct platform_device *pdev, u16 event); + +/** + * dln2_transfer - issue a DLN2 command and wait for a response and + * the associated data + * + * @pdev - the sub-device which is issuing this transfer + * @cmd - the command to be sent to the device + * @obuf - the buffer to be sent to the device; can be NULL if the + * user doesn't need to transmit data with this command + * @obuf_len - the size of the buffer to be sent to the device + * @ibuf - any data associated with the response will be copied here; + * it can be NULL if the user doesn't need the response data + * @ibuf_len - must be initialized to the input buffer size; it will + * be modified to indicate the actual data transfered + * + * @returns 0 for success, negative value for errors + */ +int dln2_transfer(struct platform_device *pdev, u16 cmd, + const void *obuf, unsigned obuf_len, + void *ibuf, unsigned *ibuf_len); + +#endif
This patch implements the USB part of the Diolan USB-I2C/SPI/GPIO Master Adapter DLN-2. Details about the device can be found here: https://www.diolan.com/i2c/i2c_interface.html. Information about the USB protocol can be found in the Programmer's Reference Manual [1], see section 1.7. Because the hardware has a single transmit endpoint and a single receive endpoint the communication between the various DLN2 drivers and the hardware will be muxed/demuxed by this driver. Each DLN2 module will be identified by the handle field within the DLN2 message header. If a DLN2 module issues multiple commands in parallel they will be identified by the echo counter field in the message header. The DLN2 modules can use the dln2_transfer() function to issue a command and wait for its response. They can also register a callback that is going to be called when a specific event id is generated by the device (e.g. GPIO interrupts). The device uses handle 0 for sending events. [1] https://www.diolan.com/downloads/dln-api-manual.pdf Signed-off-by: Octavian Purdila <octavian.purdila@intel.com> --- drivers/mfd/Kconfig | 9 + drivers/mfd/Makefile | 1 + drivers/mfd/dln2.c | 751 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/mfd/dln2.h | 67 +++++ 4 files changed, 828 insertions(+) create mode 100644 drivers/mfd/dln2.c create mode 100644 include/linux/mfd/dln2.h