1 // SPDX-License-Identifier: GPL-2.0-only
3 * Intel La Jolla Cove Adapter USB driver
5 * Copyright (c) 2023, Intel Corporation.
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>
21 #include <asm/unaligned.h>
24 #define LJCA_ACK_FLAG BIT(0)
25 #define LJCA_RESP_FLAG BIT(1)
26 #define LJCA_CMPL_FLAG BIT(2)
28 #define LJCA_MAX_PACKET_SIZE 64u
29 #define LJCA_MAX_PAYLOAD_SIZE \
30 (LJCA_MAX_PACKET_SIZE - sizeof(struct ljca_msg))
32 #define LJCA_WRITE_TIMEOUT_MS 200
33 #define LJCA_WRITE_ACK_TIMEOUT_MS 500
34 #define LJCA_ENUM_CLIENT_TIMEOUT_MS 20
36 /* ljca client type */
37 enum ljca_client_type {
44 /* MNG client commands */
47 LJCA_MNG_ENUM_GPIO = 4,
48 LJCA_MNG_ENUM_I2C = 5,
49 LJCA_MNG_ENUM_SPI = 8,
52 /* ljca client acpi _ADR */
53 enum ljca_client_acpi_adr {
59 LJCA_CLIENT_ACPI_ADR_MAX,
62 /* ljca cmd message structure */
68 u8 data[] __counted_by(len);
71 struct ljca_i2c_ctr_info {
77 struct ljca_i2c_descriptor {
79 struct ljca_i2c_ctr_info info[] __counted_by(num);
82 struct ljca_spi_ctr_info {
88 struct ljca_spi_descriptor {
90 struct ljca_spi_ctr_info info[] __counted_by(num);
93 struct ljca_bank_descriptor {
97 /* 1 bit for each gpio, 1 means valid */
101 struct ljca_gpio_descriptor {
104 struct ljca_bank_descriptor bank_desc[] __counted_by(bank_num);
108 * struct ljca_adapter - represent a ljca adapter
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
130 struct ljca_adapter {
131 struct usb_interface *intf;
132 struct usb_device *usb_dev;
135 unsigned int rx_pipe;
136 unsigned int tx_pipe;
151 struct completion cmd_completion;
154 struct list_head client_list;
161 struct ljca_match_ids_walk_data {
162 const struct acpi_device_id *ids;
164 struct acpi_device *adev;
167 static const struct acpi_device_id ljca_gpio_hids[] = {
175 static const struct acpi_device_id ljca_i2c_hids[] = {
183 static const struct acpi_device_id ljca_spi_hids[] = {
191 static void ljca_handle_event(struct ljca_adapter *adap,
192 struct ljca_msg *header)
194 struct ljca_client *client;
196 list_for_each_entry(client, &adap->client_list, link) {
198 * Currently only GPIO register event callback, but
199 * firmware message structure should include id when
200 * multiple same type clients register event callback.
202 if (client->type == header->type) {
205 spin_lock_irqsave(&client->event_cb_lock, flags);
206 client->event_cb(client->context, header->cmd,
207 header->data, header->len);
208 spin_unlock_irqrestore(&client->event_cb_lock, flags);
215 /* process command ack and received data if available */
216 static void ljca_handle_cmd_ack(struct ljca_adapter *adap, struct ljca_msg *header)
218 struct ljca_msg *tx_header = adap->tx_buf;
219 u8 ibuf_len, actual_len = 0;
223 spin_lock_irqsave(&adap->lock, flags);
225 if (tx_header->type != header->type || tx_header->cmd != header->cmd) {
226 spin_unlock_irqrestore(&adap->lock, flags);
227 dev_err(adap->dev, "cmd ack mismatch error\n");
231 ibuf_len = adap->ex_buf_len;
234 if (ibuf && ibuf_len) {
235 actual_len = min(header->len, ibuf_len);
237 /* copy received data to external buffer */
238 memcpy(ibuf, header->data, actual_len);
240 /* update copied data length */
241 adap->actual_length = actual_len;
243 spin_unlock_irqrestore(&adap->lock, flags);
245 complete(&adap->cmd_completion);
248 static void ljca_recv(struct urb *urb)
250 struct ljca_msg *header = urb->transfer_buffer;
251 struct ljca_adapter *adap = urb->context;
254 switch (urb->status) {
260 * directly complete the possible ongoing transfer
263 if (adap->disconnect)
264 complete(&adap->cmd_completion);
269 /* rx urb is terminated */
270 dev_dbg(adap->dev, "rx urb terminated with status: %d\n",
274 dev_dbg(adap->dev, "rx urb error: %d\n", urb->status);
278 if (header->len + sizeof(*header) != urb->actual_length)
281 if (header->flags & LJCA_ACK_FLAG)
282 ljca_handle_cmd_ack(adap, header);
284 ljca_handle_event(adap, header);
287 ret = usb_submit_urb(urb, GFP_ATOMIC);
288 if (ret && ret != -EPERM)
289 dev_err(adap->dev, "resubmit rx urb error %d\n", ret);
292 static int ljca_send(struct ljca_adapter *adap, u8 type, u8 cmd,
293 const u8 *obuf, u8 obuf_len, u8 *ibuf, u8 ibuf_len,
294 bool ack, unsigned long timeout)
296 unsigned int msg_len = sizeof(struct ljca_msg) + obuf_len;
297 struct ljca_msg *header = adap->tx_buf;
298 unsigned int transferred;
302 if (adap->disconnect)
305 if (msg_len > adap->tx_buf_len)
308 mutex_lock(&adap->mutex);
310 spin_lock_irqsave(&adap->lock, flags);
314 header->len = obuf_len;
316 memcpy(header->data, obuf, obuf_len);
318 header->flags = LJCA_CMPL_FLAG | (ack ? LJCA_ACK_FLAG : 0);
321 adap->ex_buf_len = ibuf_len;
322 adap->actual_length = 0;
324 spin_unlock_irqrestore(&adap->lock, flags);
326 reinit_completion(&adap->cmd_completion);
328 ret = usb_autopm_get_interface(adap->intf);
332 ret = usb_bulk_msg(adap->usb_dev, adap->tx_pipe, header,
333 msg_len, &transferred, LJCA_WRITE_TIMEOUT_MS);
335 usb_autopm_put_interface(adap->intf);
339 if (transferred != msg_len) {
345 ret = wait_for_completion_timeout(&adap->cmd_completion,
352 ret = adap->actual_length;
355 spin_lock_irqsave(&adap->lock, flags);
357 adap->ex_buf_len = 0;
359 memset(header, 0, sizeof(*header));
360 spin_unlock_irqrestore(&adap->lock, flags);
362 mutex_unlock(&adap->mutex);
367 int ljca_transfer(struct ljca_client *client, u8 cmd, const u8 *obuf,
368 u8 obuf_len, u8 *ibuf, u8 ibuf_len)
370 return ljca_send(client->adapter, client->type, cmd,
371 obuf, obuf_len, ibuf, ibuf_len, true,
372 LJCA_WRITE_ACK_TIMEOUT_MS);
374 EXPORT_SYMBOL_NS_GPL(ljca_transfer, LJCA);
376 int ljca_transfer_noack(struct ljca_client *client, u8 cmd, const u8 *obuf,
379 return ljca_send(client->adapter, client->type, cmd, obuf,
380 obuf_len, NULL, 0, false, LJCA_WRITE_ACK_TIMEOUT_MS);
382 EXPORT_SYMBOL_NS_GPL(ljca_transfer_noack, LJCA);
384 int ljca_register_event_cb(struct ljca_client *client, ljca_event_cb_t event_cb,
392 spin_lock_irqsave(&client->event_cb_lock, flags);
394 if (client->event_cb) {
395 spin_unlock_irqrestore(&client->event_cb_lock, flags);
399 client->event_cb = event_cb;
400 client->context = context;
402 spin_unlock_irqrestore(&client->event_cb_lock, flags);
406 EXPORT_SYMBOL_NS_GPL(ljca_register_event_cb, LJCA);
408 void ljca_unregister_event_cb(struct ljca_client *client)
412 spin_lock_irqsave(&client->event_cb_lock, flags);
414 client->event_cb = NULL;
415 client->context = NULL;
417 spin_unlock_irqrestore(&client->event_cb_lock, flags);
419 EXPORT_SYMBOL_NS_GPL(ljca_unregister_event_cb, LJCA);
421 static int ljca_match_device_ids(struct acpi_device *adev, void *data)
423 struct ljca_match_ids_walk_data *wd = data;
424 const char *uid = acpi_device_uid(adev);
426 if (acpi_match_device_ids(adev, wd->ids))
434 * Some DSDTs have only one ACPI companion for the two I2C
435 * controllers and they don't set a UID at all (e.g. Dell
436 * Latitude 9420). On these platforms only the first I2C
437 * controller is used, so if a HID match has no UID we use
438 * "0" as the UID and assign ACPI companion to the first
443 uid = strchr(uid, wd->uid[0]);
445 if (!uid || strcmp(uid, wd->uid))
454 /* bind auxiliary device to acpi device */
455 static void ljca_auxdev_acpi_bind(struct ljca_adapter *adap,
456 struct auxiliary_device *auxdev,
459 struct ljca_match_ids_walk_data wd = { 0 };
460 struct device *dev = adap->dev;
461 struct acpi_device *parent;
464 parent = ACPI_COMPANION(dev);
469 * Currently LJCA hw doesn't use _ADR instead the shipped
470 * platforms use _HID to distinguish children devices.
473 case LJCA_GPIO_ACPI_ADR:
474 wd.ids = ljca_gpio_hids;
476 case LJCA_I2C1_ACPI_ADR:
477 case LJCA_I2C2_ACPI_ADR:
478 snprintf(uid, sizeof(uid), "%d", id);
480 wd.ids = ljca_i2c_hids;
482 case LJCA_SPI1_ACPI_ADR:
483 case LJCA_SPI2_ACPI_ADR:
484 wd.ids = ljca_spi_hids;
487 dev_warn(dev, "unsupported _ADR\n");
491 acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd);
493 ACPI_COMPANION_SET(&auxdev->dev, wd.adev);
497 parent = ACPI_COMPANION(dev->parent->parent);
501 acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd);
503 ACPI_COMPANION_SET(&auxdev->dev, wd.adev);
506 static void ljca_auxdev_release(struct device *dev)
508 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
510 kfree(auxdev->dev.platform_data);
513 static int ljca_new_client_device(struct ljca_adapter *adap, u8 type, u8 id,
514 char *name, void *data, u64 adr)
516 struct auxiliary_device *auxdev;
517 struct ljca_client *client;
520 client = kzalloc(sizeof *client, GFP_KERNEL);
526 client->adapter = adap;
527 spin_lock_init(&client->event_cb_lock);
529 auxdev = &client->auxdev;
533 auxdev->dev.parent = adap->dev;
534 auxdev->dev.platform_data = data;
535 auxdev->dev.release = ljca_auxdev_release;
537 ret = auxiliary_device_init(auxdev);
541 ljca_auxdev_acpi_bind(adap, auxdev, adr, id);
543 ret = auxiliary_device_add(auxdev);
547 list_add_tail(&client->link, &adap->client_list);
552 auxiliary_device_uninit(auxdev);
560 static int ljca_enumerate_gpio(struct ljca_adapter *adap)
562 u32 valid_pin[LJCA_MAX_GPIO_NUM / BITS_PER_TYPE(u32)];
563 struct ljca_gpio_descriptor *desc;
564 struct ljca_gpio_info *gpio_info;
565 u8 buf[LJCA_MAX_PAYLOAD_SIZE];
569 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_GPIO, NULL, 0, buf,
570 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
574 /* check firmware response */
575 desc = (struct ljca_gpio_descriptor *)buf;
576 if (ret != struct_size(desc, bank_desc, desc->bank_num))
579 gpio_num = desc->pins_per_bank * desc->bank_num;
580 if (gpio_num > LJCA_MAX_GPIO_NUM)
583 /* construct platform data */
584 gpio_info = kzalloc(sizeof *gpio_info, GFP_KERNEL);
587 gpio_info->num = gpio_num;
589 for (i = 0; i < desc->bank_num; i++)
590 valid_pin[i] = get_unaligned_le32(&desc->bank_desc[i].valid_pins);
591 bitmap_from_arr32(gpio_info->valid_pin_map, valid_pin, gpio_num);
593 ret = ljca_new_client_device(adap, LJCA_CLIENT_GPIO, 0, "ljca-gpio",
594 gpio_info, LJCA_GPIO_ACPI_ADR);
601 static int ljca_enumerate_i2c(struct ljca_adapter *adap)
603 struct ljca_i2c_descriptor *desc;
604 struct ljca_i2c_info *i2c_info;
605 u8 buf[LJCA_MAX_PAYLOAD_SIZE];
609 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_I2C, NULL, 0, buf,
610 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
614 /* check firmware response */
615 desc = (struct ljca_i2c_descriptor *)buf;
616 if (ret != struct_size(desc, info, desc->num))
619 for (i = 0; i < desc->num; i++) {
620 /* construct platform data */
621 i2c_info = kzalloc(sizeof *i2c_info, GFP_KERNEL);
625 i2c_info->id = desc->info[i].id;
626 i2c_info->capacity = desc->info[i].capacity;
627 i2c_info->intr_pin = desc->info[i].intr_pin;
629 ret = ljca_new_client_device(adap, LJCA_CLIENT_I2C, i,
630 "ljca-i2c", i2c_info,
631 LJCA_I2C1_ACPI_ADR + i);
641 static int ljca_enumerate_spi(struct ljca_adapter *adap)
643 struct ljca_spi_descriptor *desc;
644 struct ljca_spi_info *spi_info;
645 u8 buf[LJCA_MAX_PAYLOAD_SIZE];
649 /* Not all LJCA chips implement SPI, a timeout reading the descriptors is normal */
650 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_SPI, NULL, 0, buf,
651 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS);
653 return (ret == -ETIMEDOUT) ? 0 : ret;
655 /* check firmware response */
656 desc = (struct ljca_spi_descriptor *)buf;
657 if (ret != struct_size(desc, info, desc->num))
660 for (i = 0; i < desc->num; i++) {
661 /* construct platform data */
662 spi_info = kzalloc(sizeof *spi_info, GFP_KERNEL);
666 spi_info->id = desc->info[i].id;
667 spi_info->capacity = desc->info[i].capacity;
669 ret = ljca_new_client_device(adap, LJCA_CLIENT_SPI, i,
670 "ljca-spi", spi_info,
671 LJCA_SPI1_ACPI_ADR + i);
681 static int ljca_reset_handshake(struct ljca_adapter *adap)
683 __le32 reset_id = cpu_to_le32(adap->reset_id);
684 __le32 reset_id_ret = 0;
689 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_RESET, (u8 *)&reset_id,
690 sizeof(__le32), (u8 *)&reset_id_ret, sizeof(__le32),
691 true, LJCA_WRITE_ACK_TIMEOUT_MS);
695 if (reset_id_ret != reset_id)
701 static int ljca_enumerate_clients(struct ljca_adapter *adap)
703 struct ljca_client *client, *next;
706 ret = ljca_reset_handshake(adap);
710 ret = ljca_enumerate_gpio(adap);
712 dev_err(adap->dev, "enumerate GPIO error\n");
716 ret = ljca_enumerate_i2c(adap);
718 dev_err(adap->dev, "enumerate I2C error\n");
722 ret = ljca_enumerate_spi(adap);
724 dev_err(adap->dev, "enumerate SPI error\n");
731 adap->disconnect = true;
733 usb_kill_urb(adap->rx_urb);
735 list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) {
736 auxiliary_device_delete(&client->auxdev);
737 auxiliary_device_uninit(&client->auxdev);
739 list_del_init(&client->link);
746 static int ljca_probe(struct usb_interface *interface,
747 const struct usb_device_id *id)
749 struct usb_device *usb_dev = interface_to_usbdev(interface);
750 struct usb_host_interface *alt = interface->cur_altsetting;
751 struct usb_endpoint_descriptor *ep_in, *ep_out;
752 struct device *dev = &interface->dev;
753 struct ljca_adapter *adap;
756 adap = devm_kzalloc(dev, sizeof(*adap), GFP_KERNEL);
760 /* separate tx buffer allocation for alignment */
761 adap->tx_buf = devm_kzalloc(dev, LJCA_MAX_PACKET_SIZE, GFP_KERNEL);
764 adap->tx_buf_len = LJCA_MAX_PACKET_SIZE;
766 mutex_init(&adap->mutex);
767 spin_lock_init(&adap->lock);
768 init_completion(&adap->cmd_completion);
769 INIT_LIST_HEAD(&adap->client_list);
771 adap->intf = usb_get_intf(interface);
772 adap->usb_dev = usb_dev;
776 * find the first bulk in and out endpoints.
779 ret = usb_find_common_endpoints(alt, &ep_in, &ep_out, NULL, NULL);
781 dev_err(dev, "bulk endpoints not found\n");
784 adap->rx_pipe = usb_rcvbulkpipe(usb_dev, usb_endpoint_num(ep_in));
785 adap->tx_pipe = usb_sndbulkpipe(usb_dev, usb_endpoint_num(ep_out));
787 /* setup rx buffer */
788 adap->rx_len = usb_endpoint_maxp(ep_in);
789 adap->rx_buf = devm_kzalloc(dev, adap->rx_len, GFP_KERNEL);
796 adap->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
801 usb_fill_bulk_urb(adap->rx_urb, usb_dev, adap->rx_pipe,
802 adap->rx_buf, adap->rx_len, ljca_recv, adap);
804 usb_set_intfdata(interface, adap);
806 /* submit rx urb before enumerate clients */
807 ret = usb_submit_urb(adap->rx_urb, GFP_KERNEL);
809 dev_err(dev, "submit rx urb failed: %d\n", ret);
813 ret = ljca_enumerate_clients(adap);
817 usb_enable_autosuspend(usb_dev);
822 usb_free_urb(adap->rx_urb);
825 usb_put_intf(adap->intf);
827 mutex_destroy(&adap->mutex);
832 static void ljca_disconnect(struct usb_interface *interface)
834 struct ljca_adapter *adap = usb_get_intfdata(interface);
835 struct ljca_client *client, *next;
837 adap->disconnect = true;
839 usb_kill_urb(adap->rx_urb);
841 list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) {
842 auxiliary_device_delete(&client->auxdev);
843 auxiliary_device_uninit(&client->auxdev);
845 list_del_init(&client->link);
849 usb_free_urb(adap->rx_urb);
851 usb_put_intf(adap->intf);
853 mutex_destroy(&adap->mutex);
856 static int ljca_suspend(struct usb_interface *interface, pm_message_t message)
858 struct ljca_adapter *adap = usb_get_intfdata(interface);
860 usb_kill_urb(adap->rx_urb);
865 static int ljca_resume(struct usb_interface *interface)
867 struct ljca_adapter *adap = usb_get_intfdata(interface);
869 return usb_submit_urb(adap->rx_urb, GFP_KERNEL);
872 static const struct usb_device_id ljca_table[] = {
873 { USB_DEVICE(0x8086, 0x0b63) },
876 MODULE_DEVICE_TABLE(usb, ljca_table);
878 static struct usb_driver ljca_driver = {
880 .id_table = ljca_table,
882 .disconnect = ljca_disconnect,
883 .suspend = ljca_suspend,
884 .resume = ljca_resume,
885 .supports_autosuspend = 1,
887 module_usb_driver(ljca_driver);
889 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>");
890 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
891 MODULE_AUTHOR("Lixu Zhang <lixu.zhang@intel.com>");
892 MODULE_DESCRIPTION("Intel La Jolla Cove Adapter USB driver");
893 MODULE_LICENSE("GPL");