platform/chrome: Add ChromeOS EC USB driver
Subsystems (2)
PATCH 1/1 platform/chrome: Add ChromeOS EC USB driver
This uses USB to talk to the ChromeOS EC. The protocol is defined by the EC and is fairly simple, with a length byte, checksum, command byte and version byte in the header.
The driver uses vendor defined usb interface with in/out endpoints to transfer requests and responses. The driver also uses one interrupt in endpoint which signals readiness of response and pending events on the EC side.
--- drivers/platform/chrome/Kconfig | 11 + drivers/platform/chrome/Makefile | 1 + drivers/platform/chrome/cros_ec_usb.c | 621 ++++++++++++++++++++++++++ 3 files changed, 633 insertions(+) create mode 100644 drivers/platform/chrome/cros_ec_usb.c
drivers/platform/chrome/Kconfig +11 -0
@@ -316,6 +316,17 @@ config CROS_TYPEC_SWITCH To compile this driver as a module, choose M here: the module will be called cros_typec_switch. +config CROS_EC_USB + tristate "ChromeOS Embedded Controller (USB)" + depends on CROS_EC && USB + help + If you say Y here, you get support for talking to the ChromeOS EC + through a USB. The driver uses vendor defined interface and is capable + of signaling events from EC. + + To compile this driver as a module, choose M here: the + module will be called cros_ec_usb. + source "drivers/platform/chrome/wilco_ec/Kconfig" # Kunit test cases
drivers/platform/chrome/Makefile +1 -0
@@ -38,6 +38,7 @@ obj-$(CONFIG_CROS_EC_SYSFS) += cros_ec_sysfs.o obj-$(CONFIG_CROS_HPS_I2C) += cros_hps_i2c.o obj-$(CONFIG_CROS_USBPD_LOGGER) += cros_usbpd_logger.o obj-$(CONFIG_CROS_USBPD_NOTIFY) += cros_usbpd_notify.o +obj-$(CONFIG_CROS_EC_USB) += cros_ec_usb.o obj-$(CONFIG_WILCO_EC) += wilco_ec/
drivers/platform/chrome/cros_ec_usb.c new file +621 -0
621 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Tzung-Bi Shih
maintainerQuoted 8 lines · Dawid Niedzwiecki
This uses USB to talk to the ChromeOS EC. The protocol is defined by the EC and is fairly simple, with a length byte, checksum, command byte and version byte in the header.
The driver uses vendor defined usb interface with in/out endpoints to transfer requests and responses. The driver also uses one interrupt in endpoint which signals readiness of response and pending events on the EC side.
s/This//;s/The driver// and modify the rest of sentences accordingly. Not a hard requirement but [1]("imperative mood").
[1]: https://www.kernel.org/doc/html/latest/process/submitting-patches.html
Some part of code is not easy to read to me. I'd suggest to consider to:
- Use shorter local variable names.
- Don't wrap lines whenever it's still under 100-cols.
- Put more relevant pieces of code closer.
- Insert blank lines for separating logic blocks.
- Drop redundant comments if the code is clear.
It doesn't need to be overkill as long as that makes sense.
drivers/platform/chrome/cros_ec_usb.c line 23
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+#include "cros_ec.h" + +/* Google */
Drop this comment which makes less sense.
Quoted 2 lines
[...]
+/* table of devices that work with this driver */
Drop the comment.
drivers/platform/chrome/cros_ec_usb.c line 43
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+static const struct usb_device_id cros_ec_usb_table[] = { + {USB_VENDOR_AND_INTERFACE_INFO (USB_VENDOR_ID_GOOGLE , +USB_CLASS_VENDOR_SPEC , +USB_SUBCLASS_GOOGLE_EC_HOST_CMD , +USB_PROTOCOL_GOOGLE_EC_HOST_CMD ) }, + {}/* Terminating entry */
Drop the comment which is a very clear intent.
drivers/platform/chrome/cros_ec_usb.c
Quoted 2 lines
drivers/platform/chrome/cros_ec_usb.c +2
-0+}; +MODULE_DEVICE_TABLE (usb, cros_ec_usb_table);
I'd prefer to move the device_id definition just right before the struct usb_driver.
Quoted 1 line
+/* Structure to hold all of our device specific stuff */
Drop the comment.
Quoted 1 line
+struct
cros_ec_usb{
For readability, insert some blank lines in the struct.
drivers/platform/chrome/cros_ec_usb.c line 54
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+/* the usb device for this device */ +struct usb_device *udev; +/* the interface for this device */ +struct usb_interface *interface; +/* Cros EC device structure */ +struct cros_ec_device *ec_dev;
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 64
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+/* the buffer to receive data from bulk ep */ +u8 *bulk_in_buffer; +/* the buffer to receive data from int ep */ +u8 *int_in_buffer; +/* the urb to receive data from int ep */ +struct urb *int_in_urb; +/* the size of the receive buffer from bulk ep */ +size_t bulk_in_size; +/* the size of the receive buffer from int ep */ +size_t int_in_size;
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 72
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* the pipe of the bulk in ep */ +unsigned int bulk_in_pipe; +/* the pipe of the bulk out ep */ +unsigned int bulk_out_pipe; +/* the pipe of the int in ep */ +unsigned int int_in_pipe; +/* the interval of the int in ep */ +uint8_t int_in_interval;
Maybe insert a blank line here.
./scripts/checkpatch.pl --strict complains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
drivers/platform/chrome/cros_ec_usb.c line 89
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+struct int_msg { +uint8_t int_type; +} __packed;
./scripts/checkpatch.pl --strict complains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
Quoted 1 line
+static void
cros_ec_int_callback(struct urb *urb);
Move just right before submit_int_urb() to make the intent more clear?
drivers/platform/chrome/cros_ec_usb.c line 112
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c +12
-0+static int expected_response_size (const struct ec_host_response *host_response) +{ +/* Check host request version */ +if (host_response->struct_version !=3 ) +return 0 ; + +/* Reserved byte should be 0 */ +if (host_response->reserved) +return 0 ; + +return sizeof (*host_response) + host_response->data_len; +}
Wondering if the function really helps readability. Maybe just inline to do_cros_ec_pkt_xfer_usb()?
drivers/platform/chrome/cros_ec_usb.c line 118
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+static int cros_ec_usb_register (u16 idProduct,struct cros_ec_usb *ec_usb) +{ +struct registered_ec *ec; + + ec =kzalloc (sizeof (*ec),GFP_KERNEL );
kmalloc() should be sufficient. The member fields are going to be overridden anyway.
drivers/platform/chrome/cros_ec_usb.c line 159
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+static int submit_int_urb (struct cros_ec_device *ec_dev) +{ +struct cros_ec_usb *ec_usb = ec_dev->priv; +struct usb_device *usb_dev =interface_to_usbdev (ec_usb->interface); +int ret; + +/* Submit the INT URB. */ +usb_fill_int_urb (ec_usb->int_in_urb, usb_dev, ec_usb->int_in_pipe, + ec_usb->int_in_buffer, ec_usb->int_in_size, + cros_ec_int_callback, ec_usb, ec_usb->int_in_interval); + ret =usb_submit_urb (ec_usb->int_in_urb,GFP_KERNEL ); + +return ret;
Eliminate the ret. Just return usb_submit_urb(...).
drivers/platform/chrome/cros_ec_usb.c line 186
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c +11
-0+static void cros_ec_int_callback (struct urb *urb) +{ +struct cros_ec_usb *ec_usb = urb->context; +struct cros_ec_device *ec_dev = ec_usb->ec_dev; +int ret; + +if (urb->actual_length >=sizeof (struct int_msg )) { +struct int_msg *int_msg = + (struct int_msg *)ec_usb->int_in_buffer; +enum cros_ec_usb_int_type int_type = + (enum cros_ec_usb_int_type )int_msg->int_type;
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 197
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c +11
-0+switch (int_type) { +case INT_TYPE_EVENT_OCCURED : +if (ec_usb->registered) { + ec_dev->last_event_time =cros_ec_get_time_ns (); +schedule_work (&ec_usb->work_ec_evt); + } +break ; +case INT_TYPE_RESPONSE_READY : + ec_usb->resp_ready = true; +wake_up (&ec_usb->resp_ready_wait); +break ;
I'm wondering who fills the int_type (i.e. 0 and 1) here? EC? If so, why aren't they in cros_ec_command.h?
drivers/platform/chrome/cros_ec_usb.c line 205
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+default : +dev_err (ec_dev->dev,"Unrecognized event: %d\n" , + int_type); + } + }else { +dev_err (ec_dev->dev,"Incorrect int transfer len: %d\n" , + urb->actual_length); + }
So in either cases, all of them need to resubmit the URB? Doesn't some of them just need to return?
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+ +resubmit: +/* Resubmit the INT URB. */ + ret =submit_int_urb (ec_dev); +if (ret) +dev_err (ec_dev->dev,"Failed to resumbit int urb: %d" , ret); +} +
drivers/platform/chrome/cros_ec_usb.c line 223
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+static int do_cros_ec_pkt_xfer_usb (struct cros_ec_device *ec_dev, +struct cros_ec_command *ec_msg) +{ +struct cros_ec_usb *ec_usb = ec_dev->priv; +struct ec_host_response *host_response; +int req_size, ret, actual_length, expected_resp_size, resp_size; +const int header_size =sizeof (*host_response); +const int max_resp_size = header_size + ec_msg->insize; +const int bulk_in_size =umin (ec_usb->bulk_in_size, ec_dev->din_size); +uint8_t sum =0 ;
./scripts/checkpatch.pl --strict complains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+/* Get first part of response that contains a header. */ + ret = usb_bulk_msg(ec_usb->udev, ec_usb->bulk_in_pipe, ec_dev->din, + bulk_in_size, &actual_length,
drivers/platform/chrome/cros_ec_usb.c line 281
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+ BULK_TRANSFER_TIMEOUT_MS); +if (ret) { +dev_err (ec_dev->dev,"Failed to get response: %d\n" , ret); + goto exit; + } + +/* Verify number of received bytes. */ +if (actual_length < header_size) { +dev_err (ec_dev->dev,"Received too little bytes: %d\n" , + actual_length);
Is it possible that the actual_length < header_size just because it needs to further read? I.e. need a read loop for waiting EOF or actual_length >= header_size?
drivers/platform/chrome/cros_ec_usb.c line 293
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c +12
-0+ ret = -ENOSPC ; + goto exit; + } + expected_resp_size = +expected_response_size ((struct ec_host_response *)ec_dev->din); +if ((expected_resp_size > max_resp_size) || (expected_resp_size ==0 ) || + (actual_length > expected_resp_size)) { +dev_err (ec_dev->dev,"Incorrect number of expected bytes: %d\n" , + expected_resp_size); + ret = -ENOSPC ; + goto exit; + }
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 294
Quoted 1 line
drivers/platform/chrome/cros_ec_usb.c +1
-0+ resp_size = actual_length;
Move next to the following line of the comment.
drivers/platform/chrome/cros_ec_usb.c line 307
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+/* Get the rest of the response if needed. */ +if (resp_size < expected_resp_size) { + ret =usb_bulk_msg (ec_usb->udev, ec_usb->bulk_in_pipe, + ec_dev->din + resp_size, + expected_resp_size - resp_size, + &actual_length,BULK_TRANSFER_TIMEOUT_MS ); +if (ret) { +dev_err (ec_dev->dev, +"Failed to get second part of response: %d\n" , + ret); + goto exit; + } + resp_size += actual_length;
Same here: doesn't it need a read loop for waiting EOF or resp_size >= expected_resp_size?
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+ } + +/* Check if number of received of bytes is correct. */ +if (resp_size != expected_resp_size) {
drivers/platform/chrome/cros_ec_usb.c line 321
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+dev_err (ec_dev->dev, +"Received incorrect number of bytes: %d, expected: %d\n" , + resp_size, expected_resp_size); + ret = -ENOSPC ; + goto exit; + } + +/* Validate checksum */ + host_response = (struct ec_host_response *)ec_dev->din; + for (int i = 0; i < sizeof(*host_response) + host_response->data_len;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
I.e. expected_resp_size.
drivers/platform/chrome/cros_ec_usb.c line 324
Quoted 3 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+ i++) { + sum += ec_dev->din[i]; + }
Drop the {} pair.
drivers/platform/chrome/cros_ec_usb.c line 333
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c +9
-0+if (sum) { +dev_err (ec_dev->dev,"Bad packet checksum calculated %x\n" , + sum); + ret = -EBADMSG ; + goto exit; + } + + ec_msg->result = host_response->result; + memcpy(ec_msg->data, ec_dev->din + sizeof(*host_response),
header_size == sizeof(*host_response). Either drop header_size or use it.
Quoted 4 lines
+/**
+ *usb_evt_handler- USB to AP event handler
+ * @work: Work struct
+ */
Maybe drop the comment?
drivers/platform/chrome/cros_ec_usb.c line 382
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+static int cros_ec_usb_probe (struct usb_interface *intf, +const struct usb_device_id *id) +{ +struct usb_device *usb_dev =interface_to_usbdev (intf); +struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in; +struct device *if_dev = &intf->dev; +struct cros_ec_device *ec_dev; +const u16 idProduct = usb_dev->descriptor.idProduct; +struct cros_ec_usb *ec_usb =cros_ec_usb_get_registered (idProduct); +const bool is_registered = ec_usb !=NULL ;
Or !!ec_usb.
drivers/platform/chrome/cros_ec_usb.c line 395
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+int retval; + +/* +* Do not register the same EC device twice. The probing is performed every +* reboot, sysjump, crash etc. Recreating the /dev/cros_X file every time +* would force all application to reopen the file, which is not a case for +* other cros_ec_x divers. Instead, keep the cros_ec_device and cros_ec_usb +* structures constant and replace USB related structures for the same EC +* that is reprobed. +* +* The driver doesn't support handling two devices with the same idProduct, +* but it will never be a real usecase. +*/
I don't quite understand why does it need to memorize the registered ECs. Supposedly, the probe function is only called few times during booting, and gets success once. Hot-plugs?
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+if (!is_registered) + ec_usb =kzalloc (sizeof (*ec_usb),GFP_KERNEL ); + +if (!ec_usb) +return -ENOMEM ; + +if (!is_registered) {
drivers/platform/chrome/cros_ec_usb.c line 412
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+mutex_init (&ec_usb->io_mutex); + ec_dev =kzalloc (sizeof (*ec_dev),GFP_KERNEL ); +if (!ec_dev) { + retval = -ENOMEM ; + goto error; + } + ec_usb->ec_dev = ec_dev; + }else { + ec_dev = ec_usb->ec_dev; + }
The !ec_usb check is only needed after kzalloc(). Thus, the code block could be simplified to:
if (!is_registered) {
ec_usb = kzalloc(...);
if (!ec_usb)
return -ENOMEM
ec_dev = kzalloc(...);
/* initialized ec_usb and ec_dev */
mutex_init(...);
ec_usb->...
}
ec_dev = ec_usb->ec_dev;drivers/platform/chrome/cros_ec_usb.c line 415
Quoted 3 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+ + ec_usb->udev =usb_get_dev (usb_dev); + ec_usb->interface =usb_get_intf (intf);
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 423
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* Use first bulk-in/out endpoints + int-in endpoint */ + retval =usb_find_common_endpoints (intf->cur_altsetting, &bulk_in, + &bulk_out, &int_in,NULL ); +if (retval) { +dev_err (if_dev, +"Could not find bulk-in, bulk-out or int-in endpoint\n" ); + goto error; + }
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 431
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* Bulk endpoints have to be capable of sending headers in one transfer. */ +if ((usb_endpoint_maxp (bulk_out) <sizeof (struct ec_host_request )) || + (usb_endpoint_maxp (bulk_in) <sizeof (struct ec_host_response )) || + (usb_endpoint_maxp (int_in)) <sizeof (struct int_msg )) { + retval = -ENOSPC ; +dev_err (if_dev,"Incorrect max packet size\n" ); + goto error; + }
Maybe insert a blank line here.
drivers/platform/chrome/cros_ec_usb.c line 442
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c +11
-0+ ec_usb->bulk_out_pipe = +usb_sndbulkpipe (ec_usb->udev, bulk_out->bEndpointAddress); + ec_usb->bulk_in_size =usb_endpoint_maxp (bulk_in); + ec_usb->bulk_in_pipe = +usb_rcvbulkpipe (ec_usb->udev, bulk_in->bEndpointAddress); + ec_usb->bulk_in_buffer =kmalloc (ec_usb->bulk_in_size,GFP_KERNEL ); +if (!ec_usb->bulk_in_buffer) { +dev_err (if_dev,"Failed to allocate bulk in buffer\n" ); + retval = -ENOMEM ; + goto error; + }
Maybe insert a blank line here.
Quoted 43 lines
drivers/platform/chrome/cros_ec_usb.c +43
-0+ ec_usb->int_in_size =usb_endpoint_maxp (int_in); + ec_usb->int_in_pipe = +usb_rcvintpipe (ec_usb->udev, int_in->bEndpointAddress); + ec_usb->int_in_interval = int_in->bInterval; + ec_usb->int_in_buffer =kmalloc (ec_usb->int_in_size,GFP_KERNEL ); +if (!ec_usb->int_in_buffer) { +dev_err (if_dev,"Failed to allocate int in buffer\n" ); + retval = -ENOMEM ; + goto error; + } + ec_usb->int_in_urb =usb_alloc_urb (0 ,GFP_KERNEL ); +if (!ec_usb->int_in_urb) { +dev_err (if_dev,"Failed to allocate int in urb\n" ); + retval = -ENOMEM ; + goto error; + } + + ec_dev->dev = if_dev; + ec_dev->phys_name =dev_name (if_dev); +if (!is_registered) { + ec_dev->priv = ec_usb; +/* EC uses int endpoint to signal events. */ + ec_dev->irq =0 ; + ec_dev->cmd_xfer =NULL ; + ec_dev->pkt_xfer = do_cros_ec_pkt_xfer_usb; + ec_dev->din_size =sizeof (struct ec_host_response ) + +sizeof (struct ec_response_get_protocol_info ); + ec_dev->dout_size =sizeof (struct ec_host_request ) + +sizeof (struct ec_params_rwsig_action ); +INIT_WORK (&ec_usb->work_ec_evt, usb_evt_handler); +init_waitqueue_head (&ec_usb->resp_ready_wait); + }else { +/* +* We need to allocate dout and din buffers, because cros_ec_register +* won't be called. These buffers were freed once previous usb device was +* disconnected. Use buffer sizes from the last query. +* The EC_HOST_EVENT_INTERFACE_READY event will be triggered at the end +* of a boot, which calls cros_ec_query_all function, that reallocates +* buffers. +*/ + ec_dev->din =devm_kzalloc (ec_dev->dev, ec_dev->din_size,GFP_KERNEL ); +if (!ec_dev->din) { + retval = -ENOMEM ;
drivers/platform/chrome/cros_ec_usb.c line 495
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+dev_err (if_dev,"Failed to allocate din buffer\n" ); + goto error; + } + ec_dev->dout =devm_kzalloc (ec_dev->dev, ec_dev->dout_size,GFP_KERNEL ); +if (!ec_dev->dout) { + retval = -ENOMEM ; +dev_err (if_dev,"Failed to allocate dout buffer\n" ); + goto error; + } + }
This whole block for initializing ec_dev can be done earlier. See another !is_registered above.
drivers/platform/chrome/cros_ec_usb.c line 497
Quoted 2 lines
drivers/platform/chrome/cros_ec_usb.c +2
-0+ +/* Needed by ec register function */
Drop the comment.
drivers/platform/chrome/cros_ec_usb.c line 498
Quoted 1 line
drivers/platform/chrome/cros_ec_usb.c +1
-0+usb_set_intfdata (intf, ec_dev);
This also can be done earlier when ec_dev is determined.
drivers/platform/chrome/cros_ec_usb.c line 502
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+ +mutex_lock (&ec_usb->io_mutex); + ec_usb->disconnected = false; +mutex_unlock (&ec_usb->io_mutex);
Wondering if it really needs to acquire the lock? Probe functions usually don't need to as there is no possible concurrent paths yet.
drivers/platform/chrome/cros_ec_usb.c line 537
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+error: +/* Free allocated memory */ +cros_ec_usb_delete (ec_usb);
Be careful to make sure whether cancel_work_sync() works even if &ec_usb->work_ec_evt is uninitialized.
drivers/platform/chrome/cros_ec_usb.c line 554
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+static void cros_ec_usb_disconnect (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +struct cros_ec_usb *ec_usb = ec_dev->priv; + +/* prevent more I/O from starting */ +mutex_lock (&ec_usb->io_mutex); + ec_usb->disconnected = true; +mutex_unlock (&ec_usb->io_mutex); + +cros_ec_usb_delete (ec_usb); + +dev_info (&intf->dev,"Disconnected\n" );
This is the only dev_info() in the various callbacks. Consider to drop it if it might not very useful.
drivers/platform/chrome/cros_ec_usb.c line 574
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+static int cros_ec_usb_resume (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +int err; + +/* URB is killed during suspend. */ + err =submit_int_urb (ec_dev); +if (err) { +dev_err (ec_dev->dev, +"Failed to sumbit int urb after resume: %d\n" , err); + } + +return 0 ;
Doesn't it need to return err?
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+static int cros_ec_usb_post_reset (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +struct cros_ec_usb *ec_usb = ec_dev->priv;
drivers/platform/chrome/cros_ec_usb.c line 603
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+int err; + + err =submit_int_urb (ec_dev); +if (err) { +dev_err (ec_dev->dev, +"Failed to sumbit int urb after reset: %d\n" , err); + } +mutex_unlock (&ec_usb->io_mutex); + +return 0 ;
Doesn't it need to return err?
drivers/platform/chrome/cros_ec_usb.c line 617
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c +12
-0+static struct usb_driver cros_ec_usb = { + .name ="cros-ec-usb" , + .probe = cros_ec_usb_probe, + .disconnect = cros_ec_usb_disconnect, + .suspend = cros_ec_usb_suspend, + .resume = cros_ec_usb_resume, + .pre_reset = cros_ec_usb_pre_reset, + .post_reset = cros_ec_usb_post_reset, + .id_table = cros_ec_usb_table, +/* Do not autosuspend EC */ + .supports_autosuspend =0 , +};
Most .X callbacks are named cros_ec_usb_X. Only the .id_table is different. To be neat, I'd suggest to use cros_ec_usb_id_table.
Please see inline comments.
Quoted 11 lines · Tzung-Bi Shih
Quoted 8 lines · Dawid Niedzwiecki
This uses USB to talk to the ChromeOS EC. The protocol is defined by the EC and is fairly simple, with a length byte, checksum, command byte and version byte in the header.
The driver uses vendor defined usb interface with in/out endpoints to transfer requests and responses. The driver also uses one interrupt in endpoint which signals readiness of response and pending events on the EC side.
Quoted 5 lines
s/This//;s/The driver// and modify the rest of sentences accordingly. Not a hard requirement but [1]("imperative mood").
[1]: https://www.kernel.org/doc/html/latest/process/submitting-patches.html
Will do.
Quoted 8 lines
Some part of code is not easy to read to me. I'd suggest to consider to:
- Use shorter local variable names.
- Don't wrap lines whenever it's still under 100-cols.
- Put more relevant pieces of code closer.
- Insert blank lines for separating logic blocks.
- Drop redundant comments if the code is clear.
It doesn't need to be overkill as long as that makes sense.
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c line 23
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+#include "cros_ec.h" + +/* Google */ Drop this comment which makes less sense.
Will do.
Quoted 5 lines
Quoted 2 lines
[...]
+/* table of devices that work with this driver */Drop the comment.
Will do.
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 43
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+static const struct usb_device_id cros_ec_usb_table[] = { + {USB_VENDOR_AND_INTERFACE_INFO (USB_VENDOR_ID_GOOGLE , +USB_CLASS_VENDOR_SPEC , +USB_SUBCLASS_GOOGLE_EC_HOST_CMD , +USB_PROTOCOL_GOOGLE_EC_HOST_CMD ) }, + {}/* Terminating entry */ Drop the comment which is a very clear intent.
Will do.
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c
Quoted 2 lines
drivers/platform/chrome/cros_ec_usb.c +2
-0+}; +MODULE_DEVICE_TABLE (usb, cros_ec_usb_table);I'd prefer to move the
device_iddefinition just right before the structusb_driver.Quoted 1 line
+/* Structure to hold all of our device specific stuff */
Drop the comment.
Will do.
Quoted 4 lines
Quoted 1 line
+struct
cros_ec_usb{For readability, insert some blank lines in the struct.
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 54
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+/* the usb device for this device */ +struct usb_device *udev; +/* the interface for this device */ +struct usb_interface *interface; +/* Cros EC device structure */ +struct cros_ec_device *ec_dev;Maybe insert a blank line here.
Will do.
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c line 64
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+/* the buffer to receive data from bulk ep */ +u8 *bulk_in_buffer; +/* the buffer to receive data from int ep */ +u8 *int_in_buffer; +/* the urb to receive data from int ep */ +struct urb *int_in_urb; +/* the size of the receive buffer from bulk ep */ +size_t bulk_in_size; +/* the size of the receive buffer from int ep */ +size_t int_in_size;
Quoted 2 lines
Maybe insert a blank line here.
Will do.
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c line 72
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* the pipe of the bulk in ep */ +unsigned int bulk_in_pipe; +/* the pipe of the bulk out ep */ +unsigned int bulk_out_pipe; +/* the pipe of the int in ep */ +unsigned int int_in_pipe; +/* the interval of the int in ep */ +uint8_t int_in_interval;Maybe insert a blank line here.
Will do.
Quoted 3 lines
./scripts/checkpatch.pl --strictcomplains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
I'll change that.
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c line 89
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+struct int_msg { +uint8_t int_type; +} __packed;
./scripts/checkpatch.pl --strictcomplains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
I'll change that.
Quoted 4 lines
Quoted 1 line
+static void
cros_ec_int_callback(struct urb *urb);Move just right before
submit_int_urb()to make the intent more clear?
Make sense.
Quoted 7 lines
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+static int expected_response_size (const struct ec_host_response *host_response) +{ +/* Check host request version */ +if (host_response->struct_version !=3 ) +return 0 ; + +/* Reserved byte should be 0 */
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 112
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+if (host_response->reserved) +return 0 ; + +return sizeof (*host_response) + host_response->data_len; +}Wondering if the function really helps readability. Maybe just inline to
do_cros_ec_pkt_xfer_usb()?
Make sense.
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 118
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+static int cros_ec_usb_register (u16 idProduct,struct cros_ec_usb *ec_usb) +{ +struct registered_ec *ec; + + ec =kzalloc (sizeof (*ec),GFP_KERNEL );
kmalloc()should be sufficient. The member fields are going to be overridden anyway.
Make sense.
Quoted 7 lines
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+static int submit_int_urb (struct cros_ec_device *ec_dev) +{ +struct cros_ec_usb *ec_usb = ec_dev->priv; +struct usb_device *usb_dev =interface_to_usbdev (ec_usb->interface); +int ret; + +/* Submit the INT URB. */
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 159
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+usb_fill_int_urb (ec_usb->int_in_urb, usb_dev, ec_usb->int_in_pipe, + ec_usb->int_in_buffer, ec_usb->int_in_size, + cros_ec_int_callback, ec_usb, ec_usb->int_in_interval); + ret =usb_submit_urb (ec_usb->int_in_urb,GFP_KERNEL ); + +return ret;Eliminate the
ret. Just returnusb_submit_urb(...).
Will do.
Quoted 6 lines
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+static void cros_ec_int_callback (struct urb *urb) +{ +struct cros_ec_usb *ec_usb = urb->context; +struct cros_ec_device *ec_dev = ec_usb->ec_dev; +int ret; +
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 186
Quoted 6 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +5
-0+if (urb->actual_length >=sizeof (struct int_msg )) { +struct int_msg *int_msg = + (struct int_msg *)ec_usb->int_in_buffer; +enum cros_ec_usb_int_type int_type = + (enum cros_ec_usb_int_type )int_msg->int_type;Maybe insert a blank line here.
Will do.
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c line 197
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c +11
-0+switch (int_type) { +case INT_TYPE_EVENT_OCCURED : +if (ec_usb->registered) { + ec_dev->last_event_time =cros_ec_get_time_ns (); +schedule_work (&ec_usb->work_ec_evt); + } +break ; +case INT_TYPE_RESPONSE_READY : + ec_usb->resp_ready = true; +wake_up (&ec_usb->resp_ready_wait); +break ;
Quoted 3 lines
I'm wondering who fills the
int_type(i.e. 0 and 1) here? EC? If so, why aren't they incros_ec_command.h?
Yes, EC fills the int_type since it is the IN (from device to host) interrupt transfer.
It is not in the cros_ec_command.h file, because it is a part of the USB Host Command specification. Not related to EC itself or any command.
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 205
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+default : +dev_err (ec_dev->dev,"Unrecognized event: %d\n" , + int_type); + } + }else { +dev_err (ec_dev->dev,"Incorrect int transfer len: %d\n" , + urb->actual_length); + }
Quoted 3 lines
So in either cases, all of them need to resubmit the URB? Doesn't some of them just need to return?
Yes, we do always need to resubmit URB, otherwise the interface will be dysfunctional once any error happen
Quoted 13 lines
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+ +resubmit: +/* Resubmit the INT URB. */ + ret =submit_int_urb (ec_dev); +if (ret) +dev_err (ec_dev->dev,"Failed to resumbit int urb: %d" , ret); +} + +static int do_cros_ec_pkt_xfer_usb (struct cros_ec_device *ec_dev, +struct cros_ec_command *ec_msg) +{ +struct cros_ec_usb *ec_usb = ec_dev->priv; +struct ec_host_response *host_response;
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 223
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+int req_size, ret, actual_length, expected_resp_size, resp_size; +const int header_size =sizeof (*host_response); +const int max_resp_size = header_size + ec_msg->insize; +const int bulk_in_size =umin (ec_usb->bulk_in_size, ec_dev->din_size); +uint8_t sum =0 ;
./scripts/checkpatch.pl --strictcomplains about:
CHECK: Prefer kernel type 'u8' over 'uint8_t'
I'll change that
Quoted 15 lines
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+/* Get first part of response that contains a header. */ + ret = usb_bulk_msg(ec_usb->udev, ec_usb->bulk_in_pipe, ec_dev->din, + bulk_in_size, &actual_length,drivers/platform/chrome/cros_ec_usb.c line 281
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+ BULK_TRANSFER_TIMEOUT_MS); +if (ret) { +dev_err (ec_dev->dev,"Failed to get response: %d\n" , ret); + goto exit; + } + +/* Verify number of received bytes. */ +if (actual_length < header_size) { +dev_err (ec_dev->dev,"Received too little bytes: %d\n" , + actual_length);
Quoted 4 lines
Is it possible that the
actual_length < header_sizejust because it needs to further read? I.e. need a read loop for waiting EOF oractual_length >= header_size?
No, we assume that the EP size is at least header size, so the entire header has to be sent at once.
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c line 293
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c +12
-0+ ret = -ENOSPC ; + goto exit; + } + expected_resp_size = +expected_response_size ((struct ec_host_response *)ec_dev->din); +if ((expected_resp_size > max_resp_size) || (expected_resp_size ==0 ) || + (actual_length > expected_resp_size)) { +dev_err (ec_dev->dev,"Incorrect number of expected bytes: %d\n" , + expected_resp_size); + ret = -ENOSPC ; + goto exit; + }
Quoted 2 lines
Maybe insert a blank line here.
Will do.
Quoted 4 lines
Quoted 1 line
+
resp_size=actual_length;Move next to the following line of the comment.
Will do.
Quoted 14 lines
drivers/platform/chrome/cros_ec_usb.c line 307
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+/* Get the rest of the response if needed. */ +if (resp_size < expected_resp_size) { + ret =usb_bulk_msg (ec_usb->udev, ec_usb->bulk_in_pipe, + ec_dev->din + resp_size, + expected_resp_size - resp_size, + &actual_length,BULK_TRANSFER_TIMEOUT_MS ); +if (ret) { +dev_err (ec_dev->dev, +"Failed to get second part of response: %d\n" , + ret); + goto exit; + } + resp_size += actual_length;
Quoted 3 lines
Same here: doesn't it need a read loop for waiting EOF or
resp_size >= expected_resp_size?
No, we know exactly how many bytes are expected.
The usb_bulk_msg returns before receiving expected bytes only if there was a not max size transfer detected.
Quoted 15 lines
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+ } + +/* Check if number of received of bytes is correct. */ +if (resp_size != expected_resp_size) {drivers/platform/chrome/cros_ec_usb.c line 321
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+dev_err (ec_dev->dev, +"Received incorrect number of bytes: %d, expected: %d\n" , + resp_size, expected_resp_size); + ret = -ENOSPC ; + goto exit; + } + +/* Validate checksum */ + host_response = (struct ec_host_response *)ec_dev->din; + for (int i = 0; i < sizeof(*host_response) + host_response->data_len;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Quoted 2 lines
I.e.
expected_resp_size.
I'll change that.
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c line 324
Quoted 3 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+ i++) { + sum += ec_dev->din[i]; + }Drop the {} pair.
Will do.
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c line 333
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c +9
-0+if (sum) { +dev_err (ec_dev->dev,"Bad packet checksum calculated %x\n" , + sum); + ret = -EBADMSG ; + goto exit; + } + + ec_msg->result = host_response->result; + memcpy(ec_msg->data, ec_dev->din + sizeof(*host_response),
Quoted 2 lines
header_size==sizeof(*host_response). Either dropheader_sizeor use it.
Make sense.
Quoted 7 lines
Quoted 4 lines
+/**
+ *usb_evt_handler- USB to AP event handler
+ * @work: Work struct
+ */Maybe drop the comment?
Will do.
Quoted 4 lines
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+static int cros_ec_usb_probe (struct usb_interface *intf, +const struct usb_device_id *id) +{ +struct usb_device *usb_dev =interface_to_usbdev (intf);
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 382
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in; +struct device *if_dev = &intf->dev; +struct cros_ec_device *ec_dev; +const u16 idProduct = usb_dev->descriptor.idProduct; +struct cros_ec_usb *ec_usb =cros_ec_usb_get_registered (idProduct); +const bool is_registered = ec_usb !=NULL ;Or !!ec_usb.
I'll change that.
Quoted 14 lines
drivers/platform/chrome/cros_ec_usb.c line 395
Quoted 13 lines
drivers/platform/chrome/cros_ec_usb.c +13
-0+int retval; + +/* +* Do not register the same EC device twice. The probing is performed every +* reboot, sysjump, crash etc. Recreating the /dev/cros_X file every time +* would force all application to reopen the file, which is not a case for +* other cros_ec_x divers. Instead, keep the cros_ec_device and cros_ec_usb +* structures constant and replace USB related structures for the same EC +* that is reprobed. +* +* The driver doesn't support handling two devices with the same idProduct, +* but it will never be a real usecase. +*/
Quoted 4 lines
I don't quite understand why does it need to memorize the registered ECs. Supposedly, the probe function is only called few times during booting, and gets success once. Hot-plugs?
The probe is called every time the EC device boots from the beginning
- sysjumps, crashes, reboots etc. It succeeds the first time. Once the /dev/cros_X file is created, we need the possibility to access the same EC device, with the same, previously created file. The only way to do that is to reused the already created cros_ec_device structure.
Quoted 21 lines
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+if (!is_registered) + ec_usb =kzalloc (sizeof (*ec_usb),GFP_KERNEL ); + +if (!ec_usb) +return -ENOMEM ; + +if (!is_registered) {drivers/platform/chrome/cros_ec_usb.c line 412
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+mutex_init (&ec_usb->io_mutex); + ec_dev =kzalloc (sizeof (*ec_dev),GFP_KERNEL ); +if (!ec_dev) { + retval = -ENOMEM ; + goto error; + } + ec_usb->ec_dev = ec_dev; + }else { + ec_dev = ec_usb->ec_dev; + }The
!ec_usbcheck is only needed afterkzalloc(). Thus, the code block could be simplified to:
Quoted 13 lines
if (!is_registered) {
ec_usb = kzalloc(...);
if (!ec_usb)
return -ENOMEM
ec_dev = kzalloc(...);
/* initialized ec_usb and ec_dev */
mutex_init(...);
ec_usb->...
}
ec_dev = ec_usb->ec_dev;Make sense.
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c line 415
Quoted 3 lines
drivers/platform/chrome/cros_ec_usb.c +3
-0+ + ec_usb->udev =usb_get_dev (usb_dev); + ec_usb->interface =usb_get_intf (intf);Maybe insert a blank line here.
Will do.
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c line 423
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* Use first bulk-in/out endpoints + int-in endpoint */ + retval =usb_find_common_endpoints (intf->cur_altsetting, &bulk_in, + &bulk_out, &int_in,NULL ); +if (retval) { +dev_err (if_dev, +"Could not find bulk-in, bulk-out or int-in endpoint\n" ); + goto error; + }Maybe insert a blank line here.
Will do.
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c line 431
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+/* Bulk endpoints have to be capable of sending headers in one transfer. */ +if ((usb_endpoint_maxp (bulk_out) <sizeof (struct ec_host_request )) || + (usb_endpoint_maxp (bulk_in) <sizeof (struct ec_host_response )) || + (usb_endpoint_maxp (int_in)) <sizeof (struct int_msg )) { + retval = -ENOSPC ; +dev_err (if_dev,"Incorrect max packet size\n" ); + goto error; + }Maybe insert a blank line here.
Will do.
Quoted 12 lines
drivers/platform/chrome/cros_ec_usb.c line 442
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c +11
-0+ ec_usb->bulk_out_pipe = +usb_sndbulkpipe (ec_usb->udev, bulk_out->bEndpointAddress); + ec_usb->bulk_in_size =usb_endpoint_maxp (bulk_in); + ec_usb->bulk_in_pipe = +usb_rcvbulkpipe (ec_usb->udev, bulk_in->bEndpointAddress); + ec_usb->bulk_in_buffer =kmalloc (ec_usb->bulk_in_size,GFP_KERNEL ); +if (!ec_usb->bulk_in_buffer) { +dev_err (if_dev,"Failed to allocate bulk in buffer\n" ); + retval = -ENOMEM ; + goto error; + }
Quoted 2 lines
Maybe insert a blank line here.
Wll do.
Quoted 54 lines
Quoted 43 lines
drivers/platform/chrome/cros_ec_usb.c +43
-0+ ec_usb->int_in_size =usb_endpoint_maxp (int_in); + ec_usb->int_in_pipe = +usb_rcvintpipe (ec_usb->udev, int_in->bEndpointAddress); + ec_usb->int_in_interval = int_in->bInterval; + ec_usb->int_in_buffer =kmalloc (ec_usb->int_in_size,GFP_KERNEL ); +if (!ec_usb->int_in_buffer) { +dev_err (if_dev,"Failed to allocate int in buffer\n" ); + retval = -ENOMEM ; + goto error; + } + ec_usb->int_in_urb =usb_alloc_urb (0 ,GFP_KERNEL ); +if (!ec_usb->int_in_urb) { +dev_err (if_dev,"Failed to allocate int in urb\n" ); + retval = -ENOMEM ; + goto error; + } + + ec_dev->dev = if_dev; + ec_dev->phys_name =dev_name (if_dev); +if (!is_registered) { + ec_dev->priv = ec_usb; +/* EC uses int endpoint to signal events. */ + ec_dev->irq =0 ; + ec_dev->cmd_xfer =NULL ; + ec_dev->pkt_xfer = do_cros_ec_pkt_xfer_usb; + ec_dev->din_size =sizeof (struct ec_host_response ) + +sizeof (struct ec_response_get_protocol_info ); + ec_dev->dout_size =sizeof (struct ec_host_request ) + +sizeof (struct ec_params_rwsig_action ); +INIT_WORK (&ec_usb->work_ec_evt, usb_evt_handler); +init_waitqueue_head (&ec_usb->resp_ready_wait); + }else { +/* +* We need to allocate dout and din buffers, because cros_ec_register +* won't be called. These buffers were freed once previous usb device was +* disconnected. Use buffer sizes from the last query. +* The EC_HOST_EVENT_INTERFACE_READY event will be triggered at the end +* of a boot, which calls cros_ec_query_all function, that reallocates +* buffers. +*/ + ec_dev->din =devm_kzalloc (ec_dev->dev, ec_dev->din_size,GFP_KERNEL ); +if (!ec_dev->din) { + retval = -ENOMEM ;drivers/platform/chrome/cros_ec_usb.c line 495
Quoted 10 lines
drivers/platform/chrome/cros_ec_usb.c +10
-0+dev_err (if_dev,"Failed to allocate din buffer\n" ); + goto error; + } + ec_dev->dout =devm_kzalloc (ec_dev->dev, ec_dev->dout_size,GFP_KERNEL ); +if (!ec_dev->dout) { + retval = -ENOMEM ; +dev_err (if_dev,"Failed to allocate dout buffer\n" ); + goto error; + } + }
Quoted 3 lines
This whole block for initializing
ec_devcan be done earlier. See another!is_registeredabove.
Make sense to keep the code needed in !is_registered case together if it is possible. I'll change that.
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c line 497
Quoted 2 lines
drivers/platform/chrome/cros_ec_usb.c +2
-0+ +/* Needed by ec register function */ Drop the comment.
Will do.
Quoted 4 lines
Quoted 1 line
+
usb_set_intfdata(intf, ec_dev);This also can be done earlier when
ec_devis determined.
Will do.
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c line 502
Quoted 4 lines
drivers/platform/chrome/cros_ec_usb.c +4
-0+ +mutex_lock (&ec_usb->io_mutex); + ec_usb->disconnected = false; +mutex_unlock (&ec_usb->io_mutex);Wondering if it really needs to acquire the lock? Probe functions usually don't need to as there is no possible concurrent paths yet.
That would be true for the first probing. Following probings can happen when an ec device is already registered and
xfer function can be called during probing so I think it is more safe to synchronize access to the disconnect variable.
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c line 537
Quoted 4 lines
[...]
drivers/platform/chrome/cros_ec_usb.c +3
-0+error: +/* Free allocated memory */ +cros_ec_usb_delete (ec_usb);Be careful to make sure whether
cancel_work_sync()works even if&ec_usb->work_ec_evtis uninitialized.
Good catch! cancel_work_sync() can not be used before the work_ec_evt init
Quoted 8 lines
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+static void cros_ec_usb_disconnect (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +struct cros_ec_usb *ec_usb = ec_dev->priv; + +/* prevent more I/O from starting */ +mutex_lock (&ec_usb->io_mutex); + ec_usb->disconnected = true;
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 554
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+mutex_unlock (&ec_usb->io_mutex); + +cros_ec_usb_delete (ec_usb); + +dev_info (&intf->dev,"Disconnected\n" );This is the only
dev_info()in the various callbacks. Consider to drop it if it might not very useful.
I'll remove that, kernel default logs are sufficient.
Quoted 7 lines
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+static int cros_ec_usb_resume (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +int err; + +/* URB is killed during suspend. */ + err =submit_int_urb (ec_dev);
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 574
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+if (err) { +dev_err (ec_dev->dev, +"Failed to sumbit int urb after resume: %d\n" , err); + } + +return 0 ;Doesn't it need to return
err?
It needs, I'll change that.
Quoted 8 lines
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c +8
-0+static int cros_ec_usb_post_reset (struct usb_interface *intf) +{ +struct cros_ec_device *ec_dev =usb_get_intfdata (intf); +struct cros_ec_usb *ec_usb = ec_dev->priv; +int err; + + err =submit_int_urb (ec_dev); +if (err) {
Quoted 9 lines
drivers/platform/chrome/cros_ec_usb.c line 603
Quoted 6 lines
drivers/platform/chrome/cros_ec_usb.c +6
-0+dev_err (ec_dev->dev, +"Failed to sumbit int urb after reset: %d\n" , err); + } +mutex_unlock (&ec_usb->io_mutex); + +return 0 ;Doesn't it need to return
err?
It needs, I'll change that.
Quoted 7 lines
Quoted 7 lines
drivers/platform/chrome/cros_ec_usb.c +7
-0+static struct usb_driver cros_ec_usb = { + .name ="cros-ec-usb" , + .probe = cros_ec_usb_probe, + .disconnect = cros_ec_usb_disconnect, + .suspend = cros_ec_usb_suspend, + .resume = cros_ec_usb_resume, + .pre_reset = cros_ec_usb_pre_reset,
Quoted 8 lines
drivers/platform/chrome/cros_ec_usb.c line 617
Quoted 5 lines
drivers/platform/chrome/cros_ec_usb.c +5
-0+ .post_reset = cros_ec_usb_post_reset, + .id_table = cros_ec_usb_table, + /* Do not autosuspend EC */ + .supports_autosuspend = 0, +};Most .X callbacks are named
cros_ec_usb_X. Only the .id_table is different. To be neat, I'd suggest to usecros_ec_usb_id_table.
Make sense.
PATCH v2 1/1 platform/chrome: Add ChromeOS EC USB driver
Use USB to talk to the ChromeOS EC. The protocol is defined by the EC and is fairly simple, with a length byte, checksum, command byte and version byte in the header.
Use vendor defined usb interface with in/out endpoints to transfer requests and responses. Also use one interrupt in endpoint which signals readiness of response and pending events on the EC side.
---
V1 -> V2:
- Initialize work before potential cancel_work_sync call
- Return errors in .post_reset and .resume callbacks
- Inline expected_response_size function
- Use "imperative mood" in the commit message
- Use u8 instead of uin8_t
- Use 100 columns
- Add some blank line
- Move some code and functions
- Adjust function and variables names
- Some additional formatting
drivers/platform/chrome/Kconfig | 11 + drivers/platform/chrome/Makefile | 1 + drivers/platform/chrome/cros_ec_usb.c | 582 ++++++++++++++++++++++++++ 3 files changed, 594 insertions(+) create mode 100644 drivers/platform/chrome/cros_ec_usb.c
drivers/platform/chrome/Kconfig +11 -0
@@ -316,6 +316,17 @@ config CROS_TYPEC_SWITCH To compile this driver as a module, choose M here: the module will be called cros_typec_switch. +config CROS_EC_USB + tristate "ChromeOS Embedded Controller (USB)" + depends on CROS_EC && USB + help + If you say Y here, you get support for talking to the ChromeOS EC + through a USB. The driver uses vendor defined interface and is capable + of signaling events from EC. + + To compile this driver as a module, choose M here: the + module will be called cros_ec_usb. + source "drivers/platform/chrome/wilco_ec/Kconfig" # Kunit test cases
drivers/platform/chrome/Makefile +1 -0
@@ -38,6 +38,7 @@ obj-$(CONFIG_CROS_EC_SYSFS) += cros_ec_sysfs.o obj-$(CONFIG_CROS_HPS_I2C) += cros_hps_i2c.o obj-$(CONFIG_CROS_USBPD_LOGGER) += cros_usbpd_logger.o obj-$(CONFIG_CROS_USBPD_NOTIFY) += cros_usbpd_notify.o +obj-$(CONFIG_CROS_EC_USB) += cros_ec_usb.o obj-$(CONFIG_WILCO_EC) += wilco_ec/
drivers/platform/chrome/cros_ec_usb.c new file +582 -0
582 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Tzung-Bi Shih
maintainerQuoted 19 lines · Dawid Niedźwiecki
Quoted 13 lines · Tzung-Bi Shih
drivers/platform/chrome/cros_ec_usb.c line 395
Quoted 11 lines · Dawid Niedzwiecki
drivers/platform/chrome/cros_ec_usb.c new file +11
-0+/* +* Do not register the same EC device twice. The probing is performed every +* reboot, sysjump, crash etc. Recreating the /dev/cros_X file every time +* would force all application to reopen the file, which is not a case for +* other cros_ec_x divers. Instead, keep the cros_ec_device and cros_ec_usb +* structures constant and replace USB related structures for the same EC +* that is reprobed. +* +* The driver doesn't support handling two devices with the same idProduct, +* but it will never be a real usecase. +*/ Quoted 4 lines
I don't quite understand why does it need to memorize the registered ECs. Supposedly, the probe function is only called few times during booting, and gets success once. Hot-plugs?
Quoted 6 lines
The probe is called every time the EC device boots from the beginning
- sysjumps, crashes, reboots etc. It succeeds the first time. Once the/dev/cros_Xfile is created, we need the possibility to access the same EC device, with the same, previously created file. The only way to do that is to reused the already createdcros_ec_devicestructure.
What are the shortcomings if it re-creates /dev/cros_X everytime? Isn't it also a way for userland programs to be aware of the EC device crashes?
Why other cros_ec_X drivers doesn't need the mechanism?
Quoted 1 line
What are the shortcomings if it re-creates
/dev/cros_Xeverytime?
In that case, to avoid memory leakage, you would need to free the cros_ec_device structure every disconnect.
An application with an opened cros_ec file would try to access the freed resources (use-after-free) via the char driver [1], e.g.
It would also require additional work from the userspace application e.g. reopen the cros_ec file every time there was a communication problem. I think recovering an already created file sounds like a better idea.
Quoted 1 line
Isn't it also a way for userland programs to be aware of the EC device crashes?
No. First of all, we don't know a reason for the disconnect / reprobe, so it is not always a crash. Also we signal that there is a problem with the connection by returning -ENODEV when an EC device is disconnected.
There are dedicated commands to check reboot reason, and detect potential crashes.
Quoted 1 line
Why other
cros_ec_Xdrivers doesn't need the mechanism?
It is a very USB specific problem. USB host/hub detects a new device on the bus and starts probing procedure.
It is not a case for other drivers, e.g. SPI probes only once, at the beginning of the boot, based on ACPI entry, there is no hardware detection that a device is alive after reboot. Additionally, the USB related structures are new every probe, so we need to replace those.
Quoted 32 lines · Tzung-Bi Shih
Quoted 19 lines · Dawid Niedźwiecki
Quoted 13 lines · Tzung-Bi Shih
drivers/platform/chrome/cros_ec_usb.c line 395
Quoted 11 lines · Dawid Niedzwiecki
drivers/platform/chrome/cros_ec_usb.c new file +11
-0+/* +* Do not register the same EC device twice. The probing is performed every +* reboot, sysjump, crash etc. Recreating the /dev/cros_X file every time +* would force all application to reopen the file, which is not a case for +* other cros_ec_x divers. Instead, keep the cros_ec_device and cros_ec_usb +* structures constant and replace USB related structures for the same EC +* that is reprobed. +* +* The driver doesn't support handling two devices with the same idProduct, +* but it will never be a real usecase. +*/ Quoted 4 lines
I don't quite understand why does it need to memorize the registered ECs. Supposedly, the probe function is only called few times during booting, and gets success once. Hot-plugs?
Quoted 6 lines
The probe is called every time the EC device boots from the beginning
- sysjumps, crashes, reboots etc. It succeeds the first time. Once the/dev/cros_Xfile is created, we need the possibility to access the same EC device, with the same, previously created file. The only way to do that is to reused the already createdcros_ec_devicestructure.What are the shortcomings if it re-creates
/dev/cros_Xeverytime? Isn't it also a way for userland programs to be aware of the EC device crashes?Why other
cros_ec_Xdrivers doesn't need the mechanism?
Tzung-Bi Shih
maintainerQuoted 25 lines · Dawid Niedźwiecki
Quoted 1 line
What are the shortcomings if it re-creates
/dev/cros_Xeverytime?In that case, to avoid memory leakage, you would need to free the
cros_ec_devicestructure every disconnect.
An application with an openedcros_ecfile would try to access the freed resources (use-after-free) via the char driver [1], e.g.It would also require additional work from the userspace application e.g. reopen the
cros_ecfile every time there was a communication problem. I think recovering an already created file sounds like a better idea.Quoted 1 line
Isn't it also a way for userland programs to be aware of the EC device crashes?
No. First of all, we don't know a reason for the disconnect / reprobe, so it is not always a crash. Also we signal that there is a problem with the connection by returning
-ENODEVwhen an EC device is disconnected.
There are dedicated commands to check reboot reason, and detect potential crashes.Quoted 1 line
Why other
cros_ec_Xdrivers doesn't need the mechanism?
Quoted 7 lines
It is a very USB specific problem. USB host/hub detects a new device on the bus and starts probing procedure.
It is not a case for other drivers, e.g. SPI probes only once, at the beginning of the boot, based on ACPI entry, there is no hardware detection that a device is alive after reboot. Additionally, the USB related structures are new every probe, so we need to replace those.
Please don't top-posting [2]. The discussion thread is somehow messed.
Quoted 29 lines · Tzung-Bi Shih
Quoted 28 lines · Dawid Niedźwiecki
Quoted 25 lines · Tzung-Bi Shih
Quoted 13 lines · Dawid Niedzwiecki
drivers/platform/chrome/cros_ec_usb.c line 395
Quoted 11 lines
drivers/platform/chrome/cros_ec_usb.c new file +11
-0+/* +* Do not register the same EC device twice. The probing is performed every +* reboot, sysjump, crash etc. Recreating the /dev/cros_X file every time +* would force all application to reopen the file, which is not a case for +* other cros_ec_x divers. Instead, keep the cros_ec_device and cros_ec_usb +* structures constant and replace USB related structures for the same EC +* that is reprobed. +* +* The driver doesn't support handling two devices with the same idProduct, +* but it will never be a real usecase. +*/ Quoted 4 lines
I don't quite understand why does it need to memorize the registered ECs. Supposedly, the probe function is only called few times during booting, and gets success once. Hot-plugs?
The probe is called every time the EC device boots from the beginning
- sysjumps, crashes, reboots etc. It succeeds the first time. Once the/dev/cros_Xfile is created, we need the possibility to access the same EC device, with the same, previously created file. The only way to do that is to reused the already createdcros_ec_devicestructure.
Quoted 4 lines
Quoted 4 lines
What are the shortcomings if it re-creates
/dev/cros_Xeverytime? Isn't it also a way for userland programs to be aware of the EC device crashes?Why other
cros_ec_Xdrivers doesn't need the mechanism?
Copied your reply here:
Quoted 7 lines
Quoted 1 line
What are the shortcomings if it re-creates
/dev/cros_Xeverytime?In that case, to avoid memory leakage, you would need to free the
cros_ec_devicestructure every disconnect.
An application with an openedcros_ecfile would try to access the freed resources (use-after-free) via the char driver [1], e.g.
Quoted 6 lines
It would also require additional work from the userspace application e.g. reopen the
cros_ecfile every time there was a communication problem. I think recovering an already created file sounds like a better idea.
They doesn't look like shortcomings to me. The corresponding destructor callbacks have to be called when a device is removed anyway.
Instead, re-using the same inode for the userland interface however *silently* swapping the underlying devices makes less sense to me.
Quoted 8 lines
Quoted 1 line
Isn't it also a way for userland programs to be aware of the EC device crashes?
No. First of all, we don't know a reason for the disconnect / reprobe, so it is not always a crash. Also we signal that there is a problem with the connection by returning
-ENODEVwhen an EC device is disconnected.
There are dedicated commands to check reboot reason, and detect potential crashes.
My point here is: to let userland programs be aware of the underlying device has been removed.
What are the reasons for disconnect and reprobe? From your previous message and code comment, are they "reboot, sysjump, crash"? Would it happen frequently after AP boot?
Note: we are talking about a EC-like device here. For a real EC either reboot or crash, the AP will be reset.
Quoted 7 lines
Quoted 1 line
Why other
cros_ec_Xdrivers doesn't need the mechanism?It is a very USB specific problem. USB host/hub detects a new device on the bus and starts probing procedure.
It is not a case for other drivers, e.g. SPI probes only once, at the beginning of the boot, based on ACPI entry, there is no hardware detection that a device is alive after reboot.
No, I don't think so. I think all EC-like devices share the same concern regardless of the transport medium (e.g. SCP over RPMSG, ISH over ISHTP).
Quoted 3 lines
They doesn't look like shortcomings to me. The corresponding destructor callbacks have to be called when a device is removed anyway.
Yes, anything related to USB communication itself has to be freed, but freeing the cros_ec_device structure and calling the cros_ec_unregister function can crash the system if any of a userland application has the original file cros_ec open and tries to send a command. The chardev driver is not aware that the device has been removed and will try to access the removed structures.
Quoted 3 lines
Instead, re-using the same inode for the userland interface however *silently* swapping the underlying devices makes less sense to me.
We are sure it is the same EC device, so why do you think accessing the same inode makes less sense? It is a case for specific interface, that reboot causes reprobing, which is not a case for other interfaces. I believe it should be
transparent for the cros_ec device user, what interface type is used e.g. if it is
SPI, you can reboot the EC device and wait until it responds to a next command, but if it is USB, you would need to reopen the cros_ec file after reboot.
Quoted 3 lines
My point here is: to let userland programs be aware of the underlying device has been removed.
I got your point, but they are informed with a proper return code. The host command
communication doesn't have context. Every command is independent, so userland programs can not assume any state of the EC device e.g. reboot can happen. I think
behaviour of the cros_ec file is not a good way to inform the userland programs that
there were reboot, sysjump etc. There are special commands/events for that.
Quoted 4 lines
What are the reasons for disconnect and reprobe? From your previous message and code comment, are they "reboot, sysjump, crash"? Would it happen frequently after AP boot?
Yes, every boot "from the beginning" , including sysjumps. It depends on a EC device
type, but it can happen e.g. after AP reboot (RWSIG jumps to RW, it depends on boot time),
during firmware update procedure, rollback region update etc.
Quoted 2 lines
Note: we are talking about a EC-like device here. For a real EC either reboot or crash, the AP will be reset.
That's true. The problem doesn't exist for the real EC device.
Quoted 2 lines
No, I don't think so. I think all EC-like devices share the same concern regardless of the transport medium (e.g. SCP over RPMSG, ISH over ISHTP).
Yes, you can run a userland program that opens a cros_ec file and constantly sends commands e.g. ectool stress, and then manually unbind the ec device, but I believe it can cause some crashes/memory leakage. I don't think all drivers are adjusted to hot-plugging.
Tzung-Bi Shih
maintainerQuoted 10 lines · Dawid Niedźwiecki
Quoted 3 lines
They doesn't look like shortcomings to me. The corresponding destructor callbacks have to be called when a device is removed anyway.
Yes, anything related to USB communication itself has to be freed, but freeing the
cros_ec_devicestructure and calling thecros_ec_unregisterfunction can crash the system if any of a userland application has the original filecros_ecopen and tries to send a command. The chardev driver is not aware that the device has been removed and will try to access the removed structures.
We have seen a similar crash before but I didn't come out with a solution at that time. Could you please try [3]?
[3]: https://patchwork.kernel.org/project/chrome-platform/cover/[email protected]/
Quoted 4 lines
Quoted 3 lines
Instead, re-using the same inode for the userland interface however *silently* swapping the underlying devices makes less sense to me.
Quoted 8 lines
We are sure it is the same EC device, so why do you think accessing the same inode makes less sense? It is a case for specific interface, that reboot causes reprobing, which is not a case for other interfaces. I believe it should be
transparent for thecros_ecdevice user, what interface type is used e.g. if it is
SPI, you can reboot the EC device and wait until it responds to a next command, but if it is USB, you would need to reopen thecros_ecfile after reboot.
Did some experiments and I understand the difference now. It probably depends on the bus implementation.
1) SCP over RPMSG
# ectool --name=cros_scp reboot_ec # dmesg cros-ec-rpmsg 10500000.scp.cros-ec-rpmsg.13.-1: rpmsg send timeout mtk-scp 10500000.scp: SCP watchdog timeout! 0x0 remoteproc remoteproc0: crash detected in scp: type watchdog ... cros-ec-rpmsg 10500000.scp.cros-ec-rpmsg.13.-1: Chrome EC device registered
2) FP over SPI
# ectool --name=cros_fp reboot_ec # dmesg cros-ec-spi spi-PRP0001:01: EC failed to respond in time
Anyway, I see your point about the EC over USB gets re-probe once it reboots, sysjumps, crashes, firmware updates, and etc.
Given that:
- The crash you encountered is a common issue for all cros_ec_X drivers.
- I prefer to keep cros_ec_X drivers simple and similar rather than have something special (e.g. the memorized struct cros_ec_device in current cros_ec_usb) for fixing the crash.
Could you give [3] a try to see if it fixes the crash and also call cros_ec_register()/cros_ec_unregister() everytime in the probe/disconnect?
Quoted 7 lines
Quoted 2 lines
No, I don't think so. I think all EC-like devices share the same concern regardless of the transport medium (e.g. SCP over RPMSG, ISH over ISHTP).
Yes, you can run a userland program that opens a
cros_ecfile and constantly sends commands e.g. ectool stress, and then manually unbind the ec device, but I believe it can cause some crashes/memory leakage. I don't think all drivers are adjusted to hot-plugging.
Yes, we have seen a similar crash before. See comment above.
Quoted 5 lines
We have seen a similar crash before but I didn't come out with a solution at that time. Could you please try [3]?
[3]: https://patchwork.kernel.org/project/chrome-platform/cover/[email protected]/
Sure, I'll try the fix once it gets its final shape.
Quoted 7 lines
Given that:
- The crash you encountered is a common issue for allcros_ec_Xdrivers.
- I prefer to keepcros_ec_Xdrivers simple and similar rather than have something special (e.g. the memorizedstruct cros_ec_devicein currentcros_ec_usb) for fixing the crash.
Could you give [3] a try to see if it fixes the crash and also call cros_ec_register()/cros_ec_unregister() everytime in the probe/disconnect?
I agree that the drivers should be simple and similar as much as possible. But to be precise, I think, it should behave in a similar way as much as possible
(e.g. reboot EC device doesn't cause re-registering), not be implemented in the same way. That's why I believe the current implementation of the drivers follows the already present drivers in a better way.
The specification of a certain interface influences the driver implementation a lot.
E.g. the SPI driver never frees the cros_ec_device struct [1], because it is very rare
that the driver is removed and reprobed (only manual unbind/bind). I believe the SPI device structure is constant in the system. On the other hand, the USB device
structures are recreated every unplug/plug (reboot, sysjump etc. in this case), so
this approach is unacceptable.
Tzung-Bi Shih
maintainerQuoted 8 lines · Dawid Niedźwiecki
Quoted 7 lines
Given that:
- The crash you encountered is a common issue for allcros_ec_Xdrivers.
- I prefer to keepcros_ec_Xdrivers simple and similar rather than have something special (e.g. the memorizedstruct cros_ec_devicein currentcros_ec_usb) for fixing the crash.
Could you give [3] a try to see if it fixes the crash and also call cros_ec_register()/cros_ec_unregister() everytime in the probe/disconnect?
Quoted 6 lines
I agree that the drivers should be simple and similar as much as possible. But to be precise, I think, it should behave in a similar way as much as possible
(e.g. reboot EC device doesn't cause re-registering), not be implemented in the same way. That's why I believe the current implementation of the drivers follows the already present drivers in a better way.
FWIW: It depends on the bus details. If you find my previous message, SCP over RPMSG also re-registers everytime after the firmware reboot.
One challenge for current version: it makes the driver more complicated than others. E.g. what would be happening if some friend drivers try to access ec_dev while the cros_ec_usb_probe is writing to ec_usb at a time? It tries to manage the device's lifecycle one level upper than USB (don't know what it should call, "session"?).
Another challenge: it doesn't call cros_ec_unregister() in its driver removal entry. What would be happening if someone re-inserts the module multiple times?
Resending due to HTML incident
Quoted 2 lines
FWIW: It depends on the bus details. If you find my previous message, SCP over RPMSG also re-registers everytime after the firmware reboot.
You are right. But I'm not sure if it is a good approach. My understanding is that the HAL/API should behave the same way, regardless of what interface is behind.
Quoted 5 lines
One challenge for current version: it makes the driver more complicated than others. E.g. what would be happening if some friend drivers try to access
ec_devwhile thecros_ec_usb_probeis writing toec_usbat a time? It tries to manage the device's lifecycle one level upper than USB (don't know what it should call, "session"?).
Yes, the more complicated driver is for sure not a good thing.
In that case, it shouldn't cause anything wrong. The disconnect field is set to false once everything is ready. Before that, there are no transfers handled.
Quoted 3 lines
Another challenge: it doesn't call
cros_ec_unregister()in its driver removal entry. What would be happening if someone re-inserts the module multiple times?
That's the same case as reboot/sysjump. We would get the probe callback, the driver would notice (by Product ID) that this EC device has been already registered and would replace the USB related structures in the cros_ec_usb structure and the same cros_X file would start working again.