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