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_HANDLES
  56 };
  57
  58 /*
  59  * Receive context used between the receive demultiplexer and the transfer
  60  * routine. While sending a request the transfer routine will look for a free
  61  * receive context and use it to wait for a response and to receive the URB and
  62  * thus the response data.
  63  */
  64 struct dln2_rx_context {
  65         /* completion used to wait for a response */
  66         struct completion done;
  67
  68         /* if non-NULL the URB contains the response */
  69         struct urb *urb;
  70
  71         /* if true then this context is used to wait for a response */
  72         bool in_use;
  73 };
  74
  75 /*
  76  * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the
  77  * handle header field to identify the module in dln2_dev.mod_rx_slots and then
  78  * the echo header field to index the slots field and find the receive context
  79  * for a particular request.
  80  */
  81 struct dln2_mod_rx_slots {
  82         /* RX slots bitmap */
  83         DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS);
  84
  85         /* used to wait for a free RX slot */
  86         wait_queue_head_t wq;
  87
  88         /* used to wait for an RX operation to complete */
  89         struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS];
  90
  91         /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */
  92         spinlock_t lock;
  93 };
  94
  95 struct dln2_dev {
  96         struct usb_device *usb_dev;
  97         struct usb_interface *interface;
  98         u8 ep_in;
  99         u8 ep_out;
 100
 101         struct urb *rx_urb[DLN2_MAX_URBS];
 102         void *rx_buf[DLN2_MAX_URBS];
 103
 104         struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES];
 105
 106         struct list_head event_cb_list;
 107         spinlock_t event_cb_lock;
 108
 109         bool disconnect;
 110         int active_transfers;
 111         wait_queue_head_t disconnect_wq;
 112         spinlock_t disconnect_lock;
 113 };
 114
 115 struct dln2_event_cb_entry {
 116         struct list_head list;
 117         u16 id;
 118         struct platform_device *pdev;
 119         dln2_event_cb_t callback;
 120 };
 121
 122 int dln2_register_event_cb(struct platform_device *pdev, u16 id,
 123                            dln2_event_cb_t event_cb)
 124 {
 125         struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
 126         struct dln2_event_cb_entry *i, *entry;
 127         unsigned long flags;
 128         int ret = 0;
 129
 130         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 131         if (!entry)
 132                 return -ENOMEM;
 133
 134         entry->id = id;
 135         entry->callback = event_cb;
 136         entry->pdev = pdev;
 137
 138         spin_lock_irqsave(&dln2->event_cb_lock, flags);
 139
 140         list_for_each_entry(i, &dln2->event_cb_list, list) {
 141                 if (i->id == id) {
 142                         ret = -EBUSY;
 143                         break;
 144                 }
 145         }
 146
 147         if (!ret)
 148                 list_add_rcu(&entry->list, &dln2->event_cb_list);
 149
 150         spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
 151
 152         if (ret)
 153                 kfree(entry);
 154
 155         return ret;
 156 }
 157 EXPORT_SYMBOL(dln2_register_event_cb);
 158
 159 void dln2_unregister_event_cb(struct platform_device *pdev, u16 id)
 160 {
 161         struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
 162         struct dln2_event_cb_entry *i;
 163         unsigned long flags;
 164         bool found = false;
 165
 166         spin_lock_irqsave(&dln2->event_cb_lock, flags);
 167
 168         list_for_each_entry(i, &dln2->event_cb_list, list) {
 169                 if (i->id == id) {
 170                         list_del_rcu(&i->list);
 171                         found = true;
 172                         break;
 173                 }
 174         }
 175
 176         spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
 177
 178         if (found) {
 179                 synchronize_rcu();
 180                 kfree(i);
 181         }
 182 }
 183 EXPORT_SYMBOL(dln2_unregister_event_cb);
 184
 185 /*
 186  * Returns true if a valid transfer slot is found. In this case the URB must not
 187  * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer
 188  * is woke up. It will be resubmitted there.
 189  */
 190 static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb,
 191                                    u16 handle, u16 rx_slot)
 192 {
 193         struct device *dev = &dln2->interface->dev;
 194         struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
 195         struct dln2_rx_context *rxc;
 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         /*
 204          * No need to disable interrupts as this lock is not taken in interrupt
 205          * context elsewhere in this driver. This function (or its callers) are
 206          * also not exported to other modules.
 207          */
 208         spin_lock(&rxs->lock);
 209         if (rxc->in_use && !rxc->urb) {
 210                 rxc->urb = urb;
 211                 complete(&rxc->done);
 212                 valid_slot = true;
 213         }
 214         spin_unlock(&rxs->lock);
 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                 dln2_run_event_callbacks(dln2, id, echo, data, len);
 292         } else {
 293                 /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
 294                 if (dln2_transfer_complete(dln2, urb, handle, echo))
 295                         return;
 296         }
 297
 298 out:
 299         err = usb_submit_urb(urb, GFP_ATOMIC);
 300         if (err < 0)
 301                 dev_err(dev, "failed to resubmit RX URB: %d\n", err);
 302 }
 303
 304 static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
 305                            int *obuf_len, gfp_t gfp)
 306 {
 307         int len;
 308         void *buf;
 309         struct dln2_header *hdr;
 310
 311         len = *obuf_len + sizeof(*hdr);
 312         buf = kmalloc(len, gfp);
 313         if (!buf)
 314                 return NULL;
 315
 316         hdr = (struct dln2_header *)buf;
 317         hdr->id = cpu_to_le16(cmd);
 318         hdr->size = cpu_to_le16(len);
 319         hdr->echo = cpu_to_le16(echo);
 320         hdr->handle = cpu_to_le16(handle);
 321
 322         memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
 323
 324         *obuf_len = len;
 325
 326         return buf;
 327 }
 328
 329 static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
 330                           const void *obuf, int obuf_len)
 331 {
 332         int ret = 0;
 333         int len = obuf_len;
 334         void *buf;
 335         int actual;
 336
 337         buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
 338         if (!buf)
 339                 return -ENOMEM;
 340
 341         ret = usb_bulk_msg(dln2->usb_dev,
 342                            usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
 343                            buf, len, &actual, DLN2_USB_TIMEOUT);
 344
 345         kfree(buf);
 346
 347         return ret;
 348 }
 349
 350 static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
 351 {
 352         struct dln2_mod_rx_slots *rxs;
 353         unsigned long flags;
 354
 355         if (dln2->disconnect) {
 356                 *slot = -ENODEV;
 357                 return true;
 358         }
 359
 360         rxs = &dln2->mod_rx_slots[handle];
 361
 362         spin_lock_irqsave(&rxs->lock, flags);
 363
 364         *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
 365
 366         if (*slot < DLN2_MAX_RX_SLOTS) {
 367                 struct dln2_rx_context *rxc = &rxs->slots[*slot];
 368
 369                 set_bit(*slot, rxs->bmap);
 370                 rxc->in_use = true;
 371         }
 372
 373         spin_unlock_irqrestore(&rxs->lock, flags);
 374
 375         return *slot < DLN2_MAX_RX_SLOTS;
 376 }
 377
 378 static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
 379 {
 380         int ret;
 381         int slot;
 382
 383         /*
 384          * No need to timeout here, the wait is bounded by the timeout in
 385          * _dln2_transfer.
 386          */
 387         ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
 388                                        find_free_slot(dln2, handle, &slot));
 389         if (ret < 0)
 390                 return ret;
 391
 392         return slot;
 393 }
 394
 395 static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
 396 {
 397         struct dln2_mod_rx_slots *rxs;
 398         struct urb *urb = NULL;
 399         unsigned long flags;
 400         struct dln2_rx_context *rxc;
 401
 402         rxs = &dln2->mod_rx_slots[handle];
 403
 404         spin_lock_irqsave(&rxs->lock, flags);
 405
 406         clear_bit(slot, rxs->bmap);
 407
 408         rxc = &rxs->slots[slot];
 409         rxc->in_use = false;
 410         urb = rxc->urb;
 411         rxc->urb = NULL;
 412         reinit_completion(&rxc->done);
 413
 414         spin_unlock_irqrestore(&rxs->lock, flags);
 415
 416         if (urb) {
 417                 int err;
 418                 struct device *dev = &dln2->interface->dev;
 419
 420                 err = usb_submit_urb(urb, GFP_KERNEL);
 421                 if (err < 0)
 422                         dev_err(dev, "failed to resubmit RX URB: %d\n", err);
 423         }
 424
 425         wake_up_interruptible(&rxs->wq);
 426 }
 427
 428 static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
 429                           const void *obuf, unsigned obuf_len,
 430                           void *ibuf, unsigned *ibuf_len)
 431 {
 432         int ret = 0;
 433         int rx_slot;
 434         struct dln2_response *rsp;
 435         struct dln2_rx_context *rxc;
 436         struct device *dev = &dln2->interface->dev;
 437         const unsigned long timeout = DLN2_USB_TIMEOUT * HZ / 1000;
 438         struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
 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
 481         if (rsp->hdr.size < sizeof(*rsp)) {
 482                 ret = -EPROTO;
 483                 goto out_free_rx_slot;
 484         }
 485
 486         if (le16_to_cpu(rsp->result) > 0x80) {
 487                 dev_dbg(dev, "%d received response with error %d\n",
 488                         handle, le16_to_cpu(rsp->result));
 489                 ret = -EREMOTEIO;
 490                 goto out_free_rx_slot;
 491         }
 492
 493         if (!ibuf)
 494                 goto out_free_rx_slot;
 495
 496         if (*ibuf_len > rsp->hdr.size - sizeof(*rsp))
 497                 *ibuf_len = rsp->hdr.size - sizeof(*rsp);
 498
 499         memcpy(ibuf, rsp + 1, *ibuf_len);
 500
 501 out_free_rx_slot:
 502         free_rx_slot(dln2, handle, rx_slot);
 503 out_decr:
 504         spin_lock(&dln2->disconnect_lock);
 505         dln2->active_transfers--;
 506         spin_unlock(&dln2->disconnect_lock);
 507         if (dln2->disconnect)
 508                 wake_up(&dln2->disconnect_wq);
 509
 510         return ret;
 511 }
 512
 513 int dln2_transfer(struct platform_device *pdev, u16 cmd,
 514                   const void *obuf, unsigned obuf_len,
 515                   void *ibuf, unsigned *ibuf_len)
 516 {
 517         struct dln2_platform_data *dln2_pdata;
 518         struct dln2_dev *dln2;
 519         u16 handle;
 520
 521         dln2 = dev_get_drvdata(pdev->dev.parent);
 522         dln2_pdata = dev_get_platdata(&pdev->dev);
 523         handle = dln2_pdata->handle;
 524
 525         return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
 526                               ibuf_len);
 527 }
 528 EXPORT_SYMBOL(dln2_transfer);
 529
 530 static int dln2_check_hw(struct dln2_dev *dln2)
 531 {
 532         int ret;
 533         __le32 hw_type;
 534         int len = sizeof(hw_type);
 535
 536         ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
 537                              NULL, 0, &hw_type, &len);
 538         if (ret < 0)
 539                 return ret;
 540         if (len < sizeof(hw_type))
 541                 return -EREMOTEIO;
 542
 543         if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
 544                 dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
 545                         le32_to_cpu(hw_type));
 546                 return -ENODEV;
 547         }
 548
 549         return 0;
 550 }
 551
 552 static int dln2_print_serialno(struct dln2_dev *dln2)
 553 {
 554         int ret;
 555         __le32 serial_no;
 556         int len = sizeof(serial_no);
 557         struct device *dev = &dln2->interface->dev;
 558
 559         ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
 560                              &serial_no, &len);
 561         if (ret < 0)
 562                 return ret;
 563         if (len < sizeof(serial_no))
 564                 return -EREMOTEIO;
 565
 566         dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
 567
 568         return 0;
 569 }
 570
 571 static int dln2_hw_init(struct dln2_dev *dln2)
 572 {
 573         int ret;
 574
 575         ret = dln2_check_hw(dln2);
 576         if (ret < 0)
 577                 return ret;
 578
 579         return dln2_print_serialno(dln2);
 580 }
 581
 582 static void dln2_free_rx_urbs(struct dln2_dev *dln2)
 583 {
 584         int i;
 585
 586         for (i = 0; i < DLN2_MAX_URBS; i++) {
 587                 usb_kill_urb(dln2->rx_urb[i]);
 588                 usb_free_urb(dln2->rx_urb[i]);
 589                 kfree(dln2->rx_buf[i]);
 590         }
 591 }
 592
 593 static void dln2_free(struct dln2_dev *dln2)
 594 {
 595         dln2_free_rx_urbs(dln2);
 596         usb_put_dev(dln2->usb_dev);
 597         kfree(dln2);
 598 }
 599
 600 static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
 601                               struct usb_host_interface *hostif)
 602 {
 603         int i;
 604         int ret;
 605         const int rx_max_size = DLN2_RX_BUF_SIZE;
 606         struct device *dev = &dln2->interface->dev;
 607
 608         for (i = 0; i < DLN2_MAX_URBS; i++) {
 609                 dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
 610                 if (!dln2->rx_buf[i])
 611                         return -ENOMEM;
 612
 613                 dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
 614                 if (!dln2->rx_urb[i])
 615                         return -ENOMEM;
 616
 617                 usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
 618                                   usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
 619                                   dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
 620
 621                 ret = usb_submit_urb(dln2->rx_urb[i], GFP_KERNEL);
 622                 if (ret < 0) {
 623                         dev_err(dev, "failed to submit RX URB: %d\n", ret);
 624                         return ret;
 625                 }
 626         }
 627
 628         return 0;
 629 }
 630
 631 static struct dln2_platform_data dln2_pdata_gpio = {
 632         .handle = DLN2_HANDLE_GPIO,
 633 };
 634
 635 /* Only one I2C port seems to be supported on current hardware */
 636 static struct dln2_platform_data dln2_pdata_i2c = {
 637         .handle = DLN2_HANDLE_I2C,
 638         .port = 0,
 639 };
 640
 641 static const struct mfd_cell dln2_devs[] = {
 642         {
 643                 .name = "dln2-gpio",
 644                 .platform_data = &dln2_pdata_gpio,
 645                 .pdata_size = sizeof(struct dln2_platform_data),
 646         },
 647         {
 648                 .name = "dln2-i2c",
 649                 .platform_data = &dln2_pdata_i2c,
 650                 .pdata_size = sizeof(struct dln2_platform_data),
 651         },
 652 };
 653
 654 static void dln2_disconnect(struct usb_interface *interface)
 655 {
 656         struct dln2_dev *dln2 = usb_get_intfdata(interface);
 657         int i, j;
 658
 659         /* don't allow starting new transfers */
 660         spin_lock(&dln2->disconnect_lock);
 661         dln2->disconnect = true;
 662         spin_unlock(&dln2->disconnect_lock);
 663
 664         /* cancel in progress transfers */
 665         for (i = 0; i < DLN2_HANDLES; i++) {
 666                 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
 667                 unsigned long flags;
 668
 669                 spin_lock_irqsave(&rxs->lock, flags);
 670
 671                 /* cancel all response waiters */
 672                 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
 673                         struct dln2_rx_context *rxc = &rxs->slots[j];
 674
 675                         if (rxc->in_use)
 676                                 complete(&rxc->done);
 677                 }
 678
 679                 spin_unlock_irqrestore(&rxs->lock, flags);
 680         }
 681
 682         /* wait for transfers to end */
 683         wait_event(dln2->disconnect_wq, !dln2->active_transfers);
 684
 685         mfd_remove_devices(&interface->dev);
 686
 687         dln2_free(dln2);
 688 }
 689
 690 static int dln2_probe(struct usb_interface *interface,
 691                       const struct usb_device_id *usb_id)
 692 {
 693         struct usb_host_interface *hostif = interface->cur_altsetting;
 694         struct device *dev = &interface->dev;
 695         struct dln2_dev *dln2;
 696         int ret;
 697         int i, j;
 698
 699         if (hostif->desc.bInterfaceNumber != 0 ||
 700             hostif->desc.bNumEndpoints < 2)
 701                 return -ENODEV;
 702
 703         dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
 704         if (!dln2)
 705                 return -ENOMEM;
 706
 707         dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress;
 708         dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress;
 709         dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
 710         dln2->interface = interface;
 711         usb_set_intfdata(interface, dln2);
 712         init_waitqueue_head(&dln2->disconnect_wq);
 713
 714         for (i = 0; i < DLN2_HANDLES; i++) {
 715                 init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
 716                 spin_lock_init(&dln2->mod_rx_slots[i].lock);
 717                 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
 718                         init_completion(&dln2->mod_rx_slots[i].slots[j].done);
 719         }
 720
 721         spin_lock_init(&dln2->event_cb_lock);
 722         spin_lock_init(&dln2->disconnect_lock);
 723         INIT_LIST_HEAD(&dln2->event_cb_list);
 724
 725         ret = dln2_setup_rx_urbs(dln2, hostif);
 726         if (ret)
 727                 goto out_cleanup;
 728
 729         ret = dln2_hw_init(dln2);
 730         if (ret < 0) {
 731                 dev_err(dev, "failed to initialize hardware\n");
 732                 goto out_cleanup;
 733         }
 734
 735         ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
 736         if (ret != 0) {
 737                 dev_err(dev, "failed to add mfd devices to core\n");
 738                 goto out_cleanup;
 739         }
 740
 741         return 0;
 742
 743 out_cleanup:
 744         dln2_free(dln2);
 745
 746         return ret;
 747 }
 748
 749 static const struct usb_device_id dln2_table[] = {
 750         { USB_DEVICE(0xa257, 0x2013) },
 751         { }
 752 };
 753
 754 MODULE_DEVICE_TABLE(usb, dln2_table);
 755
 756 static struct usb_driver dln2_driver = {
 757         .name = "dln2",
 758         .probe = dln2_probe,
 759         .disconnect = dln2_disconnect,
 760         .id_table = dln2_table,
 761 };
 762
 763 module_usb_driver(dln2_driver);
 764
 765 MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
 766 MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
 767 MODULE_LICENSE("GPL v2");