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