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
 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		dln2_run_event_callbacks(dln2, id, echo, data, len);
 
286	} else {
287		/* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
288		if (dln2_transfer_complete(dln2, urb, handle, echo))
289			return;
290	}
291
292out:
293	err = usb_submit_urb(urb, GFP_ATOMIC);
294	if (err < 0)
295		dev_err(dev, "failed to resubmit RX URB: %d\n", err);
296}
297
298static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
299			   int *obuf_len, gfp_t gfp)
300{
301	int len;
302	void *buf;
303	struct dln2_header *hdr;
304
305	len = *obuf_len + sizeof(*hdr);
306	buf = kmalloc(len, gfp);
307	if (!buf)
308		return NULL;
309
310	hdr = (struct dln2_header *)buf;
311	hdr->id = cpu_to_le16(cmd);
312	hdr->size = cpu_to_le16(len);
313	hdr->echo = cpu_to_le16(echo);
314	hdr->handle = cpu_to_le16(handle);
315
316	memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
317
318	*obuf_len = len;
319
320	return buf;
321}
322
323static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
324			  const void *obuf, int obuf_len)
325{
326	int ret = 0;
327	int len = obuf_len;
328	void *buf;
329	int actual;
330
331	buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
332	if (!buf)
333		return -ENOMEM;
334
335	ret = usb_bulk_msg(dln2->usb_dev,
336			   usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
337			   buf, len, &actual, DLN2_USB_TIMEOUT);
338
339	kfree(buf);
340
341	return ret;
342}
343
344static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
345{
346	struct dln2_mod_rx_slots *rxs;
347	unsigned long flags;
348
349	if (dln2->disconnect) {
350		*slot = -ENODEV;
351		return true;
352	}
353
354	rxs = &dln2->mod_rx_slots[handle];
355
356	spin_lock_irqsave(&rxs->lock, flags);
357
358	*slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
359
360	if (*slot < DLN2_MAX_RX_SLOTS) {
361		struct dln2_rx_context *rxc = &rxs->slots[*slot];
362
363		set_bit(*slot, rxs->bmap);
364		rxc->in_use = true;
365	}
366
367	spin_unlock_irqrestore(&rxs->lock, flags);
368
369	return *slot < DLN2_MAX_RX_SLOTS;
370}
371
372static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
373{
374	int ret;
375	int slot;
376
377	/*
378	 * No need to timeout here, the wait is bounded by the timeout in
379	 * _dln2_transfer.
380	 */
381	ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
382				       find_free_slot(dln2, handle, &slot));
383	if (ret < 0)
384		return ret;
385
386	return slot;
387}
388
389static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
390{
391	struct dln2_mod_rx_slots *rxs;
392	struct urb *urb = NULL;
393	unsigned long flags;
394	struct dln2_rx_context *rxc;
395
396	rxs = &dln2->mod_rx_slots[handle];
397
398	spin_lock_irqsave(&rxs->lock, flags);
399
400	clear_bit(slot, rxs->bmap);
401
402	rxc = &rxs->slots[slot];
403	rxc->in_use = false;
404	urb = rxc->urb;
405	rxc->urb = NULL;
406	reinit_completion(&rxc->done);
407
408	spin_unlock_irqrestore(&rxs->lock, flags);
409
410	if (urb) {
411		int err;
412		struct device *dev = &dln2->interface->dev;
413
414		err = usb_submit_urb(urb, GFP_KERNEL);
415		if (err < 0)
416			dev_err(dev, "failed to resubmit RX URB: %d\n", err);
417	}
418
419	wake_up_interruptible(&rxs->wq);
420}
421
422static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
423			  const void *obuf, unsigned obuf_len,
424			  void *ibuf, unsigned *ibuf_len)
425{
426	int ret = 0;
427	int rx_slot;
428	struct dln2_response *rsp;
429	struct dln2_rx_context *rxc;
430	struct device *dev = &dln2->interface->dev;
431	const unsigned long timeout = msecs_to_jiffies(DLN2_USB_TIMEOUT);
432	struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
433	int size;
434
435	spin_lock(&dln2->disconnect_lock);
436	if (!dln2->disconnect)
437		dln2->active_transfers++;
438	else
439		ret = -ENODEV;
440	spin_unlock(&dln2->disconnect_lock);
441
442	if (ret)
443		return ret;
444
445	rx_slot = alloc_rx_slot(dln2, handle);
446	if (rx_slot < 0) {
447		ret = rx_slot;
448		goto out_decr;
449	}
450
451	ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len);
452	if (ret < 0) {
453		dev_err(dev, "USB write failed: %d\n", ret);
454		goto out_free_rx_slot;
455	}
456
457	rxc = &rxs->slots[rx_slot];
458
459	ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout);
460	if (ret <= 0) {
461		if (!ret)
462			ret = -ETIMEDOUT;
463		goto out_free_rx_slot;
464	} else {
465		ret = 0;
466	}
467
468	if (dln2->disconnect) {
469		ret = -ENODEV;
470		goto out_free_rx_slot;
471	}
472
473	/* if we got here we know that the response header has been checked */
474	rsp = rxc->urb->transfer_buffer;
475	size = le16_to_cpu(rsp->hdr.size);
476
477	if (size < sizeof(*rsp)) {
478		ret = -EPROTO;
479		goto out_free_rx_slot;
480	}
481
482	if (le16_to_cpu(rsp->result) > 0x80) {
483		dev_dbg(dev, "%d received response with error %d\n",
484			handle, le16_to_cpu(rsp->result));
485		ret = -EREMOTEIO;
486		goto out_free_rx_slot;
487	}
488
489	if (!ibuf)
490		goto out_free_rx_slot;
491
492	if (*ibuf_len > size - sizeof(*rsp))
493		*ibuf_len = size - sizeof(*rsp);
494
495	memcpy(ibuf, rsp + 1, *ibuf_len);
496
497out_free_rx_slot:
498	free_rx_slot(dln2, handle, rx_slot);
499out_decr:
500	spin_lock(&dln2->disconnect_lock);
501	dln2->active_transfers--;
502	spin_unlock(&dln2->disconnect_lock);
503	if (dln2->disconnect)
504		wake_up(&dln2->disconnect_wq);
505
506	return ret;
507}
508
509int dln2_transfer(struct platform_device *pdev, u16 cmd,
510		  const void *obuf, unsigned obuf_len,
511		  void *ibuf, unsigned *ibuf_len)
512{
513	struct dln2_platform_data *dln2_pdata;
514	struct dln2_dev *dln2;
515	u16 handle;
516
517	dln2 = dev_get_drvdata(pdev->dev.parent);
518	dln2_pdata = dev_get_platdata(&pdev->dev);
519	handle = dln2_pdata->handle;
520
521	return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
522			      ibuf_len);
523}
524EXPORT_SYMBOL(dln2_transfer);
525
526static int dln2_check_hw(struct dln2_dev *dln2)
527{
528	int ret;
529	__le32 hw_type;
530	int len = sizeof(hw_type);
531
532	ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
533			     NULL, 0, &hw_type, &len);
534	if (ret < 0)
535		return ret;
536	if (len < sizeof(hw_type))
537		return -EREMOTEIO;
538
539	if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
540		dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
541			le32_to_cpu(hw_type));
542		return -ENODEV;
543	}
544
545	return 0;
546}
547
548static int dln2_print_serialno(struct dln2_dev *dln2)
549{
550	int ret;
551	__le32 serial_no;
552	int len = sizeof(serial_no);
553	struct device *dev = &dln2->interface->dev;
554
555	ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
556			     &serial_no, &len);
557	if (ret < 0)
558		return ret;
559	if (len < sizeof(serial_no))
560		return -EREMOTEIO;
561
562	dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
563
564	return 0;
565}
566
567static int dln2_hw_init(struct dln2_dev *dln2)
568{
569	int ret;
570
571	ret = dln2_check_hw(dln2);
572	if (ret < 0)
573		return ret;
574
575	return dln2_print_serialno(dln2);
576}
577
578static void dln2_free_rx_urbs(struct dln2_dev *dln2)
579{
580	int i;
581
582	for (i = 0; i < DLN2_MAX_URBS; i++) {
583		usb_free_urb(dln2->rx_urb[i]);
584		kfree(dln2->rx_buf[i]);
585	}
586}
587
588static void dln2_stop_rx_urbs(struct dln2_dev *dln2)
589{
590	int i;
591
592	for (i = 0; i < DLN2_MAX_URBS; i++)
593		usb_kill_urb(dln2->rx_urb[i]);
594}
595
596static void dln2_free(struct dln2_dev *dln2)
597{
598	dln2_free_rx_urbs(dln2);
599	usb_put_dev(dln2->usb_dev);
600	kfree(dln2);
601}
602
603static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
604			      struct usb_host_interface *hostif)
605{
606	int i;
607	const int rx_max_size = DLN2_RX_BUF_SIZE;
608
609	for (i = 0; i < DLN2_MAX_URBS; i++) {
610		dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
611		if (!dln2->rx_buf[i])
612			return -ENOMEM;
613
614		dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
615		if (!dln2->rx_urb[i])
616			return -ENOMEM;
617
618		usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
619				  usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
620				  dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
621	}
622
623	return 0;
624}
625
626static int dln2_start_rx_urbs(struct dln2_dev *dln2, gfp_t gfp)
627{
628	struct device *dev = &dln2->interface->dev;
629	int ret;
630	int i;
631
632	for (i = 0; i < DLN2_MAX_URBS; i++) {
633		ret = usb_submit_urb(dln2->rx_urb[i], gfp);
634		if (ret < 0) {
635			dev_err(dev, "failed to submit RX URB: %d\n", ret);
636			return ret;
637		}
638	}
639
640	return 0;
641}
642
 
 
 
 
 
 
 
643static struct dln2_platform_data dln2_pdata_gpio = {
644	.handle = DLN2_HANDLE_GPIO,
645};
646
 
 
 
 
647/* Only one I2C port seems to be supported on current hardware */
648static struct dln2_platform_data dln2_pdata_i2c = {
649	.handle = DLN2_HANDLE_I2C,
650	.port = 0,
651};
652
 
 
 
 
653/* Only one SPI port supported */
654static struct dln2_platform_data dln2_pdata_spi = {
655	.handle = DLN2_HANDLE_SPI,
656	.port = 0,
657};
658
 
 
 
 
 
 
 
 
 
 
 
 
 
 
659static const struct mfd_cell dln2_devs[] = {
660	{
661		.name = "dln2-gpio",
 
662		.platform_data = &dln2_pdata_gpio,
663		.pdata_size = sizeof(struct dln2_platform_data),
664	},
665	{
666		.name = "dln2-i2c",
 
667		.platform_data = &dln2_pdata_i2c,
668		.pdata_size = sizeof(struct dln2_platform_data),
669	},
670	{
671		.name = "dln2-spi",
 
672		.platform_data = &dln2_pdata_spi,
673		.pdata_size = sizeof(struct dln2_platform_data),
674	},
 
 
 
 
 
 
675};
676
677static void dln2_stop(struct dln2_dev *dln2)
678{
679	int i, j;
680
681	/* don't allow starting new transfers */
682	spin_lock(&dln2->disconnect_lock);
683	dln2->disconnect = true;
684	spin_unlock(&dln2->disconnect_lock);
685
686	/* cancel in progress transfers */
687	for (i = 0; i < DLN2_HANDLES; i++) {
688		struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
689		unsigned long flags;
690
691		spin_lock_irqsave(&rxs->lock, flags);
692
693		/* cancel all response waiters */
694		for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
695			struct dln2_rx_context *rxc = &rxs->slots[j];
696
697			if (rxc->in_use)
698				complete(&rxc->done);
699		}
700
701		spin_unlock_irqrestore(&rxs->lock, flags);
702	}
703
704	/* wait for transfers to end */
705	wait_event(dln2->disconnect_wq, !dln2->active_transfers);
706
707	dln2_stop_rx_urbs(dln2);
708}
709
710static void dln2_disconnect(struct usb_interface *interface)
711{
712	struct dln2_dev *dln2 = usb_get_intfdata(interface);
713
714	dln2_stop(dln2);
715
716	mfd_remove_devices(&interface->dev);
717
718	dln2_free(dln2);
719}
720
721static int dln2_probe(struct usb_interface *interface,
722		      const struct usb_device_id *usb_id)
723{
724	struct usb_host_interface *hostif = interface->cur_altsetting;
 
 
725	struct device *dev = &interface->dev;
726	struct dln2_dev *dln2;
727	int ret;
728	int i, j;
729
730	if (hostif->desc.bInterfaceNumber != 0 ||
731	    hostif->desc.bNumEndpoints < 2)
732		return -ENODEV;
733
 
 
 
 
734	dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
735	if (!dln2)
736		return -ENOMEM;
737
738	dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress;
739	dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress;
740	dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
741	dln2->interface = interface;
742	usb_set_intfdata(interface, dln2);
743	init_waitqueue_head(&dln2->disconnect_wq);
744
745	for (i = 0; i < DLN2_HANDLES; i++) {
746		init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
747		spin_lock_init(&dln2->mod_rx_slots[i].lock);
748		for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
749			init_completion(&dln2->mod_rx_slots[i].slots[j].done);
750	}
751
752	spin_lock_init(&dln2->event_cb_lock);
753	spin_lock_init(&dln2->disconnect_lock);
754	INIT_LIST_HEAD(&dln2->event_cb_list);
755
756	ret = dln2_setup_rx_urbs(dln2, hostif);
757	if (ret)
758		goto out_free;
759
760	ret = dln2_start_rx_urbs(dln2, GFP_KERNEL);
761	if (ret)
762		goto out_stop_rx;
763
764	ret = dln2_hw_init(dln2);
765	if (ret < 0) {
766		dev_err(dev, "failed to initialize hardware\n");
767		goto out_stop_rx;
768	}
769
770	ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
771	if (ret != 0) {
772		dev_err(dev, "failed to add mfd devices to core\n");
773		goto out_stop_rx;
774	}
775
776	return 0;
777
778out_stop_rx:
779	dln2_stop_rx_urbs(dln2);
780
781out_free:
782	dln2_free(dln2);
783
784	return ret;
785}
786
787static int dln2_suspend(struct usb_interface *iface, pm_message_t message)
788{
789	struct dln2_dev *dln2 = usb_get_intfdata(iface);
790
791	dln2_stop(dln2);
792
793	return 0;
794}
795
796static int dln2_resume(struct usb_interface *iface)
797{
798	struct dln2_dev *dln2 = usb_get_intfdata(iface);
799
800	dln2->disconnect = false;
801
802	return dln2_start_rx_urbs(dln2, GFP_NOIO);
803}
804
805static const struct usb_device_id dln2_table[] = {
806	{ USB_DEVICE(0xa257, 0x2013) },
807	{ }
808};
809
810MODULE_DEVICE_TABLE(usb, dln2_table);
811
812static struct usb_driver dln2_driver = {
813	.name = "dln2",
814	.probe = dln2_probe,
815	.disconnect = dln2_disconnect,
816	.id_table = dln2_table,
817	.suspend = dln2_suspend,
818	.resume = dln2_resume,
819};
820
821module_usb_driver(dln2_driver);
822
823MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
824MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
825MODULE_LICENSE("GPL v2");