1
2
3
4
5
6
7
8
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 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
58struct ims_pcu {
59 struct usb_device *udev;
60 struct device *dev;
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;
119};
120
121
122
123
124
125
126static 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
135static const unsigned short ims_pcu_keymap_2[] = {
136 [4] = KEY_VOLUMEUP,
137 [5] = KEY_VOLUMEDOWN,
138 [6] = KEY_INFO,
139};
140
141static 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
151static 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
161static const unsigned short ims_pcu_keymap_5[] = {
162 [1] = KEY_ATTENDANT_OFF,
163 [2] = KEY_ATTENDANT_ON,
164 [3] = KEY_LIGHTS_TOGGLE,
165};
166
167struct 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
180static 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
188static 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
204static 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
255static 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
265
266
267static 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
289static 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
340err_free_mem:
341 input_free_device(input);
342 kfree(gamepad);
343 return -ENOMEM;
344}
345
346static 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
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
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
379#define IMS_PCU_CMD_OFN_SET_CONFIG 0xb3
380#define IMS_PCU_CMD_OFN_GET_CONFIG 0xb4
381
382
383#define IMS_PCU_RSP_STATUS 0xc0
384#define IMS_PCU_RSP_PCU_RESET 0
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
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
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
404#define IMS_PCU_GAMEPAD_MASK 0x0001ff80UL
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
411#define IMS_PCU_CMD_RESPONSE_TIMEOUT 500
412
413static 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
422static 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
433
434
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
447static 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
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
507static 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
514static 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
534static 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
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
600static 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
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
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
650#define IMS_PCU_BL_RSP_LAUNCH_APP 0
651
652#define IMS_PCU_BL_DATA_OFFSET 3
653
654static 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
696static 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
720static 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
744static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu)
745{
746 int error;
747
748
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
762
763
764#define IMS_PCU_FIRMWARE_NAME "imspcu.fw"
765
766struct ims_pcu_flash_fmt {
767 __le32 addr;
768 u8 len;
769 u8 data[];
770};
771
772static 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
785static 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
824static 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
846
847
848
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
890static 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
911out:
912 pcu->update_firmware_status = retval;
913 sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
914 return retval;
915}
916
917static 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
942out:
943 complete(&pcu->async_firmware_done);
944}
945
946
947
948
949
950#define IMS_PCU_MAX_BRIGHTNESS 31998
951
952static 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
974static 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
984static enum led_brightness
985ims_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
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
1013static 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
1038static 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
1049
1050
1051struct ims_pcu_attribute {
1052 struct device_attribute dattr;
1053 size_t field_offset;
1054 int field_length;
1055};
1056
1057static 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
1070static 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
1101
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) \
1111struct 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
1124static IMS_PCU_RW_ATTR(part_number);
1125static IMS_PCU_RW_ATTR(serial_number);
1126static IMS_PCU_RW_ATTR(date_of_manufacturing);
1127
1128static IMS_PCU_RO_ATTR(fw_version);
1129static IMS_PCU_RO_ATTR(bl_version);
1130static IMS_PCU_RO_ATTR(reset_reason);
1131
1132static 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
1162static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device);
1163
1164static 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
1194
1195
1196
1197
1198
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
1207out:
1208 mutex_unlock(&pcu->cmd_mutex);
1209 return error ?: count;
1210}
1211
1212static DEVICE_ATTR(update_firmware, S_IWUSR,
1213 NULL, ims_pcu_update_firmware_store);
1214
1215static ssize_t
1216ims_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
1226static DEVICE_ATTR(update_firmware_status, S_IRUGO,
1227 ims_pcu_update_firmware_status_show, NULL);
1228
1229static 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
1242static 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
1264static const struct attribute_group ims_pcu_attr_group = {
1265 .is_visible = ims_pcu_is_attr_visible,
1266 .attrs = ims_pcu_attrs,
1267};
1268
1269
1270
1271#define OFN_REG_RESULT_OFFSET 2
1272
1273static 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
1288 *data = pcu->cmd_buf[OFN_REG_RESULT_OFFSET];
1289 return 0;
1290}
1291
1292static 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
1310static 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
1329static 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
1349static DEVICE_ATTR(reg_data, S_IRUGO | S_IWUSR,
1350 ims_pcu_ofn_reg_data_show, ims_pcu_ofn_reg_data_store);
1351
1352static 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
1367static 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 count;
1385}
1386
1387static DEVICE_ATTR(reg_addr, S_IRUGO | S_IWUSR,
1388 ims_pcu_ofn_reg_addr_show, ims_pcu_ofn_reg_addr_store);
1389
1390struct ims_pcu_ofn_bit_attribute {
1391 struct device_attribute dattr;
1392 u8 addr;
1393 u8 nr;
1394};
1395
1396static 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
1417static 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) \
1454struct 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
1461static IMS_PCU_OFN_BIT_ATTR(engine_enable, 0x60, 7);
1462static IMS_PCU_OFN_BIT_ATTR(speed_enable, 0x60, 6);
1463static IMS_PCU_OFN_BIT_ATTR(assert_enable, 0x60, 5);
1464static IMS_PCU_OFN_BIT_ATTR(xyquant_enable, 0x60, 4);
1465static IMS_PCU_OFN_BIT_ATTR(xyscale_enable, 0x60, 1);
1466
1467static IMS_PCU_OFN_BIT_ATTR(scale_x2, 0x63, 6);
1468static IMS_PCU_OFN_BIT_ATTR(scale_y2, 0x63, 7);
1469
1470static 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
1483static const struct attribute_group ims_pcu_ofn_attr_group = {
1484 .name = "ofn",
1485 .attrs = ims_pcu_ofn_attrs,
1486};
1487
1488static 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
1498 break;
1499 case -ECONNRESET:
1500 case -ENOENT:
1501 case -ESHUTDOWN:
1502
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
1518exit:
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
1525static 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
1555
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 error = -ENOMEM;
1570 goto err_free_urb_out_buf;
1571 }
1572
1573 pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
1574 if (!pcu->urb_ctrl) {
1575 dev_err(pcu->dev, "Failed to allocate input URB\n");
1576 error = -ENOMEM;
1577 goto err_free_urb_ctrl_buf;
1578 }
1579
1580 pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1581 pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;
1582
1583 usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
1584 usb_rcvintpipe(pcu->udev,
1585 pcu->ep_ctrl->bEndpointAddress),
1586 pcu->urb_ctrl_buf, pcu->max_ctrl_size,
1587 ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);
1588
1589 return 0;
1590
1591err_free_urb_ctrl_buf:
1592 usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1593 pcu->urb_ctrl_buf, pcu->ctrl_dma);
1594err_free_urb_out_buf:
1595 kfree(pcu->urb_out_buf);
1596err_free_in_urb:
1597 usb_free_urb(pcu->urb_in);
1598err_free_urb_in_buf:
1599 usb_free_coherent(pcu->udev, pcu->max_in_size,
1600 pcu->urb_in_buf, pcu->read_dma);
1601 return error;
1602}
1603
1604static void ims_pcu_buffers_free(struct ims_pcu *pcu)
1605{
1606 usb_kill_urb(pcu->urb_in);
1607 usb_free_urb(pcu->urb_in);
1608
1609 usb_free_coherent(pcu->udev, pcu->max_out_size,
1610 pcu->urb_in_buf, pcu->read_dma);
1611
1612 kfree(pcu->urb_out_buf);
1613
1614 usb_kill_urb(pcu->urb_ctrl);
1615 usb_free_urb(pcu->urb_ctrl);
1616
1617 usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
1618 pcu->urb_ctrl_buf, pcu->ctrl_dma);
1619}
1620
1621static const struct usb_cdc_union_desc *
1622ims_pcu_get_cdc_union_desc(struct usb_interface *intf)
1623{
1624 const void *buf = intf->altsetting->extra;
1625 size_t buflen = intf->altsetting->extralen;
1626 struct usb_cdc_union_desc *union_desc;
1627
1628 if (!buf) {
1629 dev_err(&intf->dev, "Missing descriptor data\n");
1630 return NULL;
1631 }
1632
1633 if (!buflen) {
1634 dev_err(&intf->dev, "Zero length descriptor\n");
1635 return NULL;
1636 }
1637
1638 while (buflen >= sizeof(*union_desc)) {
1639 union_desc = (struct usb_cdc_union_desc *)buf;
1640
1641 if (union_desc->bLength > buflen) {
1642 dev_err(&intf->dev, "Too large descriptor\n");
1643 return NULL;
1644 }
1645
1646 if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
1647 union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
1648 dev_dbg(&intf->dev, "Found union header\n");
1649
1650 if (union_desc->bLength >= sizeof(*union_desc))
1651 return union_desc;
1652
1653 dev_err(&intf->dev,
1654 "Union descriptor too short (%d vs %zd)\n",
1655 union_desc->bLength, sizeof(*union_desc));
1656 return NULL;
1657 }
1658
1659 buflen -= union_desc->bLength;
1660 buf += union_desc->bLength;
1661 }
1662
1663 dev_err(&intf->dev, "Missing CDC union descriptor\n");
1664 return NULL;
1665}
1666
1667static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1668{
1669 const struct usb_cdc_union_desc *union_desc;
1670 struct usb_host_interface *alt;
1671
1672 union_desc = ims_pcu_get_cdc_union_desc(intf);
1673 if (!union_desc)
1674 return -EINVAL;
1675
1676 pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1677 union_desc->bMasterInterface0);
1678 if (!pcu->ctrl_intf)
1679 return -EINVAL;
1680
1681 alt = pcu->ctrl_intf->cur_altsetting;
1682
1683 if (alt->desc.bNumEndpoints < 1)
1684 return -ENODEV;
1685
1686 pcu->ep_ctrl = &alt->endpoint[0].desc;
1687 pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1688
1689 pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1690 union_desc->bSlaveInterface0);
1691 if (!pcu->data_intf)
1692 return -EINVAL;
1693
1694 alt = pcu->data_intf->cur_altsetting;
1695 if (alt->desc.bNumEndpoints != 2) {
1696 dev_err(pcu->dev,
1697 "Incorrect number of endpoints on data interface (%d)\n",
1698 alt->desc.bNumEndpoints);
1699 return -EINVAL;
1700 }
1701
1702 pcu->ep_out = &alt->endpoint[0].desc;
1703 if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1704 dev_err(pcu->dev,
1705 "First endpoint on data interface is not BULK OUT\n");
1706 return -EINVAL;
1707 }
1708
1709 pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1710 if (pcu->max_out_size < 8) {
1711 dev_err(pcu->dev,
1712 "Max OUT packet size is too small (%zd)\n",
1713 pcu->max_out_size);
1714 return -EINVAL;
1715 }
1716
1717 pcu->ep_in = &alt->endpoint[1].desc;
1718 if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1719 dev_err(pcu->dev,
1720 "Second endpoint on data interface is not BULK IN\n");
1721 return -EINVAL;
1722 }
1723
1724 pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1725 if (pcu->max_in_size < 8) {
1726 dev_err(pcu->dev,
1727 "Max IN packet size is too small (%zd)\n",
1728 pcu->max_in_size);
1729 return -EINVAL;
1730 }
1731
1732 return 0;
1733}
1734
1735static int ims_pcu_start_io(struct ims_pcu *pcu)
1736{
1737 int error;
1738
1739 error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1740 if (error) {
1741 dev_err(pcu->dev,
1742 "Failed to start control IO - usb_submit_urb failed with result: %d\n",
1743 error);
1744 return -EIO;
1745 }
1746
1747 error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1748 if (error) {
1749 dev_err(pcu->dev,
1750 "Failed to start IO - usb_submit_urb failed with result: %d\n",
1751 error);
1752 usb_kill_urb(pcu->urb_ctrl);
1753 return -EIO;
1754 }
1755
1756 return 0;
1757}
1758
1759static void ims_pcu_stop_io(struct ims_pcu *pcu)
1760{
1761 usb_kill_urb(pcu->urb_in);
1762 usb_kill_urb(pcu->urb_ctrl);
1763}
1764
1765static int ims_pcu_line_setup(struct ims_pcu *pcu)
1766{
1767 struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1768 struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1769 int error;
1770
1771 memset(line, 0, sizeof(*line));
1772 line->dwDTERate = cpu_to_le32(57600);
1773 line->bDataBits = 8;
1774
1775 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1776 USB_CDC_REQ_SET_LINE_CODING,
1777 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1778 0, interface->desc.bInterfaceNumber,
1779 line, sizeof(struct usb_cdc_line_coding),
1780 5000);
1781 if (error < 0) {
1782 dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1783 error);
1784 return error;
1785 }
1786
1787 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1788 USB_CDC_REQ_SET_CONTROL_LINE_STATE,
1789 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1790 0x03, interface->desc.bInterfaceNumber,
1791 NULL, 0, 5000);
1792 if (error < 0) {
1793 dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1794 error);
1795 return error;
1796 }
1797
1798 return 0;
1799}
1800
1801static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1802{
1803 int error;
1804
1805 error = ims_pcu_get_info(pcu);
1806 if (error)
1807 return error;
1808
1809 error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1810 if (error) {
1811 dev_err(pcu->dev,
1812 "GET_FW_VERSION command failed, error: %d\n", error);
1813 return error;
1814 }
1815
1816 snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1817 "%02d%02d%02d%02d.%c%c",
1818 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1819 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1820
1821 error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1822 if (error) {
1823 dev_err(pcu->dev,
1824 "GET_BL_VERSION command failed, error: %d\n", error);
1825 return error;
1826 }
1827
1828 snprintf(pcu->bl_version, sizeof(pcu->bl_version),
1829 "%02d%02d%02d%02d.%c%c",
1830 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1831 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1832
1833 error = ims_pcu_execute_query(pcu, RESET_REASON);
1834 if (error) {
1835 dev_err(pcu->dev,
1836 "RESET_REASON command failed, error: %d\n", error);
1837 return error;
1838 }
1839
1840 snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1841 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1842
1843 dev_dbg(pcu->dev,
1844 "P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
1845 pcu->part_number,
1846 pcu->date_of_manufacturing,
1847 pcu->serial_number,
1848 pcu->fw_version,
1849 pcu->bl_version,
1850 pcu->reset_reason);
1851
1852 return 0;
1853}
1854
1855static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1856{
1857 int error;
1858
1859 error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1860 if (error) {
1861 dev_err(pcu->dev,
1862 "GET_DEVICE_ID command failed, error: %d\n", error);
1863 return error;
1864 }
1865
1866 *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1867 dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1868
1869 return 0;
1870}
1871
1872static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1873{
1874 static atomic_t device_no = ATOMIC_INIT(-1);
1875
1876 const struct ims_pcu_device_info *info;
1877 int error;
1878
1879 error = ims_pcu_get_device_info(pcu);
1880 if (error) {
1881
1882 return error;
1883 }
1884
1885 error = ims_pcu_identify_type(pcu, &pcu->device_id);
1886 if (error) {
1887 dev_err(pcu->dev,
1888 "Failed to identify device, error: %d\n", error);
1889
1890
1891
1892
1893
1894 return 0;
1895 }
1896
1897 if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1898 !ims_pcu_device_info[pcu->device_id].keymap) {
1899 dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1900
1901 return 0;
1902 }
1903
1904
1905 pcu->device_no = atomic_inc_return(&device_no);
1906
1907
1908
1909
1910 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1911 error = sysfs_create_group(&pcu->dev->kobj,
1912 &ims_pcu_ofn_attr_group);
1913 if (error)
1914 return error;
1915 }
1916
1917 error = ims_pcu_setup_backlight(pcu);
1918 if (error)
1919 return error;
1920
1921 info = &ims_pcu_device_info[pcu->device_id];
1922 error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1923 if (error)
1924 goto err_destroy_backlight;
1925
1926 if (info->has_gamepad) {
1927 error = ims_pcu_setup_gamepad(pcu);
1928 if (error)
1929 goto err_destroy_buttons;
1930 }
1931
1932 pcu->setup_complete = true;
1933
1934 return 0;
1935
1936err_destroy_buttons:
1937 ims_pcu_destroy_buttons(pcu);
1938err_destroy_backlight:
1939 ims_pcu_destroy_backlight(pcu);
1940 return error;
1941}
1942
1943static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1944{
1945 if (pcu->setup_complete) {
1946 pcu->setup_complete = false;
1947 mb();
1948
1949 if (pcu->gamepad)
1950 ims_pcu_destroy_gamepad(pcu);
1951 ims_pcu_destroy_buttons(pcu);
1952 ims_pcu_destroy_backlight(pcu);
1953
1954 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1955 sysfs_remove_group(&pcu->dev->kobj,
1956 &ims_pcu_ofn_attr_group);
1957 }
1958}
1959
1960static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1961{
1962 int error;
1963
1964 error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1965 IMS_PCU_CMD_RESPONSE_TIMEOUT);
1966 if (error) {
1967 dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1968 return error;
1969 }
1970
1971 pcu->fw_start_addr =
1972 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1973 pcu->fw_end_addr =
1974 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1975
1976 dev_info(pcu->dev,
1977 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
1978 pcu->fw_start_addr, pcu->fw_end_addr);
1979
1980 error = request_firmware_nowait(THIS_MODULE, true,
1981 IMS_PCU_FIRMWARE_NAME,
1982 pcu->dev, GFP_KERNEL, pcu,
1983 ims_pcu_process_async_firmware);
1984 if (error) {
1985
1986 complete(&pcu->async_firmware_done);
1987 }
1988
1989 return 0;
1990}
1991
1992static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1993{
1994
1995 wait_for_completion(&pcu->async_firmware_done);
1996}
1997
1998#define IMS_PCU_APPLICATION_MODE 0
1999#define IMS_PCU_BOOTLOADER_MODE 1
2000
2001static struct usb_driver ims_pcu_driver;
2002
2003static int ims_pcu_probe(struct usb_interface *intf,
2004 const struct usb_device_id *id)
2005{
2006 struct usb_device *udev = interface_to_usbdev(intf);
2007 struct ims_pcu *pcu;
2008 int error;
2009
2010 pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
2011 if (!pcu)
2012 return -ENOMEM;
2013
2014 pcu->dev = &intf->dev;
2015 pcu->udev = udev;
2016 pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
2017 mutex_init(&pcu->cmd_mutex);
2018 init_completion(&pcu->cmd_done);
2019 init_completion(&pcu->async_firmware_done);
2020
2021 error = ims_pcu_parse_cdc_data(intf, pcu);
2022 if (error)
2023 goto err_free_mem;
2024
2025 error = usb_driver_claim_interface(&ims_pcu_driver,
2026 pcu->data_intf, pcu);
2027 if (error) {
2028 dev_err(&intf->dev,
2029 "Unable to claim corresponding data interface: %d\n",
2030 error);
2031 goto err_free_mem;
2032 }
2033
2034 usb_set_intfdata(pcu->ctrl_intf, pcu);
2035 usb_set_intfdata(pcu->data_intf, pcu);
2036
2037 error = ims_pcu_buffers_alloc(pcu);
2038 if (error)
2039 goto err_unclaim_intf;
2040
2041 error = ims_pcu_start_io(pcu);
2042 if (error)
2043 goto err_free_buffers;
2044
2045 error = ims_pcu_line_setup(pcu);
2046 if (error)
2047 goto err_stop_io;
2048
2049 error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
2050 if (error)
2051 goto err_stop_io;
2052
2053 error = pcu->bootloader_mode ?
2054 ims_pcu_init_bootloader_mode(pcu) :
2055 ims_pcu_init_application_mode(pcu);
2056 if (error)
2057 goto err_remove_sysfs;
2058
2059 return 0;
2060
2061err_remove_sysfs:
2062 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2063err_stop_io:
2064 ims_pcu_stop_io(pcu);
2065err_free_buffers:
2066 ims_pcu_buffers_free(pcu);
2067err_unclaim_intf:
2068 usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2069err_free_mem:
2070 kfree(pcu);
2071 return error;
2072}
2073
2074static void ims_pcu_disconnect(struct usb_interface *intf)
2075{
2076 struct ims_pcu *pcu = usb_get_intfdata(intf);
2077 struct usb_host_interface *alt = intf->cur_altsetting;
2078
2079 usb_set_intfdata(intf, NULL);
2080
2081
2082
2083
2084
2085 if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
2086 return;
2087
2088 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2089
2090 ims_pcu_stop_io(pcu);
2091
2092 if (pcu->bootloader_mode)
2093 ims_pcu_destroy_bootloader_mode(pcu);
2094 else
2095 ims_pcu_destroy_application_mode(pcu);
2096
2097 ims_pcu_buffers_free(pcu);
2098 kfree(pcu);
2099}
2100
2101#ifdef CONFIG_PM
2102static int ims_pcu_suspend(struct usb_interface *intf,
2103 pm_message_t message)
2104{
2105 struct ims_pcu *pcu = usb_get_intfdata(intf);
2106 struct usb_host_interface *alt = intf->cur_altsetting;
2107
2108 if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
2109 ims_pcu_stop_io(pcu);
2110
2111 return 0;
2112}
2113
2114static int ims_pcu_resume(struct usb_interface *intf)
2115{
2116 struct ims_pcu *pcu = usb_get_intfdata(intf);
2117 struct usb_host_interface *alt = intf->cur_altsetting;
2118 int retval = 0;
2119
2120 if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
2121 retval = ims_pcu_start_io(pcu);
2122 if (retval == 0)
2123 retval = ims_pcu_line_setup(pcu);
2124 }
2125
2126 return retval;
2127}
2128#endif
2129
2130static const struct usb_device_id ims_pcu_id_table[] = {
2131 {
2132 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
2133 USB_CLASS_COMM,
2134 USB_CDC_SUBCLASS_ACM,
2135 USB_CDC_ACM_PROTO_AT_V25TER),
2136 .driver_info = IMS_PCU_APPLICATION_MODE,
2137 },
2138 {
2139 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
2140 USB_CLASS_COMM,
2141 USB_CDC_SUBCLASS_ACM,
2142 USB_CDC_ACM_PROTO_AT_V25TER),
2143 .driver_info = IMS_PCU_BOOTLOADER_MODE,
2144 },
2145 { }
2146};
2147
2148static struct usb_driver ims_pcu_driver = {
2149 .name = "ims_pcu",
2150 .id_table = ims_pcu_id_table,
2151 .probe = ims_pcu_probe,
2152 .disconnect = ims_pcu_disconnect,
2153#ifdef CONFIG_PM
2154 .suspend = ims_pcu_suspend,
2155 .resume = ims_pcu_resume,
2156 .reset_resume = ims_pcu_resume,
2157#endif
2158};
2159
2160module_usb_driver(ims_pcu_driver);
2161
2162MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
2163MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
2164MODULE_LICENSE("GPL");
2165
