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