xref: /openbmc/linux/drivers/input/misc/ims-pcu.c (revision b34e08d5)
1 /*
2  * Driver for IMS Passenger Control Unit Devices
3  *
4  * Copyright (C) 2013 The IMS Company
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2
8  * as published by the Free Software Foundation.
9  */
10 
11 #include <linux/completion.h>
12 #include <linux/device.h>
13 #include <linux/firmware.h>
14 #include <linux/ihex.h>
15 #include <linux/input.h>
16 #include <linux/kernel.h>
17 #include <linux/leds.h>
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/types.h>
21 #include <linux/usb/input.h>
22 #include <linux/usb/cdc.h>
23 #include <asm/unaligned.h>
24 
25 #define IMS_PCU_KEYMAP_LEN		32
26 
27 struct ims_pcu_buttons {
28 	struct input_dev *input;
29 	char name[32];
30 	char phys[32];
31 	unsigned short keymap[IMS_PCU_KEYMAP_LEN];
32 };
33 
34 struct ims_pcu_gamepad {
35 	struct input_dev *input;
36 	char name[32];
37 	char phys[32];
38 };
39 
40 struct ims_pcu_backlight {
41 	struct led_classdev cdev;
42 	struct work_struct work;
43 	enum led_brightness desired_brightness;
44 	char name[32];
45 };
46 
47 #define IMS_PCU_PART_NUMBER_LEN		15
48 #define IMS_PCU_SERIAL_NUMBER_LEN	8
49 #define IMS_PCU_DOM_LEN			8
50 #define IMS_PCU_FW_VERSION_LEN		(9 + 1)
51 #define IMS_PCU_BL_VERSION_LEN		(9 + 1)
52 #define IMS_PCU_BL_RESET_REASON_LEN	(2 + 1)
53 
54 #define IMS_PCU_PCU_B_DEVICE_ID		5
55 
56 #define IMS_PCU_BUF_SIZE		128
57 
58 struct ims_pcu {
59 	struct usb_device *udev;
60 	struct device *dev; /* control interface's device, used for logging */
61 
62 	unsigned int device_no;
63 
64 	bool bootloader_mode;
65 
66 	char part_number[IMS_PCU_PART_NUMBER_LEN];
67 	char serial_number[IMS_PCU_SERIAL_NUMBER_LEN];
68 	char date_of_manufacturing[IMS_PCU_DOM_LEN];
69 	char fw_version[IMS_PCU_FW_VERSION_LEN];
70 	char bl_version[IMS_PCU_BL_VERSION_LEN];
71 	char reset_reason[IMS_PCU_BL_RESET_REASON_LEN];
72 	int update_firmware_status;
73 	u8 device_id;
74 
75 	u8 ofn_reg_addr;
76 
77 	struct usb_interface *ctrl_intf;
78 
79 	struct usb_endpoint_descriptor *ep_ctrl;
80 	struct urb *urb_ctrl;
81 	u8 *urb_ctrl_buf;
82 	dma_addr_t ctrl_dma;
83 	size_t max_ctrl_size;
84 
85 	struct usb_interface *data_intf;
86 
87 	struct usb_endpoint_descriptor *ep_in;
88 	struct urb *urb_in;
89 	u8 *urb_in_buf;
90 	dma_addr_t read_dma;
91 	size_t max_in_size;
92 
93 	struct usb_endpoint_descriptor *ep_out;
94 	u8 *urb_out_buf;
95 	size_t max_out_size;
96 
97 	u8 read_buf[IMS_PCU_BUF_SIZE];
98 	u8 read_pos;
99 	u8 check_sum;
100 	bool have_stx;
101 	bool have_dle;
102 
103 	u8 cmd_buf[IMS_PCU_BUF_SIZE];
104 	u8 ack_id;
105 	u8 expected_response;
106 	u8 cmd_buf_len;
107 	struct completion cmd_done;
108 	struct mutex cmd_mutex;
109 
110 	u32 fw_start_addr;
111 	u32 fw_end_addr;
112 	struct completion async_firmware_done;
113 
114 	struct ims_pcu_buttons buttons;
115 	struct ims_pcu_gamepad *gamepad;
116 	struct ims_pcu_backlight backlight;
117 
118 	bool setup_complete; /* Input and LED devices have been created */
119 };
120 
121 
122 /*********************************************************************
123  *             Buttons Input device support                          *
124  *********************************************************************/
125 
126 static const unsigned short ims_pcu_keymap_1[] = {
127 	[1] = KEY_ATTENDANT_OFF,
128 	[2] = KEY_ATTENDANT_ON,
129 	[3] = KEY_LIGHTS_TOGGLE,
130 	[4] = KEY_VOLUMEUP,
131 	[5] = KEY_VOLUMEDOWN,
132 	[6] = KEY_INFO,
133 };
134 
135 static const unsigned short ims_pcu_keymap_2[] = {
136 	[4] = KEY_VOLUMEUP,
137 	[5] = KEY_VOLUMEDOWN,
138 	[6] = KEY_INFO,
139 };
140 
141 static const unsigned short ims_pcu_keymap_3[] = {
142 	[1] = KEY_HOMEPAGE,
143 	[2] = KEY_ATTENDANT_TOGGLE,
144 	[3] = KEY_LIGHTS_TOGGLE,
145 	[4] = KEY_VOLUMEUP,
146 	[5] = KEY_VOLUMEDOWN,
147 	[6] = KEY_DISPLAYTOGGLE,
148 	[18] = KEY_PLAYPAUSE,
149 };
150 
151 static const unsigned short ims_pcu_keymap_4[] = {
152 	[1] = KEY_ATTENDANT_OFF,
153 	[2] = KEY_ATTENDANT_ON,
154 	[3] = KEY_LIGHTS_TOGGLE,
155 	[4] = KEY_VOLUMEUP,
156 	[5] = KEY_VOLUMEDOWN,
157 	[6] = KEY_INFO,
158 	[18] = KEY_PLAYPAUSE,
159 };
160 
161 static const unsigned short ims_pcu_keymap_5[] = {
162 	[1] = KEY_ATTENDANT_OFF,
163 	[2] = KEY_ATTENDANT_ON,
164 	[3] = KEY_LIGHTS_TOGGLE,
165 };
166 
167 struct ims_pcu_device_info {
168 	const unsigned short *keymap;
169 	size_t keymap_len;
170 	bool has_gamepad;
171 };
172 
173 #define IMS_PCU_DEVINFO(_n, _gamepad)				\
174 	[_n] = {						\
175 		.keymap = ims_pcu_keymap_##_n,			\
176 		.keymap_len = ARRAY_SIZE(ims_pcu_keymap_##_n),	\
177 		.has_gamepad = _gamepad,			\
178 	}
179 
180 static const struct ims_pcu_device_info ims_pcu_device_info[] = {
181 	IMS_PCU_DEVINFO(1, true),
182 	IMS_PCU_DEVINFO(2, true),
183 	IMS_PCU_DEVINFO(3, true),
184 	IMS_PCU_DEVINFO(4, true),
185 	IMS_PCU_DEVINFO(5, false),
186 };
187 
188 static void ims_pcu_buttons_report(struct ims_pcu *pcu, u32 data)
189 {
190 	struct ims_pcu_buttons *buttons = &pcu->buttons;
191 	struct input_dev *input = buttons->input;
192 	int i;
193 
194 	for (i = 0; i < 32; i++) {
195 		unsigned short keycode = buttons->keymap[i];
196 
197 		if (keycode != KEY_RESERVED)
198 			input_report_key(input, keycode, data & (1UL << i));
199 	}
200 
201 	input_sync(input);
202 }
203 
204 static int ims_pcu_setup_buttons(struct ims_pcu *pcu,
205 				 const unsigned short *keymap,
206 				 size_t keymap_len)
207 {
208 	struct ims_pcu_buttons *buttons = &pcu->buttons;
209 	struct input_dev *input;
210 	int i;
211 	int error;
212 
213 	input = input_allocate_device();
214 	if (!input) {
215 		dev_err(pcu->dev,
216 			"Not enough memory for input input device\n");
217 		return -ENOMEM;
218 	}
219 
220 	snprintf(buttons->name, sizeof(buttons->name),
221 		 "IMS PCU#%d Button Interface", pcu->device_no);
222 
223 	usb_make_path(pcu->udev, buttons->phys, sizeof(buttons->phys));
224 	strlcat(buttons->phys, "/input0", sizeof(buttons->phys));
225 
226 	memcpy(buttons->keymap, keymap, sizeof(*keymap) * keymap_len);
227 
228 	input->name = buttons->name;
229 	input->phys = buttons->phys;
230 	usb_to_input_id(pcu->udev, &input->id);
231 	input->dev.parent = &pcu->ctrl_intf->dev;
232 
233 	input->keycode = buttons->keymap;
234 	input->keycodemax = ARRAY_SIZE(buttons->keymap);
235 	input->keycodesize = sizeof(buttons->keymap[0]);
236 
237 	__set_bit(EV_KEY, input->evbit);
238 	for (i = 0; i < IMS_PCU_KEYMAP_LEN; i++)
239 		__set_bit(buttons->keymap[i], input->keybit);
240 	__clear_bit(KEY_RESERVED, input->keybit);
241 
242 	error = input_register_device(input);
243 	if (error) {
244 		dev_err(pcu->dev,
245 			"Failed to register buttons input device: %d\n",
246 			error);
247 		input_free_device(input);
248 		return error;
249 	}
250 
251 	buttons->input = input;
252 	return 0;
253 }
254 
255 static void ims_pcu_destroy_buttons(struct ims_pcu *pcu)
256 {
257 	struct ims_pcu_buttons *buttons = &pcu->buttons;
258 
259 	input_unregister_device(buttons->input);
260 }
261 
262 
263 /*********************************************************************
264  *             Gamepad Input device support                          *
265  *********************************************************************/
266 
267 static void ims_pcu_gamepad_report(struct ims_pcu *pcu, u32 data)
268 {
269 	struct ims_pcu_gamepad *gamepad = pcu->gamepad;
270 	struct input_dev *input = gamepad->input;
271 	int x, y;
272 
273 	x = !!(data & (1 << 14)) - !!(data & (1 << 13));
274 	y = !!(data & (1 << 12)) - !!(data & (1 << 11));
275 
276 	input_report_abs(input, ABS_X, x);
277 	input_report_abs(input, ABS_Y, y);
278 
279 	input_report_key(input, BTN_A, data & (1 << 7));
280 	input_report_key(input, BTN_B, data & (1 << 8));
281 	input_report_key(input, BTN_X, data & (1 << 9));
282 	input_report_key(input, BTN_Y, data & (1 << 10));
283 	input_report_key(input, BTN_START, data & (1 << 15));
284 	input_report_key(input, BTN_SELECT, data & (1 << 16));
285 
286 	input_sync(input);
287 }
288 
289 static int ims_pcu_setup_gamepad(struct ims_pcu *pcu)
290 {
291 	struct ims_pcu_gamepad *gamepad;
292 	struct input_dev *input;
293 	int error;
294 
295 	gamepad = kzalloc(sizeof(struct ims_pcu_gamepad), GFP_KERNEL);
296 	input = input_allocate_device();
297 	if (!gamepad || !input) {
298 		dev_err(pcu->dev,
299 			"Not enough memory for gamepad device\n");
300 		error = -ENOMEM;
301 		goto err_free_mem;
302 	}
303 
304 	gamepad->input = input;
305 
306 	snprintf(gamepad->name, sizeof(gamepad->name),
307 		 "IMS PCU#%d Gamepad Interface", pcu->device_no);
308 
309 	usb_make_path(pcu->udev, gamepad->phys, sizeof(gamepad->phys));
310 	strlcat(gamepad->phys, "/input1", sizeof(gamepad->phys));
311 
312 	input->name = gamepad->name;
313 	input->phys = gamepad->phys;
314 	usb_to_input_id(pcu->udev, &input->id);
315 	input->dev.parent = &pcu->ctrl_intf->dev;
316 
317 	__set_bit(EV_KEY, input->evbit);
318 	__set_bit(BTN_A, input->keybit);
319 	__set_bit(BTN_B, input->keybit);
320 	__set_bit(BTN_X, input->keybit);
321 	__set_bit(BTN_Y, input->keybit);
322 	__set_bit(BTN_START, input->keybit);
323 	__set_bit(BTN_SELECT, input->keybit);
324 
325 	__set_bit(EV_ABS, input->evbit);
326 	input_set_abs_params(input, ABS_X, -1, 1, 0, 0);
327 	input_set_abs_params(input, ABS_Y, -1, 1, 0, 0);
328 
329 	error = input_register_device(input);
330 	if (error) {
331 		dev_err(pcu->dev,
332 			"Failed to register gamepad input device: %d\n",
333 			error);
334 		goto err_free_mem;
335 	}
336 
337 	pcu->gamepad = gamepad;
338 	return 0;
339 
340 err_free_mem:
341 	input_free_device(input);
342 	kfree(gamepad);
343 	return -ENOMEM;
344 }
345 
346 static void ims_pcu_destroy_gamepad(struct ims_pcu *pcu)
347 {
348 	struct ims_pcu_gamepad *gamepad = pcu->gamepad;
349 
350 	input_unregister_device(gamepad->input);
351 	kfree(gamepad);
352 }
353 
354 
355 /*********************************************************************
356  *             PCU Communication protocol handling                   *
357  *********************************************************************/
358 
359 #define IMS_PCU_PROTOCOL_STX		0x02
360 #define IMS_PCU_PROTOCOL_ETX		0x03
361 #define IMS_PCU_PROTOCOL_DLE		0x10
362 
363 /* PCU commands */
364 #define IMS_PCU_CMD_STATUS		0xa0
365 #define IMS_PCU_CMD_PCU_RESET		0xa1
366 #define IMS_PCU_CMD_RESET_REASON	0xa2
367 #define IMS_PCU_CMD_SEND_BUTTONS	0xa3
368 #define IMS_PCU_CMD_JUMP_TO_BTLDR	0xa4
369 #define IMS_PCU_CMD_GET_INFO		0xa5
370 #define IMS_PCU_CMD_SET_BRIGHTNESS	0xa6
371 #define IMS_PCU_CMD_EEPROM		0xa7
372 #define IMS_PCU_CMD_GET_FW_VERSION	0xa8
373 #define IMS_PCU_CMD_GET_BL_VERSION	0xa9
374 #define IMS_PCU_CMD_SET_INFO		0xab
375 #define IMS_PCU_CMD_GET_BRIGHTNESS	0xac
376 #define IMS_PCU_CMD_GET_DEVICE_ID	0xae
377 #define IMS_PCU_CMD_SPECIAL_INFO	0xb0
378 #define IMS_PCU_CMD_BOOTLOADER		0xb1	/* Pass data to bootloader */
379 #define IMS_PCU_CMD_OFN_SET_CONFIG	0xb3
380 #define IMS_PCU_CMD_OFN_GET_CONFIG	0xb4
381 
382 /* PCU responses */
383 #define IMS_PCU_RSP_STATUS		0xc0
384 #define IMS_PCU_RSP_PCU_RESET		0	/* Originally 0xc1 */
385 #define IMS_PCU_RSP_RESET_REASON	0xc2
386 #define IMS_PCU_RSP_SEND_BUTTONS	0xc3
387 #define IMS_PCU_RSP_JUMP_TO_BTLDR	0	/* Originally 0xc4 */
388 #define IMS_PCU_RSP_GET_INFO		0xc5
389 #define IMS_PCU_RSP_SET_BRIGHTNESS	0xc6
390 #define IMS_PCU_RSP_EEPROM		0xc7
391 #define IMS_PCU_RSP_GET_FW_VERSION	0xc8
392 #define IMS_PCU_RSP_GET_BL_VERSION	0xc9
393 #define IMS_PCU_RSP_SET_INFO		0xcb
394 #define IMS_PCU_RSP_GET_BRIGHTNESS	0xcc
395 #define IMS_PCU_RSP_CMD_INVALID		0xcd
396 #define IMS_PCU_RSP_GET_DEVICE_ID	0xce
397 #define IMS_PCU_RSP_SPECIAL_INFO	0xd0
398 #define IMS_PCU_RSP_BOOTLOADER		0xd1	/* Bootloader response */
399 #define IMS_PCU_RSP_OFN_SET_CONFIG	0xd2
400 #define IMS_PCU_RSP_OFN_GET_CONFIG	0xd3
401 
402 
403 #define IMS_PCU_RSP_EVNT_BUTTONS	0xe0	/* Unsolicited, button state */
404 #define IMS_PCU_GAMEPAD_MASK		0x0001ff80UL	/* Bits 7 through 16 */
405 
406 
407 #define IMS_PCU_MIN_PACKET_LEN		3
408 #define IMS_PCU_DATA_OFFSET		2
409 
410 #define IMS_PCU_CMD_WRITE_TIMEOUT	100 /* msec */
411 #define IMS_PCU_CMD_RESPONSE_TIMEOUT	500 /* msec */
412 
413 static void ims_pcu_report_events(struct ims_pcu *pcu)
414 {
415 	u32 data = get_unaligned_be32(&pcu->read_buf[3]);
416 
417 	ims_pcu_buttons_report(pcu, data & ~IMS_PCU_GAMEPAD_MASK);
418 	if (pcu->gamepad)
419 		ims_pcu_gamepad_report(pcu, data);
420 }
421 
422 static void ims_pcu_handle_response(struct ims_pcu *pcu)
423 {
424 	switch (pcu->read_buf[0]) {
425 	case IMS_PCU_RSP_EVNT_BUTTONS:
426 		if (likely(pcu->setup_complete))
427 			ims_pcu_report_events(pcu);
428 		break;
429 
430 	default:
431 		/*
432 		 * See if we got command completion.
433 		 * If both the sequence and response code match save
434 		 * the data and signal completion.
435 		 */
436 		if (pcu->read_buf[0] == pcu->expected_response &&
437 		    pcu->read_buf[1] == pcu->ack_id - 1) {
438 
439 			memcpy(pcu->cmd_buf, pcu->read_buf, pcu->read_pos);
440 			pcu->cmd_buf_len = pcu->read_pos;
441 			complete(&pcu->cmd_done);
442 		}
443 		break;
444 	}
445 }
446 
447 static void ims_pcu_process_data(struct ims_pcu *pcu, struct urb *urb)
448 {
449 	int i;
450 
451 	for (i = 0; i < urb->actual_length; i++) {
452 		u8 data = pcu->urb_in_buf[i];
453 
454 		/* Skip everything until we get Start Xmit */
455 		if (!pcu->have_stx && data != IMS_PCU_PROTOCOL_STX)
456 			continue;
457 
458 		if (pcu->have_dle) {
459 			pcu->have_dle = false;
460 			pcu->read_buf[pcu->read_pos++] = data;
461 			pcu->check_sum += data;
462 			continue;
463 		}
464 
465 		switch (data) {
466 		case IMS_PCU_PROTOCOL_STX:
467 			if (pcu->have_stx)
468 				dev_warn(pcu->dev,
469 					 "Unexpected STX at byte %d, discarding old data\n",
470 					 pcu->read_pos);
471 			pcu->have_stx = true;
472 			pcu->have_dle = false;
473 			pcu->read_pos = 0;
474 			pcu->check_sum = 0;
475 			break;
476 
477 		case IMS_PCU_PROTOCOL_DLE:
478 			pcu->have_dle = true;
479 			break;
480 
481 		case IMS_PCU_PROTOCOL_ETX:
482 			if (pcu->read_pos < IMS_PCU_MIN_PACKET_LEN) {
483 				dev_warn(pcu->dev,
484 					 "Short packet received (%d bytes), ignoring\n",
485 					 pcu->read_pos);
486 			} else if (pcu->check_sum != 0) {
487 				dev_warn(pcu->dev,
488 					 "Invalid checksum in packet (%d bytes), ignoring\n",
489 					 pcu->read_pos);
490 			} else {
491 				ims_pcu_handle_response(pcu);
492 			}
493 
494 			pcu->have_stx = false;
495 			pcu->have_dle = false;
496 			pcu->read_pos = 0;
497 			break;
498 
499 		default:
500 			pcu->read_buf[pcu->read_pos++] = data;
501 			pcu->check_sum += data;
502 			break;
503 		}
504 	}
505 }
506 
507 static bool ims_pcu_byte_needs_escape(u8 byte)
508 {
509 	return byte == IMS_PCU_PROTOCOL_STX ||
510 	       byte == IMS_PCU_PROTOCOL_ETX ||
511 	       byte == IMS_PCU_PROTOCOL_DLE;
512 }
513 
514 static int ims_pcu_send_cmd_chunk(struct ims_pcu *pcu,
515 				  u8 command, int chunk, int len)
516 {
517 	int error;
518 
519 	error = usb_bulk_msg(pcu->udev,
520 			     usb_sndbulkpipe(pcu->udev,
521 					     pcu->ep_out->bEndpointAddress),
522 			     pcu->urb_out_buf, len,
523 			     NULL, IMS_PCU_CMD_WRITE_TIMEOUT);
524 	if (error < 0) {
525 		dev_dbg(pcu->dev,
526 			"Sending 0x%02x command failed at chunk %d: %d\n",
527 			command, chunk, error);
528 		return error;
529 	}
530 
531 	return 0;
532 }
533 
534 static int ims_pcu_send_command(struct ims_pcu *pcu,
535 				u8 command, const u8 *data, int len)
536 {
537 	int count = 0;
538 	int chunk = 0;
539 	int delta;
540 	int i;
541 	int error;
542 	u8 csum = 0;
543 	u8 ack_id;
544 
545 	pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_STX;
546 
547 	/* We know the command need not be escaped */
548 	pcu->urb_out_buf[count++] = command;
549 	csum += command;
550 
551 	ack_id = pcu->ack_id++;
552 	if (ack_id == 0xff)
553 		ack_id = pcu->ack_id++;
554 
555 	if (ims_pcu_byte_needs_escape(ack_id))
556 		pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
557 
558 	pcu->urb_out_buf[count++] = ack_id;
559 	csum += ack_id;
560 
561 	for (i = 0; i < len; i++) {
562 
563 		delta = ims_pcu_byte_needs_escape(data[i]) ? 2 : 1;
564 		if (count + delta >= pcu->max_out_size) {
565 			error = ims_pcu_send_cmd_chunk(pcu, command,
566 						       ++chunk, count);
567 			if (error)
568 				return error;
569 
570 			count = 0;
571 		}
572 
573 		if (delta == 2)
574 			pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
575 
576 		pcu->urb_out_buf[count++] = data[i];
577 		csum += data[i];
578 	}
579 
580 	csum = 1 + ~csum;
581 
582 	delta = ims_pcu_byte_needs_escape(csum) ? 3 : 2;
583 	if (count + delta >= pcu->max_out_size) {
584 		error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
585 		if (error)
586 			return error;
587 
588 		count = 0;
589 	}
590 
591 	if (delta == 3)
592 		pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
593 
594 	pcu->urb_out_buf[count++] = csum;
595 	pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_ETX;
596 
597 	return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
598 }
599 
600 static int __ims_pcu_execute_command(struct ims_pcu *pcu,
601 				     u8 command, const void *data, size_t len,
602 				     u8 expected_response, int response_time)
603 {
604 	int error;
605 
606 	pcu->expected_response = expected_response;
607 	init_completion(&pcu->cmd_done);
608 
609 	error = ims_pcu_send_command(pcu, command, data, len);
610 	if (error)
611 		return error;
612 
613 	if (expected_response &&
614 	    !wait_for_completion_timeout(&pcu->cmd_done,
615 					 msecs_to_jiffies(response_time))) {
616 		dev_dbg(pcu->dev, "Command 0x%02x timed out\n", command);
617 		return -ETIMEDOUT;
618 	}
619 
620 	return 0;
621 }
622 
623 #define ims_pcu_execute_command(pcu, code, data, len)			\
624 	__ims_pcu_execute_command(pcu,					\
625 				  IMS_PCU_CMD_##code, data, len,	\
626 				  IMS_PCU_RSP_##code,			\
627 				  IMS_PCU_CMD_RESPONSE_TIMEOUT)
628 
629 #define ims_pcu_execute_query(pcu, code)				\
630 	ims_pcu_execute_command(pcu, code, NULL, 0)
631 
632 /* Bootloader commands */
633 #define IMS_PCU_BL_CMD_QUERY_DEVICE	0xa1
634 #define IMS_PCU_BL_CMD_UNLOCK_CONFIG	0xa2
635 #define IMS_PCU_BL_CMD_ERASE_APP	0xa3
636 #define IMS_PCU_BL_CMD_PROGRAM_DEVICE	0xa4
637 #define IMS_PCU_BL_CMD_PROGRAM_COMPLETE	0xa5
638 #define IMS_PCU_BL_CMD_READ_APP		0xa6
639 #define IMS_PCU_BL_CMD_RESET_DEVICE	0xa7
640 #define IMS_PCU_BL_CMD_LAUNCH_APP	0xa8
641 
642 /* Bootloader commands */
643 #define IMS_PCU_BL_RSP_QUERY_DEVICE	0xc1
644 #define IMS_PCU_BL_RSP_UNLOCK_CONFIG	0xc2
645 #define IMS_PCU_BL_RSP_ERASE_APP	0xc3
646 #define IMS_PCU_BL_RSP_PROGRAM_DEVICE	0xc4
647 #define IMS_PCU_BL_RSP_PROGRAM_COMPLETE	0xc5
648 #define IMS_PCU_BL_RSP_READ_APP		0xc6
649 #define IMS_PCU_BL_RSP_RESET_DEVICE	0	/* originally 0xa7 */
650 #define IMS_PCU_BL_RSP_LAUNCH_APP	0	/* originally 0xa8 */
651 
652 #define IMS_PCU_BL_DATA_OFFSET		3
653 
654 static int __ims_pcu_execute_bl_command(struct ims_pcu *pcu,
655 				        u8 command, const void *data, size_t len,
656 				        u8 expected_response, int response_time)
657 {
658 	int error;
659 
660 	pcu->cmd_buf[0] = command;
661 	if (data)
662 		memcpy(&pcu->cmd_buf[1], data, len);
663 
664 	error = __ims_pcu_execute_command(pcu,
665 				IMS_PCU_CMD_BOOTLOADER, pcu->cmd_buf, len + 1,
666 				expected_response ? IMS_PCU_RSP_BOOTLOADER : 0,
667 				response_time);
668 	if (error) {
669 		dev_err(pcu->dev,
670 			"Failure when sending 0x%02x command to bootloader, error: %d\n",
671 			pcu->cmd_buf[0], error);
672 		return error;
673 	}
674 
675 	if (expected_response && pcu->cmd_buf[2] != expected_response) {
676 		dev_err(pcu->dev,
677 			"Unexpected response from bootloader: 0x%02x, wanted 0x%02x\n",
678 			pcu->cmd_buf[2], expected_response);
679 		return -EINVAL;
680 	}
681 
682 	return 0;
683 }
684 
685 #define ims_pcu_execute_bl_command(pcu, code, data, len, timeout)	\
686 	__ims_pcu_execute_bl_command(pcu,				\
687 				     IMS_PCU_BL_CMD_##code, data, len,	\
688 				     IMS_PCU_BL_RSP_##code, timeout)	\
689 
690 #define IMS_PCU_INFO_PART_OFFSET	2
691 #define IMS_PCU_INFO_DOM_OFFSET		17
692 #define IMS_PCU_INFO_SERIAL_OFFSET	25
693 
694 #define IMS_PCU_SET_INFO_SIZE		31
695 
696 static int ims_pcu_get_info(struct ims_pcu *pcu)
697 {
698 	int error;
699 
700 	error = ims_pcu_execute_query(pcu, GET_INFO);
701 	if (error) {
702 		dev_err(pcu->dev,
703 			"GET_INFO command failed, error: %d\n", error);
704 		return error;
705 	}
706 
707 	memcpy(pcu->part_number,
708 	       &pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
709 	       sizeof(pcu->part_number));
710 	memcpy(pcu->date_of_manufacturing,
711 	       &pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
712 	       sizeof(pcu->date_of_manufacturing));
713 	memcpy(pcu->serial_number,
714 	       &pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
715 	       sizeof(pcu->serial_number));
716 
717 	return 0;
718 }
719 
720 static int ims_pcu_set_info(struct ims_pcu *pcu)
721 {
722 	int error;
723 
724 	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
725 	       pcu->part_number, sizeof(pcu->part_number));
726 	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
727 	       pcu->date_of_manufacturing, sizeof(pcu->date_of_manufacturing));
728 	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
729 	       pcu->serial_number, sizeof(pcu->serial_number));
730 
731 	error = ims_pcu_execute_command(pcu, SET_INFO,
732 					&pcu->cmd_buf[IMS_PCU_DATA_OFFSET],
733 					IMS_PCU_SET_INFO_SIZE);
734 	if (error) {
735 		dev_err(pcu->dev,
736 			"Failed to update device information, error: %d\n",
737 			error);
738 		return error;
739 	}
740 
741 	return 0;
742 }
743 
744 static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu)
745 {
746 	int error;
747 
748 	/* Execute jump to the bootoloader */
749 	error = ims_pcu_execute_command(pcu, JUMP_TO_BTLDR, NULL, 0);
750 	if (error) {
751 		dev_err(pcu->dev,
752 			"Failure when sending JUMP TO BOOLTLOADER command, error: %d\n",
753 			error);
754 		return error;
755 	}
756 
757 	return 0;
758 }
759 
760 /*********************************************************************
761  *             Firmware Update handling                              *
762  *********************************************************************/
763 
764 #define IMS_PCU_FIRMWARE_NAME	"imspcu.fw"
765 
766 struct ims_pcu_flash_fmt {
767 	__le32 addr;
768 	u8 len;
769 	u8 data[];
770 };
771 
772 static unsigned int ims_pcu_count_fw_records(const struct firmware *fw)
773 {
774 	const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
775 	unsigned int count = 0;
776 
777 	while (rec) {
778 		count++;
779 		rec = ihex_next_binrec(rec);
780 	}
781 
782 	return count;
783 }
784 
785 static int ims_pcu_verify_block(struct ims_pcu *pcu,
786 				u32 addr, u8 len, const u8 *data)
787 {
788 	struct ims_pcu_flash_fmt *fragment;
789 	int error;
790 
791 	fragment = (void *)&pcu->cmd_buf[1];
792 	put_unaligned_le32(addr, &fragment->addr);
793 	fragment->len = len;
794 
795 	error = ims_pcu_execute_bl_command(pcu, READ_APP, NULL, 5,
796 					IMS_PCU_CMD_RESPONSE_TIMEOUT);
797 	if (error) {
798 		dev_err(pcu->dev,
799 			"Failed to retrieve block at 0x%08x, len %d, error: %d\n",
800 			addr, len, error);
801 		return error;
802 	}
803 
804 	fragment = (void *)&pcu->cmd_buf[IMS_PCU_BL_DATA_OFFSET];
805 	if (get_unaligned_le32(&fragment->addr) != addr ||
806 	    fragment->len != len) {
807 		dev_err(pcu->dev,
808 			"Wrong block when retrieving 0x%08x (0x%08x), len %d (%d)\n",
809 			addr, get_unaligned_le32(&fragment->addr),
810 			len, fragment->len);
811 		return -EINVAL;
812 	}
813 
814 	if (memcmp(fragment->data, data, len)) {
815 		dev_err(pcu->dev,
816 			"Mismatch in block at 0x%08x, len %d\n",
817 			addr, len);
818 		return -EINVAL;
819 	}
820 
821 	return 0;
822 }
823 
824 static int ims_pcu_flash_firmware(struct ims_pcu *pcu,
825 				  const struct firmware *fw,
826 				  unsigned int n_fw_records)
827 {
828 	const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
829 	struct ims_pcu_flash_fmt *fragment;
830 	unsigned int count = 0;
831 	u32 addr;
832 	u8 len;
833 	int error;
834 
835 	error = ims_pcu_execute_bl_command(pcu, ERASE_APP, NULL, 0, 2000);
836 	if (error) {
837 		dev_err(pcu->dev,
838 			"Failed to erase application image, error: %d\n",
839 			error);
840 		return error;
841 	}
842 
843 	while (rec) {
844 		/*
845 		 * The firmware format is messed up for some reason.
846 		 * The address twice that of what is needed for some
847 		 * reason and we end up overwriting half of the data
848 		 * with the next record.
849 		 */
850 		addr = be32_to_cpu(rec->addr) / 2;
851 		len = be16_to_cpu(rec->len);
852 
853 		fragment = (void *)&pcu->cmd_buf[1];
854 		put_unaligned_le32(addr, &fragment->addr);
855 		fragment->len = len;
856 		memcpy(fragment->data, rec->data, len);
857 
858 		error = ims_pcu_execute_bl_command(pcu, PROGRAM_DEVICE,
859 						NULL, len + 5,
860 						IMS_PCU_CMD_RESPONSE_TIMEOUT);
861 		if (error) {
862 			dev_err(pcu->dev,
863 				"Failed to write block at 0x%08x, len %d, error: %d\n",
864 				addr, len, error);
865 			return error;
866 		}
867 
868 		if (addr >= pcu->fw_start_addr && addr < pcu->fw_end_addr) {
869 			error = ims_pcu_verify_block(pcu, addr, len, rec->data);
870 			if (error)
871 				return error;
872 		}
873 
874 		count++;
875 		pcu->update_firmware_status = (count * 100) / n_fw_records;
876 
877 		rec = ihex_next_binrec(rec);
878 	}
879 
880 	error = ims_pcu_execute_bl_command(pcu, PROGRAM_COMPLETE,
881 					    NULL, 0, 2000);
882 	if (error)
883 		dev_err(pcu->dev,
884 			"Failed to send PROGRAM_COMPLETE, error: %d\n",
885 			error);
886 
887 	return 0;
888 }
889 
890 static int ims_pcu_handle_firmware_update(struct ims_pcu *pcu,
891 					  const struct firmware *fw)
892 {
893 	unsigned int n_fw_records;
894 	int retval;
895 
896 	dev_info(pcu->dev, "Updating firmware %s, size: %zu\n",
897 		 IMS_PCU_FIRMWARE_NAME, fw->size);
898 
899 	n_fw_records = ims_pcu_count_fw_records(fw);
900 
901 	retval = ims_pcu_flash_firmware(pcu, fw, n_fw_records);
902 	if (retval)
903 		goto out;
904 
905 	retval = ims_pcu_execute_bl_command(pcu, LAUNCH_APP, NULL, 0, 0);
906 	if (retval)
907 		dev_err(pcu->dev,
908 			"Failed to start application image, error: %d\n",
909 			retval);
910 
911 out:
912 	pcu->update_firmware_status = retval;
913 	sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
914 	return retval;
915 }
916 
917 static void ims_pcu_process_async_firmware(const struct firmware *fw,
918 					   void *context)
919 {
920 	struct ims_pcu *pcu = context;
921 	int error;
922 
923 	if (!fw) {
924 		dev_err(pcu->dev, "Failed to get firmware %s\n",
925 			IMS_PCU_FIRMWARE_NAME);
926 		goto out;
927 	}
928 
929 	error = ihex_validate_fw(fw);
930 	if (error) {
931 		dev_err(pcu->dev, "Firmware %s is invalid\n",
932 			IMS_PCU_FIRMWARE_NAME);
933 		goto out;
934 	}
935 
936 	mutex_lock(&pcu->cmd_mutex);
937 	ims_pcu_handle_firmware_update(pcu, fw);
938 	mutex_unlock(&pcu->cmd_mutex);
939 
940 	release_firmware(fw);
941 
942 out:
943 	complete(&pcu->async_firmware_done);
944 }
945 
946 /*********************************************************************
947  *             Backlight LED device support                          *
948  *********************************************************************/
949 
950 #define IMS_PCU_MAX_BRIGHTNESS		31998
951 
952 static void ims_pcu_backlight_work(struct work_struct *work)
953 {
954 	struct ims_pcu_backlight *backlight =
955 			container_of(work, struct ims_pcu_backlight, work);
956 	struct ims_pcu *pcu =
957 			container_of(backlight, struct ims_pcu, backlight);
958 	int desired_brightness = backlight->desired_brightness;
959 	__le16 br_val = cpu_to_le16(desired_brightness);
960 	int error;
961 
962 	mutex_lock(&pcu->cmd_mutex);
963 
964 	error = ims_pcu_execute_command(pcu, SET_BRIGHTNESS,
965 					&br_val, sizeof(br_val));
966 	if (error && error != -ENODEV)
967 		dev_warn(pcu->dev,
968 			 "Failed to set desired brightness %u, error: %d\n",
969 			 desired_brightness, error);
970 
971 	mutex_unlock(&pcu->cmd_mutex);
972 }
973 
974 static void ims_pcu_backlight_set_brightness(struct led_classdev *cdev,
975 					     enum led_brightness value)
976 {
977 	struct ims_pcu_backlight *backlight =
978 			container_of(cdev, struct ims_pcu_backlight, cdev);
979 
980 	backlight->desired_brightness = value;
981 	schedule_work(&backlight->work);
982 }
983 
984 static enum led_brightness
985 ims_pcu_backlight_get_brightness(struct led_classdev *cdev)
986 {
987 	struct ims_pcu_backlight *backlight =
988 			container_of(cdev, struct ims_pcu_backlight, cdev);
989 	struct ims_pcu *pcu =
990 			container_of(backlight, struct ims_pcu, backlight);
991 	int brightness;
992 	int error;
993 
994 	mutex_lock(&pcu->cmd_mutex);
995 
996 	error = ims_pcu_execute_query(pcu, GET_BRIGHTNESS);
997 	if (error) {
998 		dev_warn(pcu->dev,
999 			 "Failed to get current brightness, error: %d\n",
1000 			 error);
1001 		/* Assume the LED is OFF */
1002 		brightness = LED_OFF;
1003 	} else {
1004 		brightness =
1005 			get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1006 	}
1007 
1008 	mutex_unlock(&pcu->cmd_mutex);
1009 
1010 	return brightness;
1011 }
1012 
1013 static int ims_pcu_setup_backlight(struct ims_pcu *pcu)
1014 {
1015 	struct ims_pcu_backlight *backlight = &pcu->backlight;
1016 	int error;
1017 
1018 	INIT_WORK(&backlight->work, ims_pcu_backlight_work);
1019 	snprintf(backlight->name, sizeof(backlight->name),
1020 		 "pcu%d::kbd_backlight", pcu->device_no);
1021 
1022 	backlight->cdev.name = backlight->name;
1023 	backlight->cdev.max_brightness = IMS_PCU_MAX_BRIGHTNESS;
1024 	backlight->cdev.brightness_get = ims_pcu_backlight_get_brightness;
1025 	backlight->cdev.brightness_set = ims_pcu_backlight_set_brightness;
1026 
1027 	error = led_classdev_register(pcu->dev, &backlight->cdev);
1028 	if (error) {
1029 		dev_err(pcu->dev,
1030 			"Failed to register backlight LED device, error: %d\n",
1031 			error);
1032 		return error;
1033 	}
1034 
1035 	return 0;
1036 }
1037 
1038 static void ims_pcu_destroy_backlight(struct ims_pcu *pcu)
1039 {
1040 	struct ims_pcu_backlight *backlight = &pcu->backlight;
1041 
1042 	led_classdev_unregister(&backlight->cdev);
1043 	cancel_work_sync(&backlight->work);
1044 }
1045 
1046 
1047 /*********************************************************************
1048  *             Sysfs attributes handling                             *
1049  *********************************************************************/
1050 
1051 struct ims_pcu_attribute {
1052 	struct device_attribute dattr;
1053 	size_t field_offset;
1054 	int field_length;
1055 };
1056 
1057 static ssize_t ims_pcu_attribute_show(struct device *dev,
1058 				      struct device_attribute *dattr,
1059 				      char *buf)
1060 {
1061 	struct usb_interface *intf = to_usb_interface(dev);
1062 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1063 	struct ims_pcu_attribute *attr =
1064 			container_of(dattr, struct ims_pcu_attribute, dattr);
1065 	char *field = (char *)pcu + attr->field_offset;
1066 
1067 	return scnprintf(buf, PAGE_SIZE, "%.*s\n", attr->field_length, field);
1068 }
1069 
1070 static ssize_t ims_pcu_attribute_store(struct device *dev,
1071 				       struct device_attribute *dattr,
1072 				       const char *buf, size_t count)
1073 {
1074 
1075 	struct usb_interface *intf = to_usb_interface(dev);
1076 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1077 	struct ims_pcu_attribute *attr =
1078 			container_of(dattr, struct ims_pcu_attribute, dattr);
1079 	char *field = (char *)pcu + attr->field_offset;
1080 	size_t data_len;
1081 	int error;
1082 
1083 	if (count > attr->field_length)
1084 		return -EINVAL;
1085 
1086 	data_len = strnlen(buf, attr->field_length);
1087 	if (data_len > attr->field_length)
1088 		return -EINVAL;
1089 
1090 	error = mutex_lock_interruptible(&pcu->cmd_mutex);
1091 	if (error)
1092 		return error;
1093 
1094 	memset(field, 0, attr->field_length);
1095 	memcpy(field, buf, data_len);
1096 
1097 	error = ims_pcu_set_info(pcu);
1098 
1099 	/*
1100 	 * Even if update failed, let's fetch the info again as we just
1101 	 * clobbered one of the fields.
1102 	 */
1103 	ims_pcu_get_info(pcu);
1104 
1105 	mutex_unlock(&pcu->cmd_mutex);
1106 
1107 	return error < 0 ? error : count;
1108 }
1109 
1110 #define IMS_PCU_ATTR(_field, _mode)					\
1111 struct ims_pcu_attribute ims_pcu_attr_##_field = {			\
1112 	.dattr = __ATTR(_field, _mode,					\
1113 			ims_pcu_attribute_show,				\
1114 			ims_pcu_attribute_store),			\
1115 	.field_offset = offsetof(struct ims_pcu, _field),		\
1116 	.field_length = sizeof(((struct ims_pcu *)NULL)->_field),	\
1117 }
1118 
1119 #define IMS_PCU_RO_ATTR(_field)						\
1120 		IMS_PCU_ATTR(_field, S_IRUGO)
1121 #define IMS_PCU_RW_ATTR(_field)						\
1122 		IMS_PCU_ATTR(_field, S_IRUGO | S_IWUSR)
1123 
1124 static IMS_PCU_RW_ATTR(part_number);
1125 static IMS_PCU_RW_ATTR(serial_number);
1126 static IMS_PCU_RW_ATTR(date_of_manufacturing);
1127 
1128 static IMS_PCU_RO_ATTR(fw_version);
1129 static IMS_PCU_RO_ATTR(bl_version);
1130 static IMS_PCU_RO_ATTR(reset_reason);
1131 
1132 static ssize_t ims_pcu_reset_device(struct device *dev,
1133 				    struct device_attribute *dattr,
1134 				    const char *buf, size_t count)
1135 {
1136 	static const u8 reset_byte = 1;
1137 	struct usb_interface *intf = to_usb_interface(dev);
1138 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1139 	int value;
1140 	int error;
1141 
1142 	error = kstrtoint(buf, 0, &value);
1143 	if (error)
1144 		return error;
1145 
1146 	if (value != 1)
1147 		return -EINVAL;
1148 
1149 	dev_info(pcu->dev, "Attempting to reset device\n");
1150 
1151 	error = ims_pcu_execute_command(pcu, PCU_RESET, &reset_byte, 1);
1152 	if (error) {
1153 		dev_info(pcu->dev,
1154 			 "Failed to reset device, error: %d\n",
1155 			 error);
1156 		return error;
1157 	}
1158 
1159 	return count;
1160 }
1161 
1162 static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device);
1163 
1164 static ssize_t ims_pcu_update_firmware_store(struct device *dev,
1165 					     struct device_attribute *dattr,
1166 					     const char *buf, size_t count)
1167 {
1168 	struct usb_interface *intf = to_usb_interface(dev);
1169 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1170 	const struct firmware *fw = NULL;
1171 	int value;
1172 	int error;
1173 
1174 	error = kstrtoint(buf, 0, &value);
1175 	if (error)
1176 		return error;
1177 
1178 	if (value != 1)
1179 		return -EINVAL;
1180 
1181 	error = mutex_lock_interruptible(&pcu->cmd_mutex);
1182 	if (error)
1183 		return error;
1184 
1185 	error = request_ihex_firmware(&fw, IMS_PCU_FIRMWARE_NAME, pcu->dev);
1186 	if (error) {
1187 		dev_err(pcu->dev, "Failed to request firmware %s, error: %d\n",
1188 			IMS_PCU_FIRMWARE_NAME, error);
1189 		goto out;
1190 	}
1191 
1192 	/*
1193 	 * If we are already in bootloader mode we can proceed with
1194 	 * flashing the firmware.
1195 	 *
1196 	 * If we are in application mode, then we need to switch into
1197 	 * bootloader mode, which will cause the device to disconnect
1198 	 * and reconnect as different device.
1199 	 */
1200 	if (pcu->bootloader_mode)
1201 		error = ims_pcu_handle_firmware_update(pcu, fw);
1202 	else
1203 		error = ims_pcu_switch_to_bootloader(pcu);
1204 
1205 	release_firmware(fw);
1206 
1207 out:
1208 	mutex_unlock(&pcu->cmd_mutex);
1209 	return error ?: count;
1210 }
1211 
1212 static DEVICE_ATTR(update_firmware, S_IWUSR,
1213 		   NULL, ims_pcu_update_firmware_store);
1214 
1215 static ssize_t
1216 ims_pcu_update_firmware_status_show(struct device *dev,
1217 				    struct device_attribute *dattr,
1218 				    char *buf)
1219 {
1220 	struct usb_interface *intf = to_usb_interface(dev);
1221 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1222 
1223 	return scnprintf(buf, PAGE_SIZE, "%d\n", pcu->update_firmware_status);
1224 }
1225 
1226 static DEVICE_ATTR(update_firmware_status, S_IRUGO,
1227 		   ims_pcu_update_firmware_status_show, NULL);
1228 
1229 static struct attribute *ims_pcu_attrs[] = {
1230 	&ims_pcu_attr_part_number.dattr.attr,
1231 	&ims_pcu_attr_serial_number.dattr.attr,
1232 	&ims_pcu_attr_date_of_manufacturing.dattr.attr,
1233 	&ims_pcu_attr_fw_version.dattr.attr,
1234 	&ims_pcu_attr_bl_version.dattr.attr,
1235 	&ims_pcu_attr_reset_reason.dattr.attr,
1236 	&dev_attr_reset_device.attr,
1237 	&dev_attr_update_firmware.attr,
1238 	&dev_attr_update_firmware_status.attr,
1239 	NULL
1240 };
1241 
1242 static umode_t ims_pcu_is_attr_visible(struct kobject *kobj,
1243 				       struct attribute *attr, int n)
1244 {
1245 	struct device *dev = container_of(kobj, struct device, kobj);
1246 	struct usb_interface *intf = to_usb_interface(dev);
1247 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1248 	umode_t mode = attr->mode;
1249 
1250 	if (pcu->bootloader_mode) {
1251 		if (attr != &dev_attr_update_firmware_status.attr &&
1252 		    attr != &dev_attr_update_firmware.attr &&
1253 		    attr != &dev_attr_reset_device.attr) {
1254 			mode = 0;
1255 		}
1256 	} else {
1257 		if (attr == &dev_attr_update_firmware_status.attr)
1258 			mode = 0;
1259 	}
1260 
1261 	return mode;
1262 }
1263 
1264 static struct attribute_group ims_pcu_attr_group = {
1265 	.is_visible	= ims_pcu_is_attr_visible,
1266 	.attrs		= ims_pcu_attrs,
1267 };
1268 
1269 /* Support for a separate OFN attribute group */
1270 
1271 #define OFN_REG_RESULT_OFFSET	2
1272 
1273 static int ims_pcu_read_ofn_config(struct ims_pcu *pcu, u8 addr, u8 *data)
1274 {
1275 	int error;
1276 	s16 result;
1277 
1278 	error = ims_pcu_execute_command(pcu, OFN_GET_CONFIG,
1279 					&addr, sizeof(addr));
1280 	if (error)
1281 		return error;
1282 
1283 	result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
1284 	if (result < 0)
1285 		return -EIO;
1286 
1287 	/* We only need LSB */
1288 	*data = pcu->cmd_buf[OFN_REG_RESULT_OFFSET];
1289 	return 0;
1290 }
1291 
1292 static int ims_pcu_write_ofn_config(struct ims_pcu *pcu, u8 addr, u8 data)
1293 {
1294 	u8 buffer[] = { addr, data };
1295 	int error;
1296 	s16 result;
1297 
1298 	error = ims_pcu_execute_command(pcu, OFN_SET_CONFIG,
1299 					&buffer, sizeof(buffer));
1300 	if (error)
1301 		return error;
1302 
1303 	result = (s16)get_unaligned_le16(pcu->cmd_buf + OFN_REG_RESULT_OFFSET);
1304 	if (result < 0)
1305 		return -EIO;
1306 
1307 	return 0;
1308 }
1309 
1310 static ssize_t ims_pcu_ofn_reg_data_show(struct device *dev,
1311 					 struct device_attribute *dattr,
1312 					 char *buf)
1313 {
1314 	struct usb_interface *intf = to_usb_interface(dev);
1315 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1316 	int error;
1317 	u8 data;
1318 
1319 	mutex_lock(&pcu->cmd_mutex);
1320 	error = ims_pcu_read_ofn_config(pcu, pcu->ofn_reg_addr, &data);
1321 	mutex_unlock(&pcu->cmd_mutex);
1322 
1323 	if (error)
1324 		return error;
1325 
1326 	return scnprintf(buf, PAGE_SIZE, "%x\n", data);
1327 }
1328 
1329 static ssize_t ims_pcu_ofn_reg_data_store(struct device *dev,
1330 					  struct device_attribute *dattr,
1331 					  const char *buf, size_t count)
1332 {
1333 	struct usb_interface *intf = to_usb_interface(dev);
1334 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1335 	int error;
1336 	u8 value;
1337 
1338 	error = kstrtou8(buf, 0, &value);
1339 	if (error)
1340 		return error;
1341 
1342 	mutex_lock(&pcu->cmd_mutex);
1343 	error = ims_pcu_write_ofn_config(pcu, pcu->ofn_reg_addr, value);
1344 	mutex_unlock(&pcu->cmd_mutex);
1345 
1346 	return error ?: count;
1347 }
1348 
1349 static DEVICE_ATTR(reg_data, S_IRUGO | S_IWUSR,
1350 		   ims_pcu_ofn_reg_data_show, ims_pcu_ofn_reg_data_store);
1351 
1352 static ssize_t ims_pcu_ofn_reg_addr_show(struct device *dev,
1353 					 struct device_attribute *dattr,
1354 					 char *buf)
1355 {
1356 	struct usb_interface *intf = to_usb_interface(dev);
1357 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1358 	int error;
1359 
1360 	mutex_lock(&pcu->cmd_mutex);
1361 	error = scnprintf(buf, PAGE_SIZE, "%x\n", pcu->ofn_reg_addr);
1362 	mutex_unlock(&pcu->cmd_mutex);
1363 
1364 	return error;
1365 }
1366 
1367 static ssize_t ims_pcu_ofn_reg_addr_store(struct device *dev,
1368 					  struct device_attribute *dattr,
1369 					  const char *buf, size_t count)
1370 {
1371 	struct usb_interface *intf = to_usb_interface(dev);
1372 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1373 	int error;
1374 	u8 value;
1375 
1376 	error = kstrtou8(buf, 0, &value);
1377 	if (error)
1378 		return error;
1379 
1380 	mutex_lock(&pcu->cmd_mutex);
1381 	pcu->ofn_reg_addr = value;
1382 	mutex_unlock(&pcu->cmd_mutex);
1383 
1384 	return error ?: count;
1385 }
1386 
1387 static DEVICE_ATTR(reg_addr, S_IRUGO | S_IWUSR,
1388 		   ims_pcu_ofn_reg_addr_show, ims_pcu_ofn_reg_addr_store);
1389 
1390 struct ims_pcu_ofn_bit_attribute {
1391 	struct device_attribute dattr;
1392 	u8 addr;
1393 	u8 nr;
1394 };
1395 
1396 static ssize_t ims_pcu_ofn_bit_show(struct device *dev,
1397 				    struct device_attribute *dattr,
1398 				    char *buf)
1399 {
1400 	struct usb_interface *intf = to_usb_interface(dev);
1401 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1402 	struct ims_pcu_ofn_bit_attribute *attr =
1403 		container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr);
1404 	int error;
1405 	u8 data;
1406 
1407 	mutex_lock(&pcu->cmd_mutex);
1408 	error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
1409 	mutex_unlock(&pcu->cmd_mutex);
1410 
1411 	if (error)
1412 		return error;
1413 
1414 	return scnprintf(buf, PAGE_SIZE, "%d\n", !!(data & (1 << attr->nr)));
1415 }
1416 
1417 static ssize_t ims_pcu_ofn_bit_store(struct device *dev,
1418 				     struct device_attribute *dattr,
1419 				     const char *buf, size_t count)
1420 {
1421 	struct usb_interface *intf = to_usb_interface(dev);
1422 	struct ims_pcu *pcu = usb_get_intfdata(intf);
1423 	struct ims_pcu_ofn_bit_attribute *attr =
1424 		container_of(dattr, struct ims_pcu_ofn_bit_attribute, dattr);
1425 	int error;
1426 	int value;
1427 	u8 data;
1428 
1429 	error = kstrtoint(buf, 0, &value);
1430 	if (error)
1431 		return error;
1432 
1433 	if (value > 1)
1434 		return -EINVAL;
1435 
1436 	mutex_lock(&pcu->cmd_mutex);
1437 
1438 	error = ims_pcu_read_ofn_config(pcu, attr->addr, &data);
1439 	if (!error) {
1440 		if (value)
1441 			data |= 1U << attr->nr;
1442 		else
1443 			data &= ~(1U << attr->nr);
1444 
1445 		error = ims_pcu_write_ofn_config(pcu, attr->addr, data);
1446 	}
1447 
1448 	mutex_unlock(&pcu->cmd_mutex);
1449 
1450 	return error ?: count;
1451 }
1452 
1453 #define IMS_PCU_OFN_BIT_ATTR(_field, _addr, _nr)			\
1454 struct ims_pcu_ofn_bit_attribute ims_pcu_ofn_attr_##_field = {		\
1455 	.dattr = __ATTR(_field, S_IWUSR | S_IRUGO,			\
1456 			ims_pcu_ofn_bit_show, ims_pcu_ofn_bit_store),	\
1457 	.addr = _addr,							\
1458 	.nr = _nr,							\
1459 }
1460 
1461 static IMS_PCU_OFN_BIT_ATTR(engine_enable,   0x60, 7);
1462 static IMS_PCU_OFN_BIT_ATTR(speed_enable,    0x60, 6);
1463 static IMS_PCU_OFN_BIT_ATTR(assert_enable,   0x60, 5);
1464 static IMS_PCU_OFN_BIT_ATTR(xyquant_enable,  0x60, 4);
1465 static IMS_PCU_OFN_BIT_ATTR(xyscale_enable,  0x60, 1);
1466 
1467 static IMS_PCU_OFN_BIT_ATTR(scale_x2,        0x63, 6);
1468 static IMS_PCU_OFN_BIT_ATTR(scale_y2,        0x63, 7);
1469 
1470 static struct attribute *ims_pcu_ofn_attrs[] = {
1471 	&dev_attr_reg_data.attr,
1472 	&dev_attr_reg_addr.attr,
1473 	&ims_pcu_ofn_attr_engine_enable.dattr.attr,
1474 	&ims_pcu_ofn_attr_speed_enable.dattr.attr,
1475 	&ims_pcu_ofn_attr_assert_enable.dattr.attr,
1476 	&ims_pcu_ofn_attr_xyquant_enable.dattr.attr,
1477 	&ims_pcu_ofn_attr_xyscale_enable.dattr.attr,
1478 	&ims_pcu_ofn_attr_scale_x2.dattr.attr,
1479 	&ims_pcu_ofn_attr_scale_y2.dattr.attr,
1480 	NULL
1481 };
1482 
1483 static struct attribute_group ims_pcu_ofn_attr_group = {
1484 	.name	= "ofn",
1485 	.attrs	= ims_pcu_ofn_attrs,
1486 };
1487 
1488 static void ims_pcu_irq(struct urb *urb)
1489 {
1490 	struct ims_pcu *pcu = urb->context;
1491 	int retval, status;
1492 
1493 	status = urb->status;
1494 
1495 	switch (status) {
1496 	case 0:
1497 		/* success */
1498 		break;
1499 	case -ECONNRESET:
1500 	case -ENOENT:
1501 	case -ESHUTDOWN:
1502 		/* this urb is terminated, clean up */
1503 		dev_dbg(pcu->dev, "%s - urb shutting down with status: %d\n",
1504 			__func__, status);
1505 		return;
1506 	default:
1507 		dev_dbg(pcu->dev, "%s - nonzero urb status received: %d\n",
1508 			__func__, status);
1509 		goto exit;
1510 	}
1511 
1512 	dev_dbg(pcu->dev, "%s: received %d: %*ph\n", __func__,
1513 		urb->actual_length, urb->actual_length, pcu->urb_in_buf);
1514 
1515 	if (urb == pcu->urb_in)
1516 		ims_pcu_process_data(pcu, urb);
1517 
1518 exit:
1519 	retval = usb_submit_urb(urb, GFP_ATOMIC);
1520 	if (retval && retval != -ENODEV)
1521 		dev_err(pcu->dev, "%s - usb_submit_urb failed with result %d\n",
1522 			__func__, retval);
1523 }
1524 
1525 static int ims_pcu_buffers_alloc(struct ims_pcu *pcu)
1526 {
1527 	int error;
1528 
1529 	pcu->urb_in_buf = usb_alloc_coherent(pcu->udev, pcu->max_in_size,
1530 					     GFP_KERNEL, &pcu->read_dma);
1531 	if (!pcu->urb_in_buf) {
1532 		dev_err(pcu->dev,
1533 			"Failed to allocate memory for read buffer\n");
1534 		return -ENOMEM;
1535 	}
1536 
1537 	pcu->urb_in = usb_alloc_urb(0, GFP_KERNEL);
1538 	if (!pcu->urb_in) {
1539 		dev_err(pcu->dev, "Failed to allocate input URB\n");
1540 		error = -ENOMEM;
1541 		goto err_free_urb_in_buf;
1542 	}
1543 
1544 	pcu->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1545 	pcu->urb_in->transfer_dma = pcu->read_dma;
1546 
1547 	usb_fill_bulk_urb(pcu->urb_in, pcu->udev,
1548 			  usb_rcvbulkpipe(pcu->udev,
1549 					  pcu->ep_in->bEndpointAddress),
1550 			  pcu->urb_in_buf, pcu->max_in_size,
1551 			  ims_pcu_irq, pcu);
1552 
1553 	/*
1554 	 * We are using usb_bulk_msg() for sending so there is no point
1555 	 * in allocating memory with usb_alloc_coherent().
1556 	 */
1557 	pcu->urb_out_buf = kmalloc(pcu->max_out_size, GFP_KERNEL);
1558 	if (!pcu->urb_out_buf) {
1559 		dev_err(pcu->dev, "Failed to allocate memory for write buffer\n");
1560 		error = -ENOMEM;
1561 		goto err_free_in_urb;
1562 	}
1563 
1564 	pcu->urb_ctrl_buf = usb_alloc_coherent(pcu->udev, pcu->max_ctrl_size,
1565 					       GFP_KERNEL, &pcu->ctrl_dma);
1566 	if (!pcu->urb_ctrl_buf) {
1567 		dev_err(pcu->dev,
1568 			"Failed to allocate memory for read buffer\n");
1569 		goto err_free_urb_out_buf;
1570 	}
1571 
1572 	pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
1573 	if (!pcu->urb_ctrl) {
1574 		dev_err(pcu->dev, "Failed to allocate input URB\n");
1575 		error = -ENOMEM;
1576 		goto err_free_urb_ctrl_buf;
1577 	}
1578 
1579 	pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1580 	pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;
1581 
1582 	usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
1583 			  usb_rcvintpipe(pcu->udev,
1584 					 pcu->ep_ctrl->bEndpointAddress),
1585 			  pcu->urb_ctrl_buf, pcu->max_ctrl_size,
1586 			  ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);
1587 
1588 	return 0;
1589 
1590 err_free_urb_ctrl_buf:
1591 	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1592 			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
1593 err_free_urb_out_buf:
1594 	kfree(pcu->urb_out_buf);
1595 err_free_in_urb:
1596 	usb_free_urb(pcu->urb_in);
1597 err_free_urb_in_buf:
1598 	usb_free_coherent(pcu->udev, pcu->max_in_size,
1599 			  pcu->urb_in_buf, pcu->read_dma);
1600 	return error;
1601 }
1602 
1603 static void ims_pcu_buffers_free(struct ims_pcu *pcu)
1604 {
1605 	usb_kill_urb(pcu->urb_in);
1606 	usb_free_urb(pcu->urb_in);
1607 
1608 	usb_free_coherent(pcu->udev, pcu->max_out_size,
1609 			  pcu->urb_in_buf, pcu->read_dma);
1610 
1611 	kfree(pcu->urb_out_buf);
1612 
1613 	usb_kill_urb(pcu->urb_ctrl);
1614 	usb_free_urb(pcu->urb_ctrl);
1615 
1616 	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1617 			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
1618 }
1619 
1620 static const struct usb_cdc_union_desc *
1621 ims_pcu_get_cdc_union_desc(struct usb_interface *intf)
1622 {
1623 	const void *buf = intf->altsetting->extra;
1624 	size_t buflen = intf->altsetting->extralen;
1625 	struct usb_cdc_union_desc *union_desc;
1626 
1627 	if (!buf) {
1628 		dev_err(&intf->dev, "Missing descriptor data\n");
1629 		return NULL;
1630 	}
1631 
1632 	if (!buflen) {
1633 		dev_err(&intf->dev, "Zero length descriptor\n");
1634 		return NULL;
1635 	}
1636 
1637 	while (buflen > 0) {
1638 		union_desc = (struct usb_cdc_union_desc *)buf;
1639 
1640 		if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
1641 		    union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
1642 			dev_dbg(&intf->dev, "Found union header\n");
1643 			return union_desc;
1644 		}
1645 
1646 		buflen -= union_desc->bLength;
1647 		buf += union_desc->bLength;
1648 	}
1649 
1650 	dev_err(&intf->dev, "Missing CDC union descriptor\n");
1651 	return NULL;
1652 }
1653 
1654 static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1655 {
1656 	const struct usb_cdc_union_desc *union_desc;
1657 	struct usb_host_interface *alt;
1658 
1659 	union_desc = ims_pcu_get_cdc_union_desc(intf);
1660 	if (!union_desc)
1661 		return -EINVAL;
1662 
1663 	pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1664 					 union_desc->bMasterInterface0);
1665 
1666 	alt = pcu->ctrl_intf->cur_altsetting;
1667 	pcu->ep_ctrl = &alt->endpoint[0].desc;
1668 	pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1669 
1670 	pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1671 					 union_desc->bSlaveInterface0);
1672 
1673 	alt = pcu->data_intf->cur_altsetting;
1674 	if (alt->desc.bNumEndpoints != 2) {
1675 		dev_err(pcu->dev,
1676 			"Incorrect number of endpoints on data interface (%d)\n",
1677 			alt->desc.bNumEndpoints);
1678 		return -EINVAL;
1679 	}
1680 
1681 	pcu->ep_out = &alt->endpoint[0].desc;
1682 	if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1683 		dev_err(pcu->dev,
1684 			"First endpoint on data interface is not BULK OUT\n");
1685 		return -EINVAL;
1686 	}
1687 
1688 	pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1689 	if (pcu->max_out_size < 8) {
1690 		dev_err(pcu->dev,
1691 			"Max OUT packet size is too small (%zd)\n",
1692 			pcu->max_out_size);
1693 		return -EINVAL;
1694 	}
1695 
1696 	pcu->ep_in = &alt->endpoint[1].desc;
1697 	if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1698 		dev_err(pcu->dev,
1699 			"Second endpoint on data interface is not BULK IN\n");
1700 		return -EINVAL;
1701 	}
1702 
1703 	pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1704 	if (pcu->max_in_size < 8) {
1705 		dev_err(pcu->dev,
1706 			"Max IN packet size is too small (%zd)\n",
1707 			pcu->max_in_size);
1708 		return -EINVAL;
1709 	}
1710 
1711 	return 0;
1712 }
1713 
1714 static int ims_pcu_start_io(struct ims_pcu *pcu)
1715 {
1716 	int error;
1717 
1718 	error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1719 	if (error) {
1720 		dev_err(pcu->dev,
1721 			"Failed to start control IO - usb_submit_urb failed with result: %d\n",
1722 			error);
1723 		return -EIO;
1724 	}
1725 
1726 	error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1727 	if (error) {
1728 		dev_err(pcu->dev,
1729 			"Failed to start IO - usb_submit_urb failed with result: %d\n",
1730 			error);
1731 		usb_kill_urb(pcu->urb_ctrl);
1732 		return -EIO;
1733 	}
1734 
1735 	return 0;
1736 }
1737 
1738 static void ims_pcu_stop_io(struct ims_pcu *pcu)
1739 {
1740 	usb_kill_urb(pcu->urb_in);
1741 	usb_kill_urb(pcu->urb_ctrl);
1742 }
1743 
1744 static int ims_pcu_line_setup(struct ims_pcu *pcu)
1745 {
1746 	struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1747 	struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1748 	int error;
1749 
1750 	memset(line, 0, sizeof(*line));
1751 	line->dwDTERate = cpu_to_le32(57600);
1752 	line->bDataBits = 8;
1753 
1754 	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1755 				USB_CDC_REQ_SET_LINE_CODING,
1756 				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1757 				0, interface->desc.bInterfaceNumber,
1758 				line, sizeof(struct usb_cdc_line_coding),
1759 				5000);
1760 	if (error < 0) {
1761 		dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1762 			error);
1763 		return error;
1764 	}
1765 
1766 	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1767 				USB_CDC_REQ_SET_CONTROL_LINE_STATE,
1768 				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1769 				0x03, interface->desc.bInterfaceNumber,
1770 				NULL, 0, 5000);
1771 	if (error < 0) {
1772 		dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1773 			error);
1774 		return error;
1775 	}
1776 
1777 	return 0;
1778 }
1779 
1780 static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1781 {
1782 	int error;
1783 
1784 	error = ims_pcu_get_info(pcu);
1785 	if (error)
1786 		return error;
1787 
1788 	error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1789 	if (error) {
1790 		dev_err(pcu->dev,
1791 			"GET_FW_VERSION command failed, error: %d\n", error);
1792 		return error;
1793 	}
1794 
1795 	snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1796 		 "%02d%02d%02d%02d.%c%c",
1797 		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1798 		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1799 
1800 	error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1801 	if (error) {
1802 		dev_err(pcu->dev,
1803 			"GET_BL_VERSION command failed, error: %d\n", error);
1804 		return error;
1805 	}
1806 
1807 	snprintf(pcu->bl_version, sizeof(pcu->bl_version),
1808 		 "%02d%02d%02d%02d.%c%c",
1809 		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1810 		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1811 
1812 	error = ims_pcu_execute_query(pcu, RESET_REASON);
1813 	if (error) {
1814 		dev_err(pcu->dev,
1815 			"RESET_REASON command failed, error: %d\n", error);
1816 		return error;
1817 	}
1818 
1819 	snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1820 		 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1821 
1822 	dev_dbg(pcu->dev,
1823 		"P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
1824 		pcu->part_number,
1825 		pcu->date_of_manufacturing,
1826 		pcu->serial_number,
1827 		pcu->fw_version,
1828 		pcu->bl_version,
1829 		pcu->reset_reason);
1830 
1831 	return 0;
1832 }
1833 
1834 static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1835 {
1836 	int error;
1837 
1838 	error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1839 	if (error) {
1840 		dev_err(pcu->dev,
1841 			"GET_DEVICE_ID command failed, error: %d\n", error);
1842 		return error;
1843 	}
1844 
1845 	*device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1846 	dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1847 
1848 	return 0;
1849 }
1850 
1851 static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1852 {
1853 	static atomic_t device_no = ATOMIC_INIT(0);
1854 
1855 	const struct ims_pcu_device_info *info;
1856 	int error;
1857 
1858 	error = ims_pcu_get_device_info(pcu);
1859 	if (error) {
1860 		/* Device does not respond to basic queries, hopeless */
1861 		return error;
1862 	}
1863 
1864 	error = ims_pcu_identify_type(pcu, &pcu->device_id);
1865 	if (error) {
1866 		dev_err(pcu->dev,
1867 			"Failed to identify device, error: %d\n", error);
1868 		/*
1869 		 * Do not signal error, but do not create input nor
1870 		 * backlight devices either, let userspace figure this
1871 		 * out (flash a new firmware?).
1872 		 */
1873 		return 0;
1874 	}
1875 
1876 	if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1877 	    !ims_pcu_device_info[pcu->device_id].keymap) {
1878 		dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1879 		/* Same as above, punt to userspace */
1880 		return 0;
1881 	}
1882 
1883 	/* Device appears to be operable, complete initialization */
1884 	pcu->device_no = atomic_inc_return(&device_no) - 1;
1885 
1886 	/*
1887 	 * PCU-B devices, both GEN_1 and GEN_2 do not have OFN sensor
1888 	 */
1889 	if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1890 		error = sysfs_create_group(&pcu->dev->kobj,
1891 					   &ims_pcu_ofn_attr_group);
1892 		if (error)
1893 			return error;
1894 	}
1895 
1896 	error = ims_pcu_setup_backlight(pcu);
1897 	if (error)
1898 		return error;
1899 
1900 	info = &ims_pcu_device_info[pcu->device_id];
1901 	error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1902 	if (error)
1903 		goto err_destroy_backlight;
1904 
1905 	if (info->has_gamepad) {
1906 		error = ims_pcu_setup_gamepad(pcu);
1907 		if (error)
1908 			goto err_destroy_buttons;
1909 	}
1910 
1911 	pcu->setup_complete = true;
1912 
1913 	return 0;
1914 
1915 err_destroy_buttons:
1916 	ims_pcu_destroy_buttons(pcu);
1917 err_destroy_backlight:
1918 	ims_pcu_destroy_backlight(pcu);
1919 	return error;
1920 }
1921 
1922 static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1923 {
1924 	if (pcu->setup_complete) {
1925 		pcu->setup_complete = false;
1926 		mb(); /* make sure flag setting is not reordered */
1927 
1928 		if (pcu->gamepad)
1929 			ims_pcu_destroy_gamepad(pcu);
1930 		ims_pcu_destroy_buttons(pcu);
1931 		ims_pcu_destroy_backlight(pcu);
1932 
1933 		if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1934 			sysfs_remove_group(&pcu->dev->kobj,
1935 					   &ims_pcu_ofn_attr_group);
1936 	}
1937 }
1938 
1939 static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1940 {
1941 	int error;
1942 
1943 	error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1944 					   IMS_PCU_CMD_RESPONSE_TIMEOUT);
1945 	if (error) {
1946 		dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1947 		return error;
1948 	}
1949 
1950 	pcu->fw_start_addr =
1951 		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1952 	pcu->fw_end_addr =
1953 		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1954 
1955 	dev_info(pcu->dev,
1956 		 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
1957 		 pcu->fw_start_addr, pcu->fw_end_addr);
1958 
1959 	error = request_firmware_nowait(THIS_MODULE, true,
1960 					IMS_PCU_FIRMWARE_NAME,
1961 					pcu->dev, GFP_KERNEL, pcu,
1962 					ims_pcu_process_async_firmware);
1963 	if (error) {
1964 		/* This error is not fatal, let userspace have another chance */
1965 		complete(&pcu->async_firmware_done);
1966 	}
1967 
1968 	return 0;
1969 }
1970 
1971 static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1972 {
1973 	/* Make sure our initial firmware request has completed */
1974 	wait_for_completion(&pcu->async_firmware_done);
1975 }
1976 
1977 #define IMS_PCU_APPLICATION_MODE	0
1978 #define IMS_PCU_BOOTLOADER_MODE		1
1979 
1980 static struct usb_driver ims_pcu_driver;
1981 
1982 static int ims_pcu_probe(struct usb_interface *intf,
1983 			 const struct usb_device_id *id)
1984 {
1985 	struct usb_device *udev = interface_to_usbdev(intf);
1986 	struct ims_pcu *pcu;
1987 	int error;
1988 
1989 	pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
1990 	if (!pcu)
1991 		return -ENOMEM;
1992 
1993 	pcu->dev = &intf->dev;
1994 	pcu->udev = udev;
1995 	pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
1996 	mutex_init(&pcu->cmd_mutex);
1997 	init_completion(&pcu->cmd_done);
1998 	init_completion(&pcu->async_firmware_done);
1999 
2000 	error = ims_pcu_parse_cdc_data(intf, pcu);
2001 	if (error)
2002 		goto err_free_mem;
2003 
2004 	error = usb_driver_claim_interface(&ims_pcu_driver,
2005 					   pcu->data_intf, pcu);
2006 	if (error) {
2007 		dev_err(&intf->dev,
2008 			"Unable to claim corresponding data interface: %d\n",
2009 			error);
2010 		goto err_free_mem;
2011 	}
2012 
2013 	usb_set_intfdata(pcu->ctrl_intf, pcu);
2014 	usb_set_intfdata(pcu->data_intf, pcu);
2015 
2016 	error = ims_pcu_buffers_alloc(pcu);
2017 	if (error)
2018 		goto err_unclaim_intf;
2019 
2020 	error = ims_pcu_start_io(pcu);
2021 	if (error)
2022 		goto err_free_buffers;
2023 
2024 	error = ims_pcu_line_setup(pcu);
2025 	if (error)
2026 		goto err_stop_io;
2027 
2028 	error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
2029 	if (error)
2030 		goto err_stop_io;
2031 
2032 	error = pcu->bootloader_mode ?
2033 			ims_pcu_init_bootloader_mode(pcu) :
2034 			ims_pcu_init_application_mode(pcu);
2035 	if (error)
2036 		goto err_remove_sysfs;
2037 
2038 	return 0;
2039 
2040 err_remove_sysfs:
2041 	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2042 err_stop_io:
2043 	ims_pcu_stop_io(pcu);
2044 err_free_buffers:
2045 	ims_pcu_buffers_free(pcu);
2046 err_unclaim_intf:
2047 	usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2048 err_free_mem:
2049 	kfree(pcu);
2050 	return error;
2051 }
2052 
2053 static void ims_pcu_disconnect(struct usb_interface *intf)
2054 {
2055 	struct ims_pcu *pcu = usb_get_intfdata(intf);
2056 	struct usb_host_interface *alt = intf->cur_altsetting;
2057 
2058 	usb_set_intfdata(intf, NULL);
2059 
2060 	/*
2061 	 * See if we are dealing with control or data interface. The cleanup
2062 	 * happens when we unbind primary (control) interface.
2063 	 */
2064 	if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
2065 		return;
2066 
2067 	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2068 
2069 	ims_pcu_stop_io(pcu);
2070 
2071 	if (pcu->bootloader_mode)
2072 		ims_pcu_destroy_bootloader_mode(pcu);
2073 	else
2074 		ims_pcu_destroy_application_mode(pcu);
2075 
2076 	ims_pcu_buffers_free(pcu);
2077 	kfree(pcu);
2078 }
2079 
2080 #ifdef CONFIG_PM
2081 static int ims_pcu_suspend(struct usb_interface *intf,
2082 			   pm_message_t message)
2083 {
2084 	struct ims_pcu *pcu = usb_get_intfdata(intf);
2085 	struct usb_host_interface *alt = intf->cur_altsetting;
2086 
2087 	if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
2088 		ims_pcu_stop_io(pcu);
2089 
2090 	return 0;
2091 }
2092 
2093 static int ims_pcu_resume(struct usb_interface *intf)
2094 {
2095 	struct ims_pcu *pcu = usb_get_intfdata(intf);
2096 	struct usb_host_interface *alt = intf->cur_altsetting;
2097 	int retval = 0;
2098 
2099 	if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
2100 		retval = ims_pcu_start_io(pcu);
2101 		if (retval == 0)
2102 			retval = ims_pcu_line_setup(pcu);
2103 	}
2104 
2105 	return retval;
2106 }
2107 #endif
2108 
2109 static const struct usb_device_id ims_pcu_id_table[] = {
2110 	{
2111 		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
2112 					USB_CLASS_COMM,
2113 					USB_CDC_SUBCLASS_ACM,
2114 					USB_CDC_ACM_PROTO_AT_V25TER),
2115 		.driver_info = IMS_PCU_APPLICATION_MODE,
2116 	},
2117 	{
2118 		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
2119 					USB_CLASS_COMM,
2120 					USB_CDC_SUBCLASS_ACM,
2121 					USB_CDC_ACM_PROTO_AT_V25TER),
2122 		.driver_info = IMS_PCU_BOOTLOADER_MODE,
2123 	},
2124 	{ }
2125 };
2126 
2127 static struct usb_driver ims_pcu_driver = {
2128 	.name			= "ims_pcu",
2129 	.id_table		= ims_pcu_id_table,
2130 	.probe			= ims_pcu_probe,
2131 	.disconnect		= ims_pcu_disconnect,
2132 #ifdef CONFIG_PM
2133 	.suspend		= ims_pcu_suspend,
2134 	.resume			= ims_pcu_resume,
2135 	.reset_resume		= ims_pcu_resume,
2136 #endif
2137 };
2138 
2139 module_usb_driver(ims_pcu_driver);
2140 
2141 MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
2142 MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
2143 MODULE_LICENSE("GPL");
2144