xref: /linux/drivers/usb/misc/usb-ljca.c (revision 7ec462100ef9142344ddbf86f2c3008b97acddbe)
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 
ljca_handle_event(struct ljca_adapter * adap,struct ljca_msg * header)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 */
ljca_handle_cmd_ack(struct ljca_adapter * adap,struct ljca_msg * header)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 
ljca_recv(struct urb * urb)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 
ljca_send(struct ljca_adapter * adap,u8 type,u8 cmd,const u8 * obuf,u8 obuf_len,u8 * ibuf,u8 ibuf_len,bool ack,unsigned long timeout)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 
336 	usb_autopm_put_interface(adap->intf);
337 
338 	if (ret < 0)
339 		goto out;
340 	if (transferred != msg_len) {
341 		ret = -EIO;
342 		goto out;
343 	}
344 
345 	if (ack) {
346 		ret = wait_for_completion_timeout(&adap->cmd_completion,
347 						  timeout);
348 		if (!ret) {
349 			ret = -ETIMEDOUT;
350 			goto out;
351 		}
352 	}
353 	ret = adap->actual_length;
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 
ljca_transfer(struct ljca_client * client,u8 cmd,const u8 * obuf,u8 obuf_len,u8 * ibuf,u8 ibuf_len)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 
ljca_transfer_noack(struct ljca_client * client,u8 cmd,const u8 * obuf,u8 obuf_len)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 
ljca_register_event_cb(struct ljca_client * client,ljca_event_cb_t event_cb,void * context)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 
ljca_unregister_event_cb(struct ljca_client * client)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 
ljca_match_device_ids(struct acpi_device * adev,void * data)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 */
ljca_auxdev_acpi_bind(struct ljca_adapter * adap,struct auxiliary_device * auxdev,u64 adr,u8 id)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 
ljca_auxdev_release(struct device * dev)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 
ljca_new_client_device(struct ljca_adapter * adap,u8 type,u8 id,char * name,void * data,u64 adr)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 
ljca_enumerate_gpio(struct ljca_adapter * adap)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 
ljca_enumerate_i2c(struct ljca_adapter * adap)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 
ljca_enumerate_spi(struct ljca_adapter * adap)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 
ljca_reset_handshake(struct ljca_adapter * adap)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 
ljca_enumerate_clients(struct ljca_adapter * adap)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 
ljca_probe(struct usb_interface * interface,const struct usb_device_id * id)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 	usb_enable_autosuspend(usb_dev);
815 
816 	return 0;
817 
818 err_free:
819 	usb_free_urb(adap->rx_urb);
820 
821 err_put:
822 	usb_put_intf(adap->intf);
823 
824 	mutex_destroy(&adap->mutex);
825 
826 	return ret;
827 }
828 
ljca_disconnect(struct usb_interface * interface)829 static void ljca_disconnect(struct usb_interface *interface)
830 {
831 	struct ljca_adapter *adap = usb_get_intfdata(interface);
832 	struct ljca_client *client, *next;
833 
834 	adap->disconnect = true;
835 
836 	usb_kill_urb(adap->rx_urb);
837 
838 	list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) {
839 		auxiliary_device_delete(&client->auxdev);
840 		auxiliary_device_uninit(&client->auxdev);
841 
842 		list_del_init(&client->link);
843 		kfree(client);
844 	}
845 
846 	usb_free_urb(adap->rx_urb);
847 
848 	usb_put_intf(adap->intf);
849 
850 	mutex_destroy(&adap->mutex);
851 }
852 
ljca_suspend(struct usb_interface * interface,pm_message_t message)853 static int ljca_suspend(struct usb_interface *interface, pm_message_t message)
854 {
855 	struct ljca_adapter *adap = usb_get_intfdata(interface);
856 
857 	usb_kill_urb(adap->rx_urb);
858 
859 	return 0;
860 }
861 
ljca_resume(struct usb_interface * interface)862 static int ljca_resume(struct usb_interface *interface)
863 {
864 	struct ljca_adapter *adap = usb_get_intfdata(interface);
865 
866 	return usb_submit_urb(adap->rx_urb, GFP_KERNEL);
867 }
868 
869 static const struct usb_device_id ljca_table[] = {
870 	{ USB_DEVICE(0x8086, 0x0b63) },
871 	{ /* sentinel */ }
872 };
873 MODULE_DEVICE_TABLE(usb, ljca_table);
874 
875 static struct usb_driver ljca_driver = {
876 	.name = "ljca",
877 	.id_table = ljca_table,
878 	.probe = ljca_probe,
879 	.disconnect = ljca_disconnect,
880 	.suspend = ljca_suspend,
881 	.resume = ljca_resume,
882 	.supports_autosuspend = 1,
883 };
884 module_usb_driver(ljca_driver);
885 
886 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>");
887 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
888 MODULE_AUTHOR("Lixu Zhang <lixu.zhang@intel.com>");
889 MODULE_DESCRIPTION("Intel La Jolla Cove Adapter USB driver");
890 MODULE_LICENSE("GPL");
891