drivers/usb/misc/usb-ljca.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Intel La Jolla Cove Adapter USB driver
   4  *
   5  * Copyright (c) 2023, Intel Corporation.
   6  */
   7
   8 #include <linux/acpi.h>
   9 #include <linux/auxiliary_bus.h>
  10 #include <linux/dev_printk.h>
  11 #include <linux/kernel.h>
  12 #include <linux/mod_devicetable.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/slab.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/types.h>
  18 #include <linux/usb.h>
  19 #include <linux/usb/ljca.h>
  20
  21 #include <linux/unaligned.h>
  22
  23 /* command flags */
  24 #define LJCA_ACK_FLAG                   BIT(0)
  25 #define LJCA_RESP_FLAG                  BIT(1)
  26 #define LJCA_CMPL_FLAG                  BIT(2)
  27
  28 #define LJCA_MAX_PACKET_SIZE            64u
  29 #define LJCA_MAX_PAYLOAD_SIZE           \
  30                 (LJCA_MAX_PACKET_SIZE - sizeof(struct ljca_msg))
  31
  32 #define LJCA_WRITE_TIMEOUT_MS           200
  33 #define LJCA_WRITE_ACK_TIMEOUT_MS       500
  34 #define LJCA_ENUM_CLIENT_TIMEOUT_MS     20
  35
  36 /* ljca client type */
  37 enum ljca_client_type {
  38         LJCA_CLIENT_MNG = 1,
  39         LJCA_CLIENT_GPIO = 3,
  40         LJCA_CLIENT_I2C = 4,
  41         LJCA_CLIENT_SPI = 5,
  42 };
  43
  44 /* MNG client commands */
  45 enum ljca_mng_cmd {
  46         LJCA_MNG_RESET = 2,
  47         LJCA_MNG_ENUM_GPIO = 4,
  48         LJCA_MNG_ENUM_I2C = 5,
  49         LJCA_MNG_ENUM_SPI = 8,
  50 };
  51
  52 /* ljca client acpi _ADR */
  53 enum ljca_client_acpi_adr {
  54         LJCA_GPIO_ACPI_ADR,
  55         LJCA_I2C1_ACPI_ADR,
  56         LJCA_I2C2_ACPI_ADR,
  57         LJCA_SPI1_ACPI_ADR,
  58         LJCA_SPI2_ACPI_ADR,
  59         LJCA_CLIENT_ACPI_ADR_MAX,
  60 };
  61
  62 /* ljca cmd message structure */
  63 struct ljca_msg {
  64         u8 type;
  65         u8 cmd;
  66         u8 flags;
  67         u8 len;
  68         u8 data[] __counted_by(len);
  69 } __packed;
  70
  71 struct ljca_i2c_ctr_info {
  72         u8 id;
  73         u8 capacity;
  74         u8 intr_pin;
  75 } __packed;
  76
  77 struct ljca_i2c_descriptor {
  78         u8 num;
  79         struct ljca_i2c_ctr_info info[] __counted_by(num);
  80 } __packed;
  81
  82 struct ljca_spi_ctr_info {
  83         u8 id;
  84         u8 capacity;
  85         u8 intr_pin;
  86 } __packed;
  87
  88 struct ljca_spi_descriptor {
  89         u8 num;
  90         struct ljca_spi_ctr_info info[] __counted_by(num);
  91 } __packed;
  92
  93 struct ljca_bank_descriptor {
  94         u8 bank_id;
  95         u8 pin_num;
  96
  97         /* 1 bit for each gpio, 1 means valid */
  98         __le32 valid_pins;
  99 } __packed;
 100
 101 struct ljca_gpio_descriptor {
 102         u8 pins_per_bank;
 103         u8 bank_num;
 104         struct ljca_bank_descriptor bank_desc[] __counted_by(bank_num);
 105 } __packed;
 106
 107 /**
 108  * struct ljca_adapter - represent a ljca adapter
 109  *
 110  * @intf: the usb interface for this ljca adapter
 111  * @usb_dev: the usb device for this ljca adapter
 112  * @dev: the specific device info of the usb interface
 113  * @rx_pipe: bulk in pipe for receive data from firmware
 114  * @tx_pipe: bulk out pipe for send data to firmware
 115  * @rx_urb: urb used for the bulk in pipe
 116  * @rx_buf: buffer used to receive command response and event
 117  * @rx_len: length of rx buffer
 118  * @ex_buf: external buffer to save command response
 119  * @ex_buf_len: length of external buffer
 120  * @actual_length: actual length of data copied to external buffer
 121  * @tx_buf: buffer used to download command to firmware
 122  * @tx_buf_len: length of tx buffer
 123  * @lock: spinlock to protect tx_buf and ex_buf
 124  * @cmd_completion: completion object as the command receives ack
 125  * @mutex: mutex to avoid command download concurrently
 126  * @client_list: client device list
 127  * @disconnect: usb disconnect ongoing or not
 128  * @reset_id: used to reset firmware
 129  */
 130 struct ljca_adapter {
 131         struct usb_interface *intf;
 132         struct usb_device *usb_dev;
 133         struct device *dev;
 134
 135         unsigned int rx_pipe;
 136         unsigned int tx_pipe;
 137
 138         struct urb *rx_urb;
 139         void *rx_buf;
 140         unsigned int rx_len;
 141
 142         u8 *ex_buf;
 143         u8 ex_buf_len;
 144         u8 actual_length;
 145
 146         void *tx_buf;
 147         u8 tx_buf_len;
 148
 149         spinlock_t lock;
 150
 151         struct completion cmd_completion;
 152         struct mutex mutex;
 153
 154         struct list_head client_list;
 155
 156         bool disconnect;
 157
 158         u32 reset_id;
 159 };
 160
 161 struct ljca_match_ids_walk_data {
 162         const struct acpi_device_id *ids;
 163         const char *uid;
 164         struct acpi_device *adev;
 165 };
 166
 167 static const struct acpi_device_id ljca_gpio_hids[] = {
 168         { "INTC1074" },
 169         { "INTC1096" },
 170         { "INTC100B" },
 171         { "INTC10D1" },
 172         { "INTC10B5" },
 173         {},
 174 };
 175
 176 static const struct acpi_device_id ljca_i2c_hids[] = {
 177         { "INTC1075" },
 178         { "INTC1097" },
 179         { "INTC100C" },
 180         { "INTC10D2" },
 181         {},
 182 };
 183
 184 static const struct acpi_device_id ljca_spi_hids[] = {
 185         { "INTC1091" },
 186         { "INTC1098" },
 187         { "INTC100D" },
 188         { "INTC10D3" },
 189         {},
 190 };
 191
 192 static void ljca_handle_event(struct ljca_adapter *adap,
 193                               struct ljca_msg *header)
 194 {
 195         struct ljca_client *client;
 196
 197         list_for_each_entry(client, &adap->client_list, link) {
 198                 /*
 199                  * Currently only GPIO register event callback, but
 200                  * firmware message structure should include id when
 201                  * multiple same type clients register event callback.
 202                  */
 203                 if (client->type == header->type) {
 204                         unsigned long flags;
 205
 206                         spin_lock_irqsave(&client->event_cb_lock, flags);
 207                         client->event_cb(client->context, header->cmd,
 208                                          header->data, header->len);
 209                         spin_unlock_irqrestore(&client->event_cb_lock, flags);
 210
 211                         break;
 212                 }
 213         }
 214 }
 215
 216 /* process command ack and received data if available */
 217 static void ljca_handle_cmd_ack(struct ljca_adapter *adap, struct ljca_msg *header)
 218 {
 219         struct ljca_msg *tx_header = adap->tx_buf;
 220         u8 ibuf_len, actual_len = 0;
 221         unsigned long flags;
 222         u8 *ibuf;
 223
 224         spin_lock_irqsave(&adap->lock, flags);
 225
 226         if (tx_header->type != header->type || tx_header->cmd != header->cmd) {
 227                 spin_unlock_irqrestore(&adap->lock, flags);
 228                 dev_err(adap->dev, "cmd ack mismatch error\n");
 229                 return;
 230         }
 231
 232         ibuf_len = adap->ex_buf_len;
 233         ibuf = adap->ex_buf;
 234
 235         if (ibuf && ibuf_len) {
 236                 actual_len = min(header->len, ibuf_len);
 237
 238                 /* copy received data to external buffer */
 239                 memcpy(ibuf, header->data, actual_len);
 240         }
 241         /* update copied data length */
 242         adap->actual_length = actual_len;
 243
 244         spin_unlock_irqrestore(&adap->lock, flags);
 245
 246         complete(&adap->cmd_completion);
 247 }
 248
 249 static void ljca_recv(struct urb *urb)
 250 {
 251         struct ljca_msg *header = urb->transfer_buffer;
 252         struct ljca_adapter *adap = urb->context;
 253         int ret;
 254
 255         switch (urb->status) {
 256         case 0:
 257                 /* success */
 258                 break;
 259         case -ENOENT:
 260                 /*
 261                  * directly complete the possible ongoing transfer
 262                  * during disconnect
 263                  */
 264                 if (adap->disconnect)
 265                         complete(&adap->cmd_completion);
 266                 return;
 267         case -ECONNRESET:
 268         case -ESHUTDOWN:
 269         case -EPIPE:
 270                 /* rx urb is terminated */
 271                 dev_dbg(adap->dev, "rx urb terminated with status: %d\n",
 272                         urb->status);
 273                 return;
 274         default:
 275                 dev_dbg(adap->dev, "rx urb error: %d\n", urb->status);
 276                 goto resubmit;
 277         }
 278
 279         if (header->len + sizeof(*header) != urb->actual_length)
 280                 goto resubmit;
 281
 282         if (header->flags & LJCA_ACK_FLAG)
 283                 ljca_handle_cmd_ack(adap, header);
 284         else
 285                 ljca_handle_event(adap, header);
 286
 287 resubmit:
 288         ret = usb_submit_urb(urb, GFP_ATOMIC);
 289         if (ret && ret != -EPERM)
 290                 dev_err(adap->dev, "resubmit rx urb error %d\n", ret);
 291 }
 292
 293 static int ljca_send(struct ljca_adapter *adap, u8 type, u8 cmd,
 294                      const u8 *obuf, u8 obuf_len, u8 *ibuf, u8 ibuf_len,
 295                      bool ack, unsigned long timeout)
 296 {
 297         unsigned int msg_len = sizeof(struct ljca_msg) + obuf_len;
 298         struct ljca_msg *header = adap->tx_buf;
 299         unsigned int transferred;
 300         unsigned long flags;
 301         int ret;
 302
 303         if (adap->disconnect)
 304                 return -ENODEV;
 305
 306         if (msg_len > adap->tx_buf_len)
 307                 return -EINVAL;
 308
 309         mutex_lock(&adap->mutex);
 310
 311         spin_lock_irqsave(&adap->lock, flags);
 312
 313         header->type = type;
 314         header->cmd = cmd;
 315         header->len = obuf_len;
 316         if (obuf)
 317                 memcpy(header->data, obuf, obuf_len);
 318
 319         header->flags = LJCA_CMPL_FLAG | (ack ? LJCA_ACK_FLAG : 0);
 320
 321         adap->ex_buf = ibuf;
 322         adap->ex_buf_len = ibuf_len;
 323         adap->actual_length = 0;
 324
 325         spin_unlock_irqrestore(&adap->lock, flags);
 326
 327         reinit_completion(&adap->cmd_completion);
 328
 329         ret = usb_autopm_get_interface(adap->intf);
 330         if (ret < 0)
 331                 goto out;
 332
 333         ret = usb_bulk_msg(adap->usb_dev, adap->tx_pipe, header,
 334                            msg_len, &transferred, LJCA_WRITE_TIMEOUT_MS);
 335         if (ret < 0)
 336                 goto out_put;
 337         if (transferred != msg_len) {
 338                 ret = -EIO;
 339                 goto out_put;
 340         }
 341
 342         if (ack) {
 343                 ret = wait_for_completion_timeout(&adap->cmd_completion,
 344                                                   timeout);
 345                 if (!ret) {
 346                         ret = -ETIMEDOUT;
 347                         goto out_put;
 348                 }
 349         }
 350         ret = adap->actual_length;
 351
 352 out_put:
 353         usb_autopm_put_interface(adap->intf);
 354
 355 out:
 356         spin_lock_irqsave(&adap->lock, flags);
 357         adap->ex_buf = NULL;
 358         adap->ex_buf_len = 0;
 359
 360         memset(header, 0, sizeof(*header));
 361         spin_unlock_irqrestore(&adap->lock, flags);
 362
 363         mutex_unlock(&adap->mutex);
 364
 365         return ret;
 366 }
 367
 368 int ljca_transfer(struct ljca_client *client, u8 cmd, const u8 *obuf,
 369                   u8 obuf_len, u8 *ibuf, u8 ibuf_len)
 370 {
 371         return ljca_send(client->adapter, client->type, cmd,
 372                          obuf, obuf_len, ibuf, ibuf_len, true,
 373                          LJCA_WRITE_ACK_TIMEOUT_MS);
 374 }
 375 EXPORT_SYMBOL_NS_GPL(ljca_transfer, "LJCA");
 376
 377 int ljca_transfer_noack(struct ljca_client *client, u8 cmd, const u8 *obuf,
 378                         u8 obuf_len)
 379 {
 380         return ljca_send(client->adapter, client->type, cmd, obuf,
 381                          obuf_len, NULL, 0, false, LJCA_WRITE_ACK_TIMEOUT_MS);
 382 }
 383 EXPORT_SYMBOL_NS_GPL(ljca_transfer_noack, "LJCA");
 384
 385 int ljca_register_event_cb(struct ljca_client *client, ljca_event_cb_t event_cb,
 386                            void *context)
 387 {
 388         unsigned long flags;
 389
 390         if (!event_cb)
 391                 return -EINVAL;
 392
 393         spin_lock_irqsave(&client->event_cb_lock, flags);
 394
 395         if (client->event_cb) {
 396                 spin_unlock_irqrestore(&client->event_cb_lock, flags);
 397                 return -EALREADY;
 398         }
 399
 400         client->event_cb = event_cb;
 401         client->context = context;
 402
 403         spin_unlock_irqrestore(&client->event_cb_lock, flags);
 404
 405         return 0;
 406 }
 407 EXPORT_SYMBOL_NS_GPL(ljca_register_event_cb, "LJCA");
 408
 409 void ljca_unregister_event_cb(struct ljca_client *client)
 410 {
 411         unsigned long flags;
 412
 413         spin_lock_irqsave(&client->event_cb_lock, flags);
 414
 415         client->event_cb = NULL;
 416         client->context = NULL;
 417
 418         spin_unlock_irqrestore(&client->event_cb_lock, flags);
 419 }
 420 EXPORT_SYMBOL_NS_GPL(ljca_unregister_event_cb, "LJCA");
 421
 422 static int ljca_match_device_ids(struct acpi_device *adev, void *data)
 423 {
 424         struct ljca_match_ids_walk_data *wd = data;
 425         const char *uid = acpi_device_uid(adev);
 426
 427         if (acpi_match_device_ids(adev, wd->ids))
 428                 return 0;
 429
 430         if (!wd->uid)
 431                 goto match;
 432
 433         if (!uid)
 434                 /*
 435                  * Some DSDTs have only one ACPI companion for the two I2C
 436                  * controllers and they don't set a UID at all (e.g. Dell
 437                  * Latitude 9420). On these platforms only the first I2C
 438                  * controller is used, so if a HID match has no UID we use
 439                  * "0" as the UID and assign ACPI companion to the first
 440                  * I2C controller.
 441                  */
 442                 uid = "0";
 443         else
 444                 uid = strchr(uid, wd->uid[0]);
 445
 446         if (!uid || strcmp(uid, wd->uid))
 447                 return 0;
 448
 449 match:
 450         wd->adev = adev;
 451
 452         return 1;
 453 }
 454
 455 /* bind auxiliary device to acpi device */
 456 static void ljca_auxdev_acpi_bind(struct ljca_adapter *adap,
 457                                   struct auxiliary_device *auxdev,
 458                                   u64 adr, u8 id)
 459 {
 460         struct ljca_match_ids_walk_data wd = { 0 };
 461         struct device *dev = adap->dev;
 462         struct acpi_device *parent;
 463         char uid[4];
 464
 465         parent = ACPI_COMPANION(dev);
 466         if (!parent)
 467                 return;
 468
 469         /*
 470          * Currently LJCA hw doesn't use _ADR instead the shipped
 471          * platforms use _HID to distinguish children devices.
 472          */
 473         switch (adr) {
 474         case LJCA_GPIO_ACPI_ADR:
 475                 wd.ids = ljca_gpio_hids;
 476                 break;
 477         case LJCA_I2C1_ACPI_ADR:
 478         case LJCA_I2C2_ACPI_ADR:
 479                 snprintf(uid, sizeof(uid), "%d", id);
 480                 wd.uid = uid;
 481                 wd.ids = ljca_i2c_hids;
 482                 break;
 483         case LJCA_SPI1_ACPI_ADR:
 484         case LJCA_SPI2_ACPI_ADR:
 485                 wd.ids = ljca_spi_hids;
 486                 break;
 487         default:
 488                 dev_warn(dev, "unsupported _ADR\n");
 489                 return;
 490         }
 491
 492         acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd);
 493         if (wd.adev) {
 494                 ACPI_COMPANION_SET(&auxdev->dev, wd.adev);
 495                 return;
 496         }
 497
 498         parent = ACPI_COMPANION(dev->parent->parent);
 499         if (!parent)
 500                 return;
 501
 502         acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd);
 503         if (wd.adev)
 504                 ACPI_COMPANION_SET(&auxdev->dev, wd.adev);
 505 }
 506
 507 static void ljca_auxdev_release(struct device *dev)
 508 {
 509         struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
 510
 511         kfree(auxdev->dev.platform_data);
 512 }
 513
 514 static int ljca_new_client_device(struct ljca_adapter *adap, u8 type, u8 id,
 515                                   char *name, void *data, u64 adr)
 516 {
 517         struct auxiliary_device *auxdev;
 518         struct ljca_client *client;
 519         int ret;
 520
 521         client = kzalloc(sizeof *client, GFP_KERNEL);
 522         if (!client) {
 523                 kfree(data);
 524                 return -ENOMEM;
 525         }
 526
 527         client->type = type;
 528         client->id = id;
 529         client->adapter = adap;
 530         spin_lock_init(&client->event_cb_lock);
 531
 532         auxdev = &client->auxdev;
 533         auxdev->name = name;
 534         auxdev->id = id;
 535
 536         auxdev->dev.parent = adap->dev;
 537         auxdev->dev.platform_data = data;
 538         auxdev->dev.release = ljca_auxdev_release;
 539
 540         ret = auxiliary_device_init(auxdev);
 541         if (ret) {
 542                 kfree(data);
 543                 goto err_free;
 544         }
 545
 546         ljca_auxdev_acpi_bind(adap, auxdev, adr, id);
 547
 548         ret = auxiliary_device_add(auxdev);
 549         if (ret)
 550                 goto err_uninit;
 551
 552         list_add_tail(&client->link, &adap->client_list);
 553
 554         return 0;
 555
 556 err_uninit:
 557         auxiliary_device_uninit(auxdev);
 558
 559 err_free:
 560         kfree(client);
 561
 562         return ret;
 563 }
 564
 565 static int ljca_enumerate_gpio(struct ljca_adapter *adap)
 566 {
 567         u32 valid_pin[LJCA_MAX_GPIO_NUM / BITS_PER_TYPE(u32)];
 568         struct ljca_gpio_descriptor *desc;
 569         struct ljca_gpio_info *gpio_info;
 570         u8 buf[LJCA_MAX_PAYLOAD_SIZE];
 571         int ret, gpio_num;
 572         unsigned int i;
 573
 574         ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_GPIO, NULL, 0, buf,
 575                         sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
 576         if (ret < 0)
 577                 return ret;
 578
 579         /* check firmware response */
 580         desc = (struct ljca_gpio_descriptor *)buf;
 581         if (ret != struct_size(desc, bank_desc, desc->bank_num))
 582                 return -EINVAL;
 583
 584         gpio_num = desc->pins_per_bank * desc->bank_num;
 585         if (gpio_num > LJCA_MAX_GPIO_NUM)
 586                 return -EINVAL;
 587
 588         /* construct platform data */
 589         gpio_info = kzalloc(sizeof *gpio_info, GFP_KERNEL);
 590         if (!gpio_info)
 591                 return -ENOMEM;
 592         gpio_info->num = gpio_num;
 593
 594         for (i = 0; i < desc->bank_num; i++)
 595                 valid_pin[i] = get_unaligned_le32(&desc->bank_desc[i].valid_pins);
 596         bitmap_from_arr32(gpio_info->valid_pin_map, valid_pin, gpio_num);
 597
 598         return ljca_new_client_device(adap, LJCA_CLIENT_GPIO, 0, "ljca-gpio",
 599                                      gpio_info, LJCA_GPIO_ACPI_ADR);
 600 }
 601
 602 static int ljca_enumerate_i2c(struct ljca_adapter *adap)
 603 {
 604         struct ljca_i2c_descriptor *desc;
 605         struct ljca_i2c_info *i2c_info;
 606         u8 buf[LJCA_MAX_PAYLOAD_SIZE];
 607         unsigned int i;
 608         int ret;
 609
 610         ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_I2C, NULL, 0, buf,
 611                         sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
 612         if (ret < 0)
 613                 return ret;
 614
 615         /* check firmware response */
 616         desc = (struct ljca_i2c_descriptor *)buf;
 617         if (ret != struct_size(desc, info, desc->num))
 618                 return -EINVAL;
 619
 620         for (i = 0; i < desc->num; i++) {
 621                 /* construct platform data */
 622                 i2c_info = kzalloc(sizeof *i2c_info, GFP_KERNEL);
 623                 if (!i2c_info)
 624                         return -ENOMEM;
 625
 626                 i2c_info->id = desc->info[i].id;
 627                 i2c_info->capacity = desc->info[i].capacity;
 628                 i2c_info->intr_pin = desc->info[i].intr_pin;
 629
 630                 ret = ljca_new_client_device(adap, LJCA_CLIENT_I2C, i,
 631                                              "ljca-i2c", i2c_info,
 632                                              LJCA_I2C1_ACPI_ADR + i);
 633                 if (ret)
 634                         return ret;
 635         }
 636
 637         return 0;
 638 }
 639
 640 static int ljca_enumerate_spi(struct ljca_adapter *adap)
 641 {
 642         struct ljca_spi_descriptor *desc;
 643         struct ljca_spi_info *spi_info;
 644         u8 buf[LJCA_MAX_PAYLOAD_SIZE];
 645         unsigned int i;
 646         int ret;
 647
 648         /* Not all LJCA chips implement SPI, a timeout reading the descriptors is normal */
 649         ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_SPI, NULL, 0, buf,
 650                         sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
 651         if (ret < 0)
 652                 return (ret == -ETIMEDOUT) ? 0 : ret;
 653
 654         /* check firmware response */
 655         desc = (struct ljca_spi_descriptor *)buf;
 656         if (ret != struct_size(desc, info, desc->num))
 657                 return -EINVAL;
 658
 659         for (i = 0; i < desc->num; i++) {
 660                 /* construct platform data */
 661                 spi_info = kzalloc(sizeof *spi_info, GFP_KERNEL);
 662                 if (!spi_info)
 663                         return -ENOMEM;
 664
 665                 spi_info->id = desc->info[i].id;
 666                 spi_info->capacity = desc->info[i].capacity;
 667
 668                 ret = ljca_new_client_device(adap, LJCA_CLIENT_SPI, i,
 669                                              "ljca-spi", spi_info,
 670                                              LJCA_SPI1_ACPI_ADR + i);
 671                 if (ret)
 672                         return ret;
 673         }
 674
 675         return 0;
 676 }
 677
 678 static int ljca_reset_handshake(struct ljca_adapter *adap)
 679 {
 680         __le32 reset_id = cpu_to_le32(adap->reset_id);
 681         __le32 reset_id_ret = 0;
 682         int ret;
 683
 684         adap->reset_id++;
 685
 686         ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_RESET, (u8 *)&reset_id,
 687                         sizeof(__le32), (u8 *)&reset_id_ret, sizeof(__le32),
 688                         true, LJCA_WRITE_ACK_TIMEOUT_MS);
 689         if (ret < 0)
 690                 return ret;
 691
 692         if (reset_id_ret != reset_id)
 693                 return -EINVAL;
 694
 695         return 0;
 696 }
 697
 698 static int ljca_enumerate_clients(struct ljca_adapter *adap)
 699 {
 700         struct ljca_client *client, *next;
 701         int ret;
 702
 703         ret = ljca_reset_handshake(adap);
 704         if (ret)
 705                 goto err_kill;
 706
 707         ret = ljca_enumerate_gpio(adap);
 708         if (ret) {
 709                 dev_err(adap->dev, "enumerate GPIO error\n");
 710                 goto err_kill;
 711         }
 712
 713         ret = ljca_enumerate_i2c(adap);
 714         if (ret) {
 715                 dev_err(adap->dev, "enumerate I2C error\n");
 716                 goto err_kill;
 717         }
 718
 719         ret = ljca_enumerate_spi(adap);
 720         if (ret) {
 721                 dev_err(adap->dev, "enumerate SPI error\n");
 722                 goto err_kill;
 723         }
 724
 725         return 0;
 726
 727 err_kill:
 728         adap->disconnect = true;
 729
 730         usb_kill_urb(adap->rx_urb);
 731
 732         list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) {
 733                 auxiliary_device_delete(&client->auxdev);
 734                 auxiliary_device_uninit(&client->auxdev);
 735
 736                 list_del_init(&client->link);
 737                 kfree(client);
 738         }
 739
 740         return ret;
 741 }
 742
 743 static int ljca_probe(struct usb_interface *interface,
 744                       const struct usb_device_id *id)
 745 {
 746         struct usb_device *usb_dev = interface_to_usbdev(interface);
 747         struct usb_host_interface *alt = interface->cur_altsetting;
 748         struct usb_endpoint_descriptor *ep_in, *ep_out;
 749         struct device *dev = &interface->dev;
 750         struct ljca_adapter *adap;
 751         int ret;
 752
 753         adap = devm_kzalloc(dev, sizeof(*adap), GFP_KERNEL);
 754         if (!adap)
 755                 return -ENOMEM;
 756
 757         /* separate tx buffer allocation for alignment */
 758         adap->tx_buf = devm_kzalloc(dev, LJCA_MAX_PACKET_SIZE, GFP_KERNEL);
 759         if (!adap->tx_buf)
 760                 return -ENOMEM;
 761         adap->tx_buf_len = LJCA_MAX_PACKET_SIZE;
 762
 763         mutex_init(&adap->mutex);
 764         spin_lock_init(&adap->lock);
 765         init_completion(&adap->cmd_completion);
 766         INIT_LIST_HEAD(&adap->client_list);
 767
 768         adap->intf = usb_get_intf(interface);
 769         adap->usb_dev = usb_dev;
 770         adap->dev = dev;
 771
 772         /*
 773          * find the first bulk in and out endpoints.
 774          * ignore any others.
 775          */
 776         ret = usb_find_common_endpoints(alt, &ep_in, &ep_out, NULL, NULL);
 777         if (ret) {
 778                 dev_err(dev, "bulk endpoints not found\n");
 779                 goto err_put;
 780         }
 781         adap->rx_pipe = usb_rcvbulkpipe(usb_dev, usb_endpoint_num(ep_in));
 782         adap->tx_pipe = usb_sndbulkpipe(usb_dev, usb_endpoint_num(ep_out));
 783
 784         /* setup rx buffer */
 785         adap->rx_len = usb_endpoint_maxp(ep_in);
 786         adap->rx_buf = devm_kzalloc(dev, adap->rx_len, GFP_KERNEL);
 787         if (!adap->rx_buf) {
 788                 ret = -ENOMEM;
 789                 goto err_put;
 790         }
 791
 792         /* alloc rx urb */
 793         adap->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 794         if (!adap->rx_urb) {
 795                 ret = -ENOMEM;
 796                 goto err_put;
 797         }
 798         usb_fill_bulk_urb(adap->rx_urb, usb_dev, adap->rx_pipe,
 799                           adap->rx_buf, adap->rx_len, ljca_recv, adap);
 800
 801         usb_set_intfdata(interface, adap);
 802
 803         /* submit rx urb before enumerate clients */
 804         ret = usb_submit_urb(adap->rx_urb, GFP_KERNEL);
 805         if (ret) {
 806                 dev_err(dev, "submit rx urb failed: %d\n", ret);
 807                 goto err_free;
 808         }
 809
 810         ret = ljca_enumerate_clients(adap);
 811         if (ret)
 812                 goto err_free;
 813
 814         /*
 815          * This works around problems with ov2740 initialization on some
 816          * Lenovo platforms. The autosuspend delay, has to be smaller than
 817          * the delay after setting the reset_gpio line in ov2740_resume().
 818          * Otherwise the sensor randomly fails to initialize.
 819          */
 820         pm_runtime_set_autosuspend_delay(&usb_dev->dev, 10);
 821
 822         usb_enable_autosuspend(usb_dev);
 823
 824         return 0;
 825
 826 err_free:
 827         usb_free_urb(adap->rx_urb);
 828
 829 err_put:
 830         usb_put_intf(adap->intf);
 831
 832         mutex_destroy(&adap->mutex);
 833
 834         return ret;
 835 }
 836
 837 static void ljca_disconnect(struct usb_interface *interface)
 838 {
 839         struct ljca_adapter *adap = usb_get_intfdata(interface);
 840         struct ljca_client *client, *next;
 841
 842         adap->disconnect = true;
 843
 844         usb_kill_urb(adap->rx_urb);
 845
 846         list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) {
 847                 auxiliary_device_delete(&client->auxdev);
 848                 auxiliary_device_uninit(&client->auxdev);
 849
 850                 list_del_init(&client->link);
 851                 kfree(client);
 852         }
 853
 854         usb_free_urb(adap->rx_urb);
 855
 856         usb_put_intf(adap->intf);
 857
 858         mutex_destroy(&adap->mutex);
 859 }
 860
 861 static int ljca_suspend(struct usb_interface *interface, pm_message_t message)
 862 {
 863         struct ljca_adapter *adap = usb_get_intfdata(interface);
 864
 865         usb_kill_urb(adap->rx_urb);
 866
 867         return 0;
 868 }
 869
 870 static int ljca_resume(struct usb_interface *interface)
 871 {
 872         struct ljca_adapter *adap = usb_get_intfdata(interface);
 873
 874         return usb_submit_urb(adap->rx_urb, GFP_KERNEL);
 875 }
 876
 877 static const struct usb_device_id ljca_table[] = {
 878         { USB_DEVICE(0x8086, 0x0b63) },
 879         { /* sentinel */ }
 880 };
 881 MODULE_DEVICE_TABLE(usb, ljca_table);
 882
 883 static struct usb_driver ljca_driver = {
 884         .name = "ljca",
 885         .id_table = ljca_table,
 886         .probe = ljca_probe,
 887         .disconnect = ljca_disconnect,
 888         .suspend = ljca_suspend,
 889         .resume = ljca_resume,
 890         .supports_autosuspend = 1,
 891 };
 892 module_usb_driver(ljca_driver);
 893
 894 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>");
 895 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
 896 MODULE_AUTHOR("Lixu Zhang <lixu.zhang@intel.com>");
 897 MODULE_DESCRIPTION("Intel La Jolla Cove Adapter USB driver");
 898 MODULE_LICENSE("GPL");