dln2.c 19 KB

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