GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / mfd / dln2.c
1 /*
2  * Driver for the Diolan DLN-2 USB adapter
3  *
4  * Copyright (c) 2014 Intel Corporation
5  *
6  * Derived from:
7  *  i2c-diolan-u2c.c
8  *  Copyright (c) 2010-2011 Ericsson AB
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation, version 2.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/slab.h>
19 #include <linux/usb.h>
20 #include <linux/i2c.h>
21 #include <linux/mutex.h>
22 #include <linux/platform_device.h>
23 #include <linux/mfd/core.h>
24 #include <linux/mfd/dln2.h>
25 #include <linux/rculist.h>
26
27 struct dln2_header {
28         __le16 size;
29         __le16 id;
30         __le16 echo;
31         __le16 handle;
32 };
33
34 struct dln2_response {
35         struct dln2_header hdr;
36         __le16 result;
37 };
38
39 #define DLN2_GENERIC_MODULE_ID          0x00
40 #define DLN2_GENERIC_CMD(cmd)           DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID)
41 #define CMD_GET_DEVICE_VER              DLN2_GENERIC_CMD(0x30)
42 #define CMD_GET_DEVICE_SN               DLN2_GENERIC_CMD(0x31)
43
44 #define DLN2_HW_ID                      0x200
45 #define DLN2_USB_TIMEOUT                200     /* in ms */
46 #define DLN2_MAX_RX_SLOTS               16
47 #define DLN2_MAX_URBS                   16
48 #define DLN2_RX_BUF_SIZE                512
49
50 enum dln2_handle {
51         DLN2_HANDLE_EVENT = 0,          /* don't change, hardware defined */
52         DLN2_HANDLE_CTRL,
53         DLN2_HANDLE_GPIO,
54         DLN2_HANDLE_I2C,
55         DLN2_HANDLE_SPI,
56         DLN2_HANDLES
57 };
58
59 /*
60  * Receive context used between the receive demultiplexer and the transfer
61  * routine. While sending a request the transfer routine will look for a free
62  * receive context and use it to wait for a response and to receive the URB and
63  * thus the response data.
64  */
65 struct dln2_rx_context {
66         /* completion used to wait for a response */
67         struct completion done;
68
69         /* if non-NULL the URB contains the response */
70         struct urb *urb;
71
72         /* if true then this context is used to wait for a response */
73         bool in_use;
74 };
75
76 /*
77  * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the
78  * handle header field to identify the module in dln2_dev.mod_rx_slots and then
79  * the echo header field to index the slots field and find the receive context
80  * for a particular request.
81  */
82 struct dln2_mod_rx_slots {
83         /* RX slots bitmap */
84         DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS);
85
86         /* used to wait for a free RX slot */
87         wait_queue_head_t wq;
88
89         /* used to wait for an RX operation to complete */
90         struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS];
91
92         /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */
93         spinlock_t lock;
94 };
95
96 enum dln2_endpoint {
97         DLN2_EP_OUT     = 0,
98         DLN2_EP_IN      = 1,
99 };
100
101 struct dln2_dev {
102         struct usb_device *usb_dev;
103         struct usb_interface *interface;
104         u8 ep_in;
105         u8 ep_out;
106
107         struct urb *rx_urb[DLN2_MAX_URBS];
108         void *rx_buf[DLN2_MAX_URBS];
109
110         struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES];
111
112         struct list_head event_cb_list;
113         spinlock_t event_cb_lock;
114
115         bool disconnect;
116         int active_transfers;
117         wait_queue_head_t disconnect_wq;
118         spinlock_t disconnect_lock;
119 };
120
121 struct dln2_event_cb_entry {
122         struct list_head list;
123         u16 id;
124         struct platform_device *pdev;
125         dln2_event_cb_t callback;
126 };
127
128 int dln2_register_event_cb(struct platform_device *pdev, u16 id,
129                            dln2_event_cb_t event_cb)
130 {
131         struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
132         struct dln2_event_cb_entry *i, *entry;
133         unsigned long flags;
134         int ret = 0;
135
136         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
137         if (!entry)
138                 return -ENOMEM;
139
140         entry->id = id;
141         entry->callback = event_cb;
142         entry->pdev = pdev;
143
144         spin_lock_irqsave(&dln2->event_cb_lock, flags);
145
146         list_for_each_entry(i, &dln2->event_cb_list, list) {
147                 if (i->id == id) {
148                         ret = -EBUSY;
149                         break;
150                 }
151         }
152
153         if (!ret)
154                 list_add_rcu(&entry->list, &dln2->event_cb_list);
155
156         spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
157
158         if (ret)
159                 kfree(entry);
160
161         return ret;
162 }
163 EXPORT_SYMBOL(dln2_register_event_cb);
164
165 void dln2_unregister_event_cb(struct platform_device *pdev, u16 id)
166 {
167         struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
168         struct dln2_event_cb_entry *i;
169         unsigned long flags;
170         bool found = false;
171
172         spin_lock_irqsave(&dln2->event_cb_lock, flags);
173
174         list_for_each_entry(i, &dln2->event_cb_list, list) {
175                 if (i->id == id) {
176                         list_del_rcu(&i->list);
177                         found = true;
178                         break;
179                 }
180         }
181
182         spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
183
184         if (found) {
185                 synchronize_rcu();
186                 kfree(i);
187         }
188 }
189 EXPORT_SYMBOL(dln2_unregister_event_cb);
190
191 /*
192  * Returns true if a valid transfer slot is found. In this case the URB must not
193  * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer
194  * is woke up. It will be resubmitted there.
195  */
196 static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb,
197                                    u16 handle, u16 rx_slot)
198 {
199         struct device *dev = &dln2->interface->dev;
200         struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
201         struct dln2_rx_context *rxc;
202         bool valid_slot = false;
203
204         if (rx_slot >= DLN2_MAX_RX_SLOTS)
205                 goto out;
206
207         rxc = &rxs->slots[rx_slot];
208
209         /*
210          * No need to disable interrupts as this lock is not taken in interrupt
211          * context elsewhere in this driver. This function (or its callers) are
212          * also not exported to other modules.
213          */
214         spin_lock(&rxs->lock);
215         if (rxc->in_use && !rxc->urb) {
216                 rxc->urb = urb;
217                 complete(&rxc->done);
218                 valid_slot = true;
219         }
220         spin_unlock(&rxs->lock);
221
222 out:
223         if (!valid_slot)
224                 dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot);
225
226         return valid_slot;
227 }
228
229 static void dln2_run_event_callbacks(struct dln2_dev *dln2, u16 id, u16 echo,
230                                      void *data, int len)
231 {
232         struct dln2_event_cb_entry *i;
233
234         rcu_read_lock();
235
236         list_for_each_entry_rcu(i, &dln2->event_cb_list, list) {
237                 if (i->id == id) {
238                         i->callback(i->pdev, echo, data, len);
239                         break;
240                 }
241         }
242
243         rcu_read_unlock();
244 }
245
246 static void dln2_rx(struct urb *urb)
247 {
248         struct dln2_dev *dln2 = urb->context;
249         struct dln2_header *hdr = urb->transfer_buffer;
250         struct device *dev = &dln2->interface->dev;
251         u16 id, echo, handle, size;
252         u8 *data;
253         int len;
254         int err;
255
256         switch (urb->status) {
257         case 0:
258                 /* success */
259                 break;
260         case -ECONNRESET:
261         case -ENOENT:
262         case -ESHUTDOWN:
263         case -EPIPE:
264                 /* this urb is terminated, clean up */
265                 dev_dbg(dev, "urb shutting down with status %d\n", urb->status);
266                 return;
267         default:
268                 dev_dbg(dev, "nonzero urb status received %d\n", urb->status);
269                 goto out;
270         }
271
272         if (urb->actual_length < sizeof(struct dln2_header)) {
273                 dev_err(dev, "short response: %d\n", urb->actual_length);
274                 goto out;
275         }
276
277         handle = le16_to_cpu(hdr->handle);
278         id = le16_to_cpu(hdr->id);
279         echo = le16_to_cpu(hdr->echo);
280         size = le16_to_cpu(hdr->size);
281
282         if (size != urb->actual_length) {
283                 dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n",
284                         handle, id, echo, size, urb->actual_length);
285                 goto out;
286         }
287
288         if (handle >= DLN2_HANDLES) {
289                 dev_warn(dev, "invalid handle %d\n", handle);
290                 goto out;
291         }
292
293         data = urb->transfer_buffer + sizeof(struct dln2_header);
294         len = urb->actual_length - sizeof(struct dln2_header);
295
296         if (handle == DLN2_HANDLE_EVENT) {
297                 unsigned long flags;
298
299                 spin_lock_irqsave(&dln2->event_cb_lock, flags);
300                 dln2_run_event_callbacks(dln2, id, echo, data, len);
301                 spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
302         } else {
303                 /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
304                 if (dln2_transfer_complete(dln2, urb, handle, echo))
305                         return;
306         }
307
308 out:
309         err = usb_submit_urb(urb, GFP_ATOMIC);
310         if (err < 0)
311                 dev_err(dev, "failed to resubmit RX URB: %d\n", err);
312 }
313
314 static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
315                            int *obuf_len, gfp_t gfp)
316 {
317         int len;
318         void *buf;
319         struct dln2_header *hdr;
320
321         len = *obuf_len + sizeof(*hdr);
322         buf = kmalloc(len, gfp);
323         if (!buf)
324                 return NULL;
325
326         hdr = (struct dln2_header *)buf;
327         hdr->id = cpu_to_le16(cmd);
328         hdr->size = cpu_to_le16(len);
329         hdr->echo = cpu_to_le16(echo);
330         hdr->handle = cpu_to_le16(handle);
331
332         memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
333
334         *obuf_len = len;
335
336         return buf;
337 }
338
339 static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
340                           const void *obuf, int obuf_len)
341 {
342         int ret = 0;
343         int len = obuf_len;
344         void *buf;
345         int actual;
346
347         buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
348         if (!buf)
349                 return -ENOMEM;
350
351         ret = usb_bulk_msg(dln2->usb_dev,
352                            usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
353                            buf, len, &actual, DLN2_USB_TIMEOUT);
354
355         kfree(buf);
356
357         return ret;
358 }
359
360 static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
361 {
362         struct dln2_mod_rx_slots *rxs;
363         unsigned long flags;
364
365         if (dln2->disconnect) {
366                 *slot = -ENODEV;
367                 return true;
368         }
369
370         rxs = &dln2->mod_rx_slots[handle];
371
372         spin_lock_irqsave(&rxs->lock, flags);
373
374         *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
375
376         if (*slot < DLN2_MAX_RX_SLOTS) {
377                 struct dln2_rx_context *rxc = &rxs->slots[*slot];
378
379                 set_bit(*slot, rxs->bmap);
380                 rxc->in_use = true;
381         }
382
383         spin_unlock_irqrestore(&rxs->lock, flags);
384
385         return *slot < DLN2_MAX_RX_SLOTS;
386 }
387
388 static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
389 {
390         int ret;
391         int slot;
392
393         /*
394          * No need to timeout here, the wait is bounded by the timeout in
395          * _dln2_transfer.
396          */
397         ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
398                                        find_free_slot(dln2, handle, &slot));
399         if (ret < 0)
400                 return ret;
401
402         return slot;
403 }
404
405 static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
406 {
407         struct dln2_mod_rx_slots *rxs;
408         struct urb *urb = NULL;
409         unsigned long flags;
410         struct dln2_rx_context *rxc;
411
412         rxs = &dln2->mod_rx_slots[handle];
413
414         spin_lock_irqsave(&rxs->lock, flags);
415
416         clear_bit(slot, rxs->bmap);
417
418         rxc = &rxs->slots[slot];
419         rxc->in_use = false;
420         urb = rxc->urb;
421         rxc->urb = NULL;
422         reinit_completion(&rxc->done);
423
424         spin_unlock_irqrestore(&rxs->lock, flags);
425
426         if (urb) {
427                 int err;
428                 struct device *dev = &dln2->interface->dev;
429
430                 err = usb_submit_urb(urb, GFP_KERNEL);
431                 if (err < 0)
432                         dev_err(dev, "failed to resubmit RX URB: %d\n", err);
433         }
434
435         wake_up_interruptible(&rxs->wq);
436 }
437
438 static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
439                           const void *obuf, unsigned obuf_len,
440                           void *ibuf, unsigned *ibuf_len)
441 {
442         int ret = 0;
443         int rx_slot;
444         struct dln2_response *rsp;
445         struct dln2_rx_context *rxc;
446         struct device *dev = &dln2->interface->dev;
447         const unsigned long timeout = msecs_to_jiffies(DLN2_USB_TIMEOUT);
448         struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
449         int size;
450
451         spin_lock(&dln2->disconnect_lock);
452         if (!dln2->disconnect)
453                 dln2->active_transfers++;
454         else
455                 ret = -ENODEV;
456         spin_unlock(&dln2->disconnect_lock);
457
458         if (ret)
459                 return ret;
460
461         rx_slot = alloc_rx_slot(dln2, handle);
462         if (rx_slot < 0) {
463                 ret = rx_slot;
464                 goto out_decr;
465         }
466
467         ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len);
468         if (ret < 0) {
469                 dev_err(dev, "USB write failed: %d\n", ret);
470                 goto out_free_rx_slot;
471         }
472
473         rxc = &rxs->slots[rx_slot];
474
475         ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout);
476         if (ret <= 0) {
477                 if (!ret)
478                         ret = -ETIMEDOUT;
479                 goto out_free_rx_slot;
480         } else {
481                 ret = 0;
482         }
483
484         if (dln2->disconnect) {
485                 ret = -ENODEV;
486                 goto out_free_rx_slot;
487         }
488
489         /* if we got here we know that the response header has been checked */
490         rsp = rxc->urb->transfer_buffer;
491         size = le16_to_cpu(rsp->hdr.size);
492
493         if (size < sizeof(*rsp)) {
494                 ret = -EPROTO;
495                 goto out_free_rx_slot;
496         }
497
498         if (le16_to_cpu(rsp->result) > 0x80) {
499                 dev_dbg(dev, "%d received response with error %d\n",
500                         handle, le16_to_cpu(rsp->result));
501                 ret = -EREMOTEIO;
502                 goto out_free_rx_slot;
503         }
504
505         if (!ibuf)
506                 goto out_free_rx_slot;
507
508         if (*ibuf_len > size - sizeof(*rsp))
509                 *ibuf_len = size - sizeof(*rsp);
510
511         memcpy(ibuf, rsp + 1, *ibuf_len);
512
513 out_free_rx_slot:
514         free_rx_slot(dln2, handle, rx_slot);
515 out_decr:
516         spin_lock(&dln2->disconnect_lock);
517         dln2->active_transfers--;
518         spin_unlock(&dln2->disconnect_lock);
519         if (dln2->disconnect)
520                 wake_up(&dln2->disconnect_wq);
521
522         return ret;
523 }
524
525 int dln2_transfer(struct platform_device *pdev, u16 cmd,
526                   const void *obuf, unsigned obuf_len,
527                   void *ibuf, unsigned *ibuf_len)
528 {
529         struct dln2_platform_data *dln2_pdata;
530         struct dln2_dev *dln2;
531         u16 handle;
532
533         dln2 = dev_get_drvdata(pdev->dev.parent);
534         dln2_pdata = dev_get_platdata(&pdev->dev);
535         handle = dln2_pdata->handle;
536
537         return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
538                               ibuf_len);
539 }
540 EXPORT_SYMBOL(dln2_transfer);
541
542 static int dln2_check_hw(struct dln2_dev *dln2)
543 {
544         int ret;
545         __le32 hw_type;
546         int len = sizeof(hw_type);
547
548         ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
549                              NULL, 0, &hw_type, &len);
550         if (ret < 0)
551                 return ret;
552         if (len < sizeof(hw_type))
553                 return -EREMOTEIO;
554
555         if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
556                 dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
557                         le32_to_cpu(hw_type));
558                 return -ENODEV;
559         }
560
561         return 0;
562 }
563
564 static int dln2_print_serialno(struct dln2_dev *dln2)
565 {
566         int ret;
567         __le32 serial_no;
568         int len = sizeof(serial_no);
569         struct device *dev = &dln2->interface->dev;
570
571         ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
572                              &serial_no, &len);
573         if (ret < 0)
574                 return ret;
575         if (len < sizeof(serial_no))
576                 return -EREMOTEIO;
577
578         dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
579
580         return 0;
581 }
582
583 static int dln2_hw_init(struct dln2_dev *dln2)
584 {
585         int ret;
586
587         ret = dln2_check_hw(dln2);
588         if (ret < 0)
589                 return ret;
590
591         return dln2_print_serialno(dln2);
592 }
593
594 static void dln2_free_rx_urbs(struct dln2_dev *dln2)
595 {
596         int i;
597
598         for (i = 0; i < DLN2_MAX_URBS; i++) {
599                 usb_free_urb(dln2->rx_urb[i]);
600                 kfree(dln2->rx_buf[i]);
601         }
602 }
603
604 static void dln2_stop_rx_urbs(struct dln2_dev *dln2)
605 {
606         int i;
607
608         for (i = 0; i < DLN2_MAX_URBS; i++)
609                 usb_kill_urb(dln2->rx_urb[i]);
610 }
611
612 static void dln2_free(struct dln2_dev *dln2)
613 {
614         dln2_free_rx_urbs(dln2);
615         usb_put_dev(dln2->usb_dev);
616         kfree(dln2);
617 }
618
619 static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
620                               struct usb_host_interface *hostif)
621 {
622         int i;
623         const int rx_max_size = DLN2_RX_BUF_SIZE;
624
625         for (i = 0; i < DLN2_MAX_URBS; i++) {
626                 dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
627                 if (!dln2->rx_buf[i])
628                         return -ENOMEM;
629
630                 dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
631                 if (!dln2->rx_urb[i])
632                         return -ENOMEM;
633
634                 usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
635                                   usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
636                                   dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
637         }
638
639         return 0;
640 }
641
642 static int dln2_start_rx_urbs(struct dln2_dev *dln2, gfp_t gfp)
643 {
644         struct device *dev = &dln2->interface->dev;
645         int ret;
646         int i;
647
648         for (i = 0; i < DLN2_MAX_URBS; i++) {
649                 ret = usb_submit_urb(dln2->rx_urb[i], gfp);
650                 if (ret < 0) {
651                         dev_err(dev, "failed to submit RX URB: %d\n", ret);
652                         return ret;
653                 }
654         }
655
656         return 0;
657 }
658
659 static struct dln2_platform_data dln2_pdata_gpio = {
660         .handle = DLN2_HANDLE_GPIO,
661 };
662
663 /* Only one I2C port seems to be supported on current hardware */
664 static struct dln2_platform_data dln2_pdata_i2c = {
665         .handle = DLN2_HANDLE_I2C,
666         .port = 0,
667 };
668
669 /* Only one SPI port supported */
670 static struct dln2_platform_data dln2_pdata_spi = {
671         .handle = DLN2_HANDLE_SPI,
672         .port = 0,
673 };
674
675 static const struct mfd_cell dln2_devs[] = {
676         {
677                 .name = "dln2-gpio",
678                 .platform_data = &dln2_pdata_gpio,
679                 .pdata_size = sizeof(struct dln2_platform_data),
680         },
681         {
682                 .name = "dln2-i2c",
683                 .platform_data = &dln2_pdata_i2c,
684                 .pdata_size = sizeof(struct dln2_platform_data),
685         },
686         {
687                 .name = "dln2-spi",
688                 .platform_data = &dln2_pdata_spi,
689                 .pdata_size = sizeof(struct dln2_platform_data),
690         },
691 };
692
693 static void dln2_stop(struct dln2_dev *dln2)
694 {
695         int i, j;
696
697         /* don't allow starting new transfers */
698         spin_lock(&dln2->disconnect_lock);
699         dln2->disconnect = true;
700         spin_unlock(&dln2->disconnect_lock);
701
702         /* cancel in progress transfers */
703         for (i = 0; i < DLN2_HANDLES; i++) {
704                 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
705                 unsigned long flags;
706
707                 spin_lock_irqsave(&rxs->lock, flags);
708
709                 /* cancel all response waiters */
710                 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
711                         struct dln2_rx_context *rxc = &rxs->slots[j];
712
713                         if (rxc->in_use)
714                                 complete(&rxc->done);
715                 }
716
717                 spin_unlock_irqrestore(&rxs->lock, flags);
718         }
719
720         /* wait for transfers to end */
721         wait_event(dln2->disconnect_wq, !dln2->active_transfers);
722
723         dln2_stop_rx_urbs(dln2);
724 }
725
726 static void dln2_disconnect(struct usb_interface *interface)
727 {
728         struct dln2_dev *dln2 = usb_get_intfdata(interface);
729
730         dln2_stop(dln2);
731
732         mfd_remove_devices(&interface->dev);
733
734         dln2_free(dln2);
735 }
736
737 static int dln2_probe(struct usb_interface *interface,
738                       const struct usb_device_id *usb_id)
739 {
740         struct usb_host_interface *hostif = interface->cur_altsetting;
741         struct usb_endpoint_descriptor *epin;
742         struct usb_endpoint_descriptor *epout;
743         struct device *dev = &interface->dev;
744         struct dln2_dev *dln2;
745         int ret;
746         int i, j;
747
748         if (hostif->desc.bInterfaceNumber != 0 ||
749             hostif->desc.bNumEndpoints < 2)
750                 return -ENODEV;
751
752         epout = &hostif->endpoint[DLN2_EP_OUT].desc;
753         if (!usb_endpoint_is_bulk_out(epout))
754                 return -ENODEV;
755         epin = &hostif->endpoint[DLN2_EP_IN].desc;
756         if (!usb_endpoint_is_bulk_in(epin))
757                 return -ENODEV;
758
759         dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
760         if (!dln2)
761                 return -ENOMEM;
762
763         dln2->ep_out = epout->bEndpointAddress;
764         dln2->ep_in = epin->bEndpointAddress;
765         dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
766         dln2->interface = interface;
767         usb_set_intfdata(interface, dln2);
768         init_waitqueue_head(&dln2->disconnect_wq);
769
770         for (i = 0; i < DLN2_HANDLES; i++) {
771                 init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
772                 spin_lock_init(&dln2->mod_rx_slots[i].lock);
773                 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
774                         init_completion(&dln2->mod_rx_slots[i].slots[j].done);
775         }
776
777         spin_lock_init(&dln2->event_cb_lock);
778         spin_lock_init(&dln2->disconnect_lock);
779         INIT_LIST_HEAD(&dln2->event_cb_list);
780
781         ret = dln2_setup_rx_urbs(dln2, hostif);
782         if (ret)
783                 goto out_free;
784
785         ret = dln2_start_rx_urbs(dln2, GFP_KERNEL);
786         if (ret)
787                 goto out_stop_rx;
788
789         ret = dln2_hw_init(dln2);
790         if (ret < 0) {
791                 dev_err(dev, "failed to initialize hardware\n");
792                 goto out_stop_rx;
793         }
794
795         ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
796         if (ret != 0) {
797                 dev_err(dev, "failed to add mfd devices to core\n");
798                 goto out_stop_rx;
799         }
800
801         return 0;
802
803 out_stop_rx:
804         dln2_stop_rx_urbs(dln2);
805
806 out_free:
807         dln2_free(dln2);
808
809         return ret;
810 }
811
812 static int dln2_suspend(struct usb_interface *iface, pm_message_t message)
813 {
814         struct dln2_dev *dln2 = usb_get_intfdata(iface);
815
816         dln2_stop(dln2);
817
818         return 0;
819 }
820
821 static int dln2_resume(struct usb_interface *iface)
822 {
823         struct dln2_dev *dln2 = usb_get_intfdata(iface);
824
825         dln2->disconnect = false;
826
827         return dln2_start_rx_urbs(dln2, GFP_NOIO);
828 }
829
830 static const struct usb_device_id dln2_table[] = {
831         { USB_DEVICE(0xa257, 0x2013) },
832         { }
833 };
834
835 MODULE_DEVICE_TABLE(usb, dln2_table);
836
837 static struct usb_driver dln2_driver = {
838         .name = "dln2",
839         .probe = dln2_probe,
840         .disconnect = dln2_disconnect,
841         .id_table = dln2_table,
842         .suspend = dln2_suspend,
843         .resume = dln2_resume,
844 };
845
846 module_usb_driver(dln2_driver);
847
848 MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
849 MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
850 MODULE_LICENSE("GPL v2");