drivers/mfd/dln2.c

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