Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Driver for the Diolan DLN-2 USB adapter
0004  *
0005  * Copyright (c) 2014 Intel Corporation
0006  *
0007  * Derived from:
0008  *  i2c-diolan-u2c.c
0009  *  Copyright (c) 2010-2011 Ericsson AB
0010  */
0011 
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/types.h>
0015 #include <linux/slab.h>
0016 #include <linux/usb.h>
0017 #include <linux/i2c.h>
0018 #include <linux/mutex.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/mfd/core.h>
0021 #include <linux/mfd/dln2.h>
0022 #include <linux/rculist.h>
0023 
0024 struct dln2_header {
0025     __le16 size;
0026     __le16 id;
0027     __le16 echo;
0028     __le16 handle;
0029 };
0030 
0031 struct dln2_response {
0032     struct dln2_header hdr;
0033     __le16 result;
0034 };
0035 
0036 #define DLN2_GENERIC_MODULE_ID      0x00
0037 #define DLN2_GENERIC_CMD(cmd)       DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID)
0038 #define CMD_GET_DEVICE_VER      DLN2_GENERIC_CMD(0x30)
0039 #define CMD_GET_DEVICE_SN       DLN2_GENERIC_CMD(0x31)
0040 
0041 #define DLN2_HW_ID          0x200
0042 #define DLN2_USB_TIMEOUT        200 /* in ms */
0043 #define DLN2_MAX_RX_SLOTS       16
0044 #define DLN2_MAX_URBS           16
0045 #define DLN2_RX_BUF_SIZE        512
0046 
0047 enum dln2_handle {
0048     DLN2_HANDLE_EVENT = 0,      /* don't change, hardware defined */
0049     DLN2_HANDLE_CTRL,
0050     DLN2_HANDLE_GPIO,
0051     DLN2_HANDLE_I2C,
0052     DLN2_HANDLE_SPI,
0053     DLN2_HANDLE_ADC,
0054     DLN2_HANDLES
0055 };
0056 
0057 /*
0058  * Receive context used between the receive demultiplexer and the transfer
0059  * routine. While sending a request the transfer routine will look for a free
0060  * receive context and use it to wait for a response and to receive the URB and
0061  * thus the response data.
0062  */
0063 struct dln2_rx_context {
0064     /* completion used to wait for a response */
0065     struct completion done;
0066 
0067     /* if non-NULL the URB contains the response */
0068     struct urb *urb;
0069 
0070     /* if true then this context is used to wait for a response */
0071     bool in_use;
0072 };
0073 
0074 /*
0075  * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the
0076  * handle header field to identify the module in dln2_dev.mod_rx_slots and then
0077  * the echo header field to index the slots field and find the receive context
0078  * for a particular request.
0079  */
0080 struct dln2_mod_rx_slots {
0081     /* RX slots bitmap */
0082     DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS);
0083 
0084     /* used to wait for a free RX slot */
0085     wait_queue_head_t wq;
0086 
0087     /* used to wait for an RX operation to complete */
0088     struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS];
0089 
0090     /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */
0091     spinlock_t lock;
0092 };
0093 
0094 struct dln2_dev {
0095     struct usb_device *usb_dev;
0096     struct usb_interface *interface;
0097     u8 ep_in;
0098     u8 ep_out;
0099 
0100     struct urb *rx_urb[DLN2_MAX_URBS];
0101     void *rx_buf[DLN2_MAX_URBS];
0102 
0103     struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES];
0104 
0105     struct list_head event_cb_list;
0106     spinlock_t event_cb_lock;
0107 
0108     bool disconnect;
0109     int active_transfers;
0110     wait_queue_head_t disconnect_wq;
0111     spinlock_t disconnect_lock;
0112 };
0113 
0114 struct dln2_event_cb_entry {
0115     struct list_head list;
0116     u16 id;
0117     struct platform_device *pdev;
0118     dln2_event_cb_t callback;
0119 };
0120 
0121 int dln2_register_event_cb(struct platform_device *pdev, u16 id,
0122                dln2_event_cb_t event_cb)
0123 {
0124     struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
0125     struct dln2_event_cb_entry *i, *entry;
0126     unsigned long flags;
0127     int ret = 0;
0128 
0129     entry = kzalloc(sizeof(*entry), GFP_KERNEL);
0130     if (!entry)
0131         return -ENOMEM;
0132 
0133     entry->id = id;
0134     entry->callback = event_cb;
0135     entry->pdev = pdev;
0136 
0137     spin_lock_irqsave(&dln2->event_cb_lock, flags);
0138 
0139     list_for_each_entry(i, &dln2->event_cb_list, list) {
0140         if (i->id == id) {
0141             ret = -EBUSY;
0142             break;
0143         }
0144     }
0145 
0146     if (!ret)
0147         list_add_rcu(&entry->list, &dln2->event_cb_list);
0148 
0149     spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
0150 
0151     if (ret)
0152         kfree(entry);
0153 
0154     return ret;
0155 }
0156 EXPORT_SYMBOL(dln2_register_event_cb);
0157 
0158 void dln2_unregister_event_cb(struct platform_device *pdev, u16 id)
0159 {
0160     struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
0161     struct dln2_event_cb_entry *i;
0162     unsigned long flags;
0163     bool found = false;
0164 
0165     spin_lock_irqsave(&dln2->event_cb_lock, flags);
0166 
0167     list_for_each_entry(i, &dln2->event_cb_list, list) {
0168         if (i->id == id) {
0169             list_del_rcu(&i->list);
0170             found = true;
0171             break;
0172         }
0173     }
0174 
0175     spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
0176 
0177     if (found) {
0178         synchronize_rcu();
0179         kfree(i);
0180     }
0181 }
0182 EXPORT_SYMBOL(dln2_unregister_event_cb);
0183 
0184 /*
0185  * Returns true if a valid transfer slot is found. In this case the URB must not
0186  * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer
0187  * is woke up. It will be resubmitted there.
0188  */
0189 static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb,
0190                    u16 handle, u16 rx_slot)
0191 {
0192     struct device *dev = &dln2->interface->dev;
0193     struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
0194     struct dln2_rx_context *rxc;
0195     unsigned long flags;
0196     bool valid_slot = false;
0197 
0198     if (rx_slot >= DLN2_MAX_RX_SLOTS)
0199         goto out;
0200 
0201     rxc = &rxs->slots[rx_slot];
0202 
0203     spin_lock_irqsave(&rxs->lock, flags);
0204     if (rxc->in_use && !rxc->urb) {
0205         rxc->urb = urb;
0206         complete(&rxc->done);
0207         valid_slot = true;
0208     }
0209     spin_unlock_irqrestore(&rxs->lock, flags);
0210 
0211 out:
0212     if (!valid_slot)
0213         dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot);
0214 
0215     return valid_slot;
0216 }
0217 
0218 static void dln2_run_event_callbacks(struct dln2_dev *dln2, u16 id, u16 echo,
0219                      void *data, int len)
0220 {
0221     struct dln2_event_cb_entry *i;
0222 
0223     rcu_read_lock();
0224 
0225     list_for_each_entry_rcu(i, &dln2->event_cb_list, list) {
0226         if (i->id == id) {
0227             i->callback(i->pdev, echo, data, len);
0228             break;
0229         }
0230     }
0231 
0232     rcu_read_unlock();
0233 }
0234 
0235 static void dln2_rx(struct urb *urb)
0236 {
0237     struct dln2_dev *dln2 = urb->context;
0238     struct dln2_header *hdr = urb->transfer_buffer;
0239     struct device *dev = &dln2->interface->dev;
0240     u16 id, echo, handle, size;
0241     u8 *data;
0242     int len;
0243     int err;
0244 
0245     switch (urb->status) {
0246     case 0:
0247         /* success */
0248         break;
0249     case -ECONNRESET:
0250     case -ENOENT:
0251     case -ESHUTDOWN:
0252     case -EPIPE:
0253         /* this urb is terminated, clean up */
0254         dev_dbg(dev, "urb shutting down with status %d\n", urb->status);
0255         return;
0256     default:
0257         dev_dbg(dev, "nonzero urb status received %d\n", urb->status);
0258         goto out;
0259     }
0260 
0261     if (urb->actual_length < sizeof(struct dln2_header)) {
0262         dev_err(dev, "short response: %d\n", urb->actual_length);
0263         goto out;
0264     }
0265 
0266     handle = le16_to_cpu(hdr->handle);
0267     id = le16_to_cpu(hdr->id);
0268     echo = le16_to_cpu(hdr->echo);
0269     size = le16_to_cpu(hdr->size);
0270 
0271     if (size != urb->actual_length) {
0272         dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n",
0273             handle, id, echo, size, urb->actual_length);
0274         goto out;
0275     }
0276 
0277     if (handle >= DLN2_HANDLES) {
0278         dev_warn(dev, "invalid handle %d\n", handle);
0279         goto out;
0280     }
0281 
0282     data = urb->transfer_buffer + sizeof(struct dln2_header);
0283     len = urb->actual_length - sizeof(struct dln2_header);
0284 
0285     if (handle == DLN2_HANDLE_EVENT) {
0286         unsigned long flags;
0287 
0288         spin_lock_irqsave(&dln2->event_cb_lock, flags);
0289         dln2_run_event_callbacks(dln2, id, echo, data, len);
0290         spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
0291     } else {
0292         /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
0293         if (dln2_transfer_complete(dln2, urb, handle, echo))
0294             return;
0295     }
0296 
0297 out:
0298     err = usb_submit_urb(urb, GFP_ATOMIC);
0299     if (err < 0)
0300         dev_err(dev, "failed to resubmit RX URB: %d\n", err);
0301 }
0302 
0303 static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
0304                int *obuf_len, gfp_t gfp)
0305 {
0306     int len;
0307     void *buf;
0308     struct dln2_header *hdr;
0309 
0310     len = *obuf_len + sizeof(*hdr);
0311     buf = kmalloc(len, gfp);
0312     if (!buf)
0313         return NULL;
0314 
0315     hdr = (struct dln2_header *)buf;
0316     hdr->id = cpu_to_le16(cmd);
0317     hdr->size = cpu_to_le16(len);
0318     hdr->echo = cpu_to_le16(echo);
0319     hdr->handle = cpu_to_le16(handle);
0320 
0321     memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
0322 
0323     *obuf_len = len;
0324 
0325     return buf;
0326 }
0327 
0328 static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
0329               const void *obuf, int obuf_len)
0330 {
0331     int ret = 0;
0332     int len = obuf_len;
0333     void *buf;
0334     int actual;
0335 
0336     buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
0337     if (!buf)
0338         return -ENOMEM;
0339 
0340     ret = usb_bulk_msg(dln2->usb_dev,
0341                usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
0342                buf, len, &actual, DLN2_USB_TIMEOUT);
0343 
0344     kfree(buf);
0345 
0346     return ret;
0347 }
0348 
0349 static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
0350 {
0351     struct dln2_mod_rx_slots *rxs;
0352     unsigned long flags;
0353 
0354     if (dln2->disconnect) {
0355         *slot = -ENODEV;
0356         return true;
0357     }
0358 
0359     rxs = &dln2->mod_rx_slots[handle];
0360 
0361     spin_lock_irqsave(&rxs->lock, flags);
0362 
0363     *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
0364 
0365     if (*slot < DLN2_MAX_RX_SLOTS) {
0366         struct dln2_rx_context *rxc = &rxs->slots[*slot];
0367 
0368         set_bit(*slot, rxs->bmap);
0369         rxc->in_use = true;
0370     }
0371 
0372     spin_unlock_irqrestore(&rxs->lock, flags);
0373 
0374     return *slot < DLN2_MAX_RX_SLOTS;
0375 }
0376 
0377 static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
0378 {
0379     int ret;
0380     int slot;
0381 
0382     /*
0383      * No need to timeout here, the wait is bounded by the timeout in
0384      * _dln2_transfer.
0385      */
0386     ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
0387                        find_free_slot(dln2, handle, &slot));
0388     if (ret < 0)
0389         return ret;
0390 
0391     return slot;
0392 }
0393 
0394 static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
0395 {
0396     struct dln2_mod_rx_slots *rxs;
0397     struct urb *urb = NULL;
0398     unsigned long flags;
0399     struct dln2_rx_context *rxc;
0400 
0401     rxs = &dln2->mod_rx_slots[handle];
0402 
0403     spin_lock_irqsave(&rxs->lock, flags);
0404 
0405     clear_bit(slot, rxs->bmap);
0406 
0407     rxc = &rxs->slots[slot];
0408     rxc->in_use = false;
0409     urb = rxc->urb;
0410     rxc->urb = NULL;
0411     reinit_completion(&rxc->done);
0412 
0413     spin_unlock_irqrestore(&rxs->lock, flags);
0414 
0415     if (urb) {
0416         int err;
0417         struct device *dev = &dln2->interface->dev;
0418 
0419         err = usb_submit_urb(urb, GFP_KERNEL);
0420         if (err < 0)
0421             dev_err(dev, "failed to resubmit RX URB: %d\n", err);
0422     }
0423 
0424     wake_up_interruptible(&rxs->wq);
0425 }
0426 
0427 static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
0428               const void *obuf, unsigned obuf_len,
0429               void *ibuf, unsigned *ibuf_len)
0430 {
0431     int ret = 0;
0432     int rx_slot;
0433     struct dln2_response *rsp;
0434     struct dln2_rx_context *rxc;
0435     struct device *dev = &dln2->interface->dev;
0436     const unsigned long timeout = msecs_to_jiffies(DLN2_USB_TIMEOUT);
0437     struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
0438     int size;
0439 
0440     spin_lock(&dln2->disconnect_lock);
0441     if (!dln2->disconnect)
0442         dln2->active_transfers++;
0443     else
0444         ret = -ENODEV;
0445     spin_unlock(&dln2->disconnect_lock);
0446 
0447     if (ret)
0448         return ret;
0449 
0450     rx_slot = alloc_rx_slot(dln2, handle);
0451     if (rx_slot < 0) {
0452         ret = rx_slot;
0453         goto out_decr;
0454     }
0455 
0456     ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len);
0457     if (ret < 0) {
0458         dev_err(dev, "USB write failed: %d\n", ret);
0459         goto out_free_rx_slot;
0460     }
0461 
0462     rxc = &rxs->slots[rx_slot];
0463 
0464     ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout);
0465     if (ret <= 0) {
0466         if (!ret)
0467             ret = -ETIMEDOUT;
0468         goto out_free_rx_slot;
0469     } else {
0470         ret = 0;
0471     }
0472 
0473     if (dln2->disconnect) {
0474         ret = -ENODEV;
0475         goto out_free_rx_slot;
0476     }
0477 
0478     /* if we got here we know that the response header has been checked */
0479     rsp = rxc->urb->transfer_buffer;
0480     size = le16_to_cpu(rsp->hdr.size);
0481 
0482     if (size < sizeof(*rsp)) {
0483         ret = -EPROTO;
0484         goto out_free_rx_slot;
0485     }
0486 
0487     if (le16_to_cpu(rsp->result) > 0x80) {
0488         dev_dbg(dev, "%d received response with error %d\n",
0489             handle, le16_to_cpu(rsp->result));
0490         ret = -EREMOTEIO;
0491         goto out_free_rx_slot;
0492     }
0493 
0494     if (!ibuf)
0495         goto out_free_rx_slot;
0496 
0497     if (*ibuf_len > size - sizeof(*rsp))
0498         *ibuf_len = size - sizeof(*rsp);
0499 
0500     memcpy(ibuf, rsp + 1, *ibuf_len);
0501 
0502 out_free_rx_slot:
0503     free_rx_slot(dln2, handle, rx_slot);
0504 out_decr:
0505     spin_lock(&dln2->disconnect_lock);
0506     dln2->active_transfers--;
0507     spin_unlock(&dln2->disconnect_lock);
0508     if (dln2->disconnect)
0509         wake_up(&dln2->disconnect_wq);
0510 
0511     return ret;
0512 }
0513 
0514 int dln2_transfer(struct platform_device *pdev, u16 cmd,
0515           const void *obuf, unsigned obuf_len,
0516           void *ibuf, unsigned *ibuf_len)
0517 {
0518     struct dln2_platform_data *dln2_pdata;
0519     struct dln2_dev *dln2;
0520     u16 handle;
0521 
0522     dln2 = dev_get_drvdata(pdev->dev.parent);
0523     dln2_pdata = dev_get_platdata(&pdev->dev);
0524     handle = dln2_pdata->handle;
0525 
0526     return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
0527                   ibuf_len);
0528 }
0529 EXPORT_SYMBOL(dln2_transfer);
0530 
0531 static int dln2_check_hw(struct dln2_dev *dln2)
0532 {
0533     int ret;
0534     __le32 hw_type;
0535     int len = sizeof(hw_type);
0536 
0537     ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
0538                  NULL, 0, &hw_type, &len);
0539     if (ret < 0)
0540         return ret;
0541     if (len < sizeof(hw_type))
0542         return -EREMOTEIO;
0543 
0544     if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
0545         dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
0546             le32_to_cpu(hw_type));
0547         return -ENODEV;
0548     }
0549 
0550     return 0;
0551 }
0552 
0553 static int dln2_print_serialno(struct dln2_dev *dln2)
0554 {
0555     int ret;
0556     __le32 serial_no;
0557     int len = sizeof(serial_no);
0558     struct device *dev = &dln2->interface->dev;
0559 
0560     ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
0561                  &serial_no, &len);
0562     if (ret < 0)
0563         return ret;
0564     if (len < sizeof(serial_no))
0565         return -EREMOTEIO;
0566 
0567     dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
0568 
0569     return 0;
0570 }
0571 
0572 static int dln2_hw_init(struct dln2_dev *dln2)
0573 {
0574     int ret;
0575 
0576     ret = dln2_check_hw(dln2);
0577     if (ret < 0)
0578         return ret;
0579 
0580     return dln2_print_serialno(dln2);
0581 }
0582 
0583 static void dln2_free_rx_urbs(struct dln2_dev *dln2)
0584 {
0585     int i;
0586 
0587     for (i = 0; i < DLN2_MAX_URBS; i++) {
0588         usb_free_urb(dln2->rx_urb[i]);
0589         kfree(dln2->rx_buf[i]);
0590     }
0591 }
0592 
0593 static void dln2_stop_rx_urbs(struct dln2_dev *dln2)
0594 {
0595     int i;
0596 
0597     for (i = 0; i < DLN2_MAX_URBS; i++)
0598         usb_kill_urb(dln2->rx_urb[i]);
0599 }
0600 
0601 static void dln2_free(struct dln2_dev *dln2)
0602 {
0603     dln2_free_rx_urbs(dln2);
0604     usb_put_dev(dln2->usb_dev);
0605     kfree(dln2);
0606 }
0607 
0608 static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
0609                   struct usb_host_interface *hostif)
0610 {
0611     int i;
0612     const int rx_max_size = DLN2_RX_BUF_SIZE;
0613 
0614     for (i = 0; i < DLN2_MAX_URBS; i++) {
0615         dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
0616         if (!dln2->rx_buf[i])
0617             return -ENOMEM;
0618 
0619         dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
0620         if (!dln2->rx_urb[i])
0621             return -ENOMEM;
0622 
0623         usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
0624                   usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
0625                   dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
0626     }
0627 
0628     return 0;
0629 }
0630 
0631 static int dln2_start_rx_urbs(struct dln2_dev *dln2, gfp_t gfp)
0632 {
0633     struct device *dev = &dln2->interface->dev;
0634     int ret;
0635     int i;
0636 
0637     for (i = 0; i < DLN2_MAX_URBS; i++) {
0638         ret = usb_submit_urb(dln2->rx_urb[i], gfp);
0639         if (ret < 0) {
0640             dev_err(dev, "failed to submit RX URB: %d\n", ret);
0641             return ret;
0642         }
0643     }
0644 
0645     return 0;
0646 }
0647 
0648 enum {
0649     DLN2_ACPI_MATCH_GPIO    = 0,
0650     DLN2_ACPI_MATCH_I2C = 1,
0651     DLN2_ACPI_MATCH_SPI = 2,
0652     DLN2_ACPI_MATCH_ADC = 3,
0653 };
0654 
0655 static struct dln2_platform_data dln2_pdata_gpio = {
0656     .handle = DLN2_HANDLE_GPIO,
0657 };
0658 
0659 static struct mfd_cell_acpi_match dln2_acpi_match_gpio = {
0660     .adr = DLN2_ACPI_MATCH_GPIO,
0661 };
0662 
0663 /* Only one I2C port seems to be supported on current hardware */
0664 static struct dln2_platform_data dln2_pdata_i2c = {
0665     .handle = DLN2_HANDLE_I2C,
0666     .port = 0,
0667 };
0668 
0669 static struct mfd_cell_acpi_match dln2_acpi_match_i2c = {
0670     .adr = DLN2_ACPI_MATCH_I2C,
0671 };
0672 
0673 /* Only one SPI port supported */
0674 static struct dln2_platform_data dln2_pdata_spi = {
0675     .handle = DLN2_HANDLE_SPI,
0676     .port = 0,
0677 };
0678 
0679 static struct mfd_cell_acpi_match dln2_acpi_match_spi = {
0680     .adr = DLN2_ACPI_MATCH_SPI,
0681 };
0682 
0683 /* Only one ADC port supported */
0684 static struct dln2_platform_data dln2_pdata_adc = {
0685     .handle = DLN2_HANDLE_ADC,
0686     .port = 0,
0687 };
0688 
0689 static struct mfd_cell_acpi_match dln2_acpi_match_adc = {
0690     .adr = DLN2_ACPI_MATCH_ADC,
0691 };
0692 
0693 static const struct mfd_cell dln2_devs[] = {
0694     {
0695         .name = "dln2-gpio",
0696         .acpi_match = &dln2_acpi_match_gpio,
0697         .platform_data = &dln2_pdata_gpio,
0698         .pdata_size = sizeof(struct dln2_platform_data),
0699     },
0700     {
0701         .name = "dln2-i2c",
0702         .acpi_match = &dln2_acpi_match_i2c,
0703         .platform_data = &dln2_pdata_i2c,
0704         .pdata_size = sizeof(struct dln2_platform_data),
0705     },
0706     {
0707         .name = "dln2-spi",
0708         .acpi_match = &dln2_acpi_match_spi,
0709         .platform_data = &dln2_pdata_spi,
0710         .pdata_size = sizeof(struct dln2_platform_data),
0711     },
0712     {
0713         .name = "dln2-adc",
0714         .acpi_match = &dln2_acpi_match_adc,
0715         .platform_data = &dln2_pdata_adc,
0716         .pdata_size = sizeof(struct dln2_platform_data),
0717     },
0718 };
0719 
0720 static void dln2_stop(struct dln2_dev *dln2)
0721 {
0722     int i, j;
0723 
0724     /* don't allow starting new transfers */
0725     spin_lock(&dln2->disconnect_lock);
0726     dln2->disconnect = true;
0727     spin_unlock(&dln2->disconnect_lock);
0728 
0729     /* cancel in progress transfers */
0730     for (i = 0; i < DLN2_HANDLES; i++) {
0731         struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
0732         unsigned long flags;
0733 
0734         spin_lock_irqsave(&rxs->lock, flags);
0735 
0736         /* cancel all response waiters */
0737         for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
0738             struct dln2_rx_context *rxc = &rxs->slots[j];
0739 
0740             if (rxc->in_use)
0741                 complete(&rxc->done);
0742         }
0743 
0744         spin_unlock_irqrestore(&rxs->lock, flags);
0745     }
0746 
0747     /* wait for transfers to end */
0748     wait_event(dln2->disconnect_wq, !dln2->active_transfers);
0749 
0750     dln2_stop_rx_urbs(dln2);
0751 }
0752 
0753 static void dln2_disconnect(struct usb_interface *interface)
0754 {
0755     struct dln2_dev *dln2 = usb_get_intfdata(interface);
0756 
0757     dln2_stop(dln2);
0758 
0759     mfd_remove_devices(&interface->dev);
0760 
0761     dln2_free(dln2);
0762 }
0763 
0764 static int dln2_probe(struct usb_interface *interface,
0765               const struct usb_device_id *usb_id)
0766 {
0767     struct usb_host_interface *hostif = interface->cur_altsetting;
0768     struct usb_endpoint_descriptor *epin;
0769     struct usb_endpoint_descriptor *epout;
0770     struct device *dev = &interface->dev;
0771     struct dln2_dev *dln2;
0772     int ret;
0773     int i, j;
0774 
0775     if (hostif->desc.bInterfaceNumber != 0)
0776         return -ENODEV;
0777 
0778     ret = usb_find_common_endpoints(hostif, &epin, &epout, NULL, NULL);
0779     if (ret)
0780         return ret;
0781 
0782     dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
0783     if (!dln2)
0784         return -ENOMEM;
0785 
0786     dln2->ep_out = epout->bEndpointAddress;
0787     dln2->ep_in = epin->bEndpointAddress;
0788     dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
0789     dln2->interface = interface;
0790     usb_set_intfdata(interface, dln2);
0791     init_waitqueue_head(&dln2->disconnect_wq);
0792 
0793     for (i = 0; i < DLN2_HANDLES; i++) {
0794         init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
0795         spin_lock_init(&dln2->mod_rx_slots[i].lock);
0796         for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
0797             init_completion(&dln2->mod_rx_slots[i].slots[j].done);
0798     }
0799 
0800     spin_lock_init(&dln2->event_cb_lock);
0801     spin_lock_init(&dln2->disconnect_lock);
0802     INIT_LIST_HEAD(&dln2->event_cb_list);
0803 
0804     ret = dln2_setup_rx_urbs(dln2, hostif);
0805     if (ret)
0806         goto out_free;
0807 
0808     ret = dln2_start_rx_urbs(dln2, GFP_KERNEL);
0809     if (ret)
0810         goto out_stop_rx;
0811 
0812     ret = dln2_hw_init(dln2);
0813     if (ret < 0) {
0814         dev_err(dev, "failed to initialize hardware\n");
0815         goto out_stop_rx;
0816     }
0817 
0818     ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
0819     if (ret != 0) {
0820         dev_err(dev, "failed to add mfd devices to core\n");
0821         goto out_stop_rx;
0822     }
0823 
0824     return 0;
0825 
0826 out_stop_rx:
0827     dln2_stop_rx_urbs(dln2);
0828 
0829 out_free:
0830     dln2_free(dln2);
0831 
0832     return ret;
0833 }
0834 
0835 static int dln2_suspend(struct usb_interface *iface, pm_message_t message)
0836 {
0837     struct dln2_dev *dln2 = usb_get_intfdata(iface);
0838 
0839     dln2_stop(dln2);
0840 
0841     return 0;
0842 }
0843 
0844 static int dln2_resume(struct usb_interface *iface)
0845 {
0846     struct dln2_dev *dln2 = usb_get_intfdata(iface);
0847 
0848     dln2->disconnect = false;
0849 
0850     return dln2_start_rx_urbs(dln2, GFP_NOIO);
0851 }
0852 
0853 static const struct usb_device_id dln2_table[] = {
0854     { USB_DEVICE(0xa257, 0x2013) },
0855     { }
0856 };
0857 
0858 MODULE_DEVICE_TABLE(usb, dln2_table);
0859 
0860 static struct usb_driver dln2_driver = {
0861     .name = "dln2",
0862     .probe = dln2_probe,
0863     .disconnect = dln2_disconnect,
0864     .id_table = dln2_table,
0865     .suspend = dln2_suspend,
0866     .resume = dln2_resume,
0867 };
0868 
0869 module_usb_driver(dln2_driver);
0870 
0871 MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
0872 MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
0873 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!