drivers/mfd/dln2.c

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