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