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 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 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 > 0) {
1639 union_desc = (struct usb_cdc_union_desc *)buf;
1640
1641 if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
1642 union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
1643 dev_dbg(&intf->dev, "Found union header\n");
1644 return union_desc;
1645 }
1646
1647 buflen -= union_desc->bLength;
1648 buf += union_desc->bLength;
1649 }
1650
1651 dev_err(&intf->dev, "Missing CDC union descriptor\n");
1652 return NULL;
1653}
1654
1655static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
1656{
1657 const struct usb_cdc_union_desc *union_desc;
1658 struct usb_host_interface *alt;
1659
1660 union_desc = ims_pcu_get_cdc_union_desc(intf);
1661 if (!union_desc)
1662 return -EINVAL;
1663
1664 pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
1665 union_desc->bMasterInterface0);
1666
1667 alt = pcu->ctrl_intf->cur_altsetting;
1668 pcu->ep_ctrl = &alt->endpoint[0].desc;
1669 pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
1670
1671 pcu->data_intf = usb_ifnum_to_if(pcu->udev,
1672 union_desc->bSlaveInterface0);
1673
1674 alt = pcu->data_intf->cur_altsetting;
1675 if (alt->desc.bNumEndpoints != 2) {
1676 dev_err(pcu->dev,
1677 "Incorrect number of endpoints on data interface (%d)\n",
1678 alt->desc.bNumEndpoints);
1679 return -EINVAL;
1680 }
1681
1682 pcu->ep_out = &alt->endpoint[0].desc;
1683 if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
1684 dev_err(pcu->dev,
1685 "First endpoint on data interface is not BULK OUT\n");
1686 return -EINVAL;
1687 }
1688
1689 pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
1690 if (pcu->max_out_size < 8) {
1691 dev_err(pcu->dev,
1692 "Max OUT packet size is too small (%zd)\n",
1693 pcu->max_out_size);
1694 return -EINVAL;
1695 }
1696
1697 pcu->ep_in = &alt->endpoint[1].desc;
1698 if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
1699 dev_err(pcu->dev,
1700 "Second endpoint on data interface is not BULK IN\n");
1701 return -EINVAL;
1702 }
1703
1704 pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
1705 if (pcu->max_in_size < 8) {
1706 dev_err(pcu->dev,
1707 "Max IN packet size is too small (%zd)\n",
1708 pcu->max_in_size);
1709 return -EINVAL;
1710 }
1711
1712 return 0;
1713}
1714
1715static int ims_pcu_start_io(struct ims_pcu *pcu)
1716{
1717 int error;
1718
1719 error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
1720 if (error) {
1721 dev_err(pcu->dev,
1722 "Failed to start control IO - usb_submit_urb failed with result: %d\n",
1723 error);
1724 return -EIO;
1725 }
1726
1727 error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
1728 if (error) {
1729 dev_err(pcu->dev,
1730 "Failed to start IO - usb_submit_urb failed with result: %d\n",
1731 error);
1732 usb_kill_urb(pcu->urb_ctrl);
1733 return -EIO;
1734 }
1735
1736 return 0;
1737}
1738
1739static void ims_pcu_stop_io(struct ims_pcu *pcu)
1740{
1741 usb_kill_urb(pcu->urb_in);
1742 usb_kill_urb(pcu->urb_ctrl);
1743}
1744
1745static int ims_pcu_line_setup(struct ims_pcu *pcu)
1746{
1747 struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
1748 struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
1749 int error;
1750
1751 memset(line, 0, sizeof(*line));
1752 line->dwDTERate = cpu_to_le32(57600);
1753 line->bDataBits = 8;
1754
1755 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1756 USB_CDC_REQ_SET_LINE_CODING,
1757 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1758 0, interface->desc.bInterfaceNumber,
1759 line, sizeof(struct usb_cdc_line_coding),
1760 5000);
1761 if (error < 0) {
1762 dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
1763 error);
1764 return error;
1765 }
1766
1767 error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
1768 USB_CDC_REQ_SET_CONTROL_LINE_STATE,
1769 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1770 0x03, interface->desc.bInterfaceNumber,
1771 NULL, 0, 5000);
1772 if (error < 0) {
1773 dev_err(pcu->dev, "Failed to set line state, error: %d\n",
1774 error);
1775 return error;
1776 }
1777
1778 return 0;
1779}
1780
1781static int ims_pcu_get_device_info(struct ims_pcu *pcu)
1782{
1783 int error;
1784
1785 error = ims_pcu_get_info(pcu);
1786 if (error)
1787 return error;
1788
1789 error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
1790 if (error) {
1791 dev_err(pcu->dev,
1792 "GET_FW_VERSION command failed, error: %d\n", error);
1793 return error;
1794 }
1795
1796 snprintf(pcu->fw_version, sizeof(pcu->fw_version),
1797 "%02d%02d%02d%02d.%c%c",
1798 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1799 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1800
1801 error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
1802 if (error) {
1803 dev_err(pcu->dev,
1804 "GET_BL_VERSION command failed, error: %d\n", error);
1805 return error;
1806 }
1807
1808 snprintf(pcu->bl_version, sizeof(pcu->bl_version),
1809 "%02d%02d%02d%02d.%c%c",
1810 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
1811 pcu->cmd_buf[6], pcu->cmd_buf[7]);
1812
1813 error = ims_pcu_execute_query(pcu, RESET_REASON);
1814 if (error) {
1815 dev_err(pcu->dev,
1816 "RESET_REASON command failed, error: %d\n", error);
1817 return error;
1818 }
1819
1820 snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
1821 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
1822
1823 dev_dbg(pcu->dev,
1824 "P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
1825 pcu->part_number,
1826 pcu->date_of_manufacturing,
1827 pcu->serial_number,
1828 pcu->fw_version,
1829 pcu->bl_version,
1830 pcu->reset_reason);
1831
1832 return 0;
1833}
1834
1835static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
1836{
1837 int error;
1838
1839 error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
1840 if (error) {
1841 dev_err(pcu->dev,
1842 "GET_DEVICE_ID command failed, error: %d\n", error);
1843 return error;
1844 }
1845
1846 *device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
1847 dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
1848
1849 return 0;
1850}
1851
1852static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
1853{
1854 static atomic_t device_no = ATOMIC_INIT(-1);
1855
1856 const struct ims_pcu_device_info *info;
1857 int error;
1858
1859 error = ims_pcu_get_device_info(pcu);
1860 if (error) {
1861
1862 return error;
1863 }
1864
1865 error = ims_pcu_identify_type(pcu, &pcu->device_id);
1866 if (error) {
1867 dev_err(pcu->dev,
1868 "Failed to identify device, error: %d\n", error);
1869
1870
1871
1872
1873
1874 return 0;
1875 }
1876
1877 if (pcu->device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
1878 !ims_pcu_device_info[pcu->device_id].keymap) {
1879 dev_err(pcu->dev, "Device ID %d is not valid\n", pcu->device_id);
1880
1881 return 0;
1882 }
1883
1884
1885 pcu->device_no = atomic_inc_return(&device_no);
1886
1887
1888
1889
1890 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID) {
1891 error = sysfs_create_group(&pcu->dev->kobj,
1892 &ims_pcu_ofn_attr_group);
1893 if (error)
1894 return error;
1895 }
1896
1897 error = ims_pcu_setup_backlight(pcu);
1898 if (error)
1899 return error;
1900
1901 info = &ims_pcu_device_info[pcu->device_id];
1902 error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
1903 if (error)
1904 goto err_destroy_backlight;
1905
1906 if (info->has_gamepad) {
1907 error = ims_pcu_setup_gamepad(pcu);
1908 if (error)
1909 goto err_destroy_buttons;
1910 }
1911
1912 pcu->setup_complete = true;
1913
1914 return 0;
1915
1916err_destroy_buttons:
1917 ims_pcu_destroy_buttons(pcu);
1918err_destroy_backlight:
1919 ims_pcu_destroy_backlight(pcu);
1920 return error;
1921}
1922
1923static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
1924{
1925 if (pcu->setup_complete) {
1926 pcu->setup_complete = false;
1927 mb();
1928
1929 if (pcu->gamepad)
1930 ims_pcu_destroy_gamepad(pcu);
1931 ims_pcu_destroy_buttons(pcu);
1932 ims_pcu_destroy_backlight(pcu);
1933
1934 if (pcu->device_id != IMS_PCU_PCU_B_DEVICE_ID)
1935 sysfs_remove_group(&pcu->dev->kobj,
1936 &ims_pcu_ofn_attr_group);
1937 }
1938}
1939
1940static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
1941{
1942 int error;
1943
1944 error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
1945 IMS_PCU_CMD_RESPONSE_TIMEOUT);
1946 if (error) {
1947 dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
1948 return error;
1949 }
1950
1951 pcu->fw_start_addr =
1952 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
1953 pcu->fw_end_addr =
1954 get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
1955
1956 dev_info(pcu->dev,
1957 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
1958 pcu->fw_start_addr, pcu->fw_end_addr);
1959
1960 error = request_firmware_nowait(THIS_MODULE, true,
1961 IMS_PCU_FIRMWARE_NAME,
1962 pcu->dev, GFP_KERNEL, pcu,
1963 ims_pcu_process_async_firmware);
1964 if (error) {
1965
1966 complete(&pcu->async_firmware_done);
1967 }
1968
1969 return 0;
1970}
1971
1972static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
1973{
1974
1975 wait_for_completion(&pcu->async_firmware_done);
1976}
1977
1978#define IMS_PCU_APPLICATION_MODE 0
1979#define IMS_PCU_BOOTLOADER_MODE 1
1980
1981static struct usb_driver ims_pcu_driver;
1982
1983static int ims_pcu_probe(struct usb_interface *intf,
1984 const struct usb_device_id *id)
1985{
1986 struct usb_device *udev = interface_to_usbdev(intf);
1987 struct ims_pcu *pcu;
1988 int error;
1989
1990 pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
1991 if (!pcu)
1992 return -ENOMEM;
1993
1994 pcu->dev = &intf->dev;
1995 pcu->udev = udev;
1996 pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
1997 mutex_init(&pcu->cmd_mutex);
1998 init_completion(&pcu->cmd_done);
1999 init_completion(&pcu->async_firmware_done);
2000
2001 error = ims_pcu_parse_cdc_data(intf, pcu);
2002 if (error)
2003 goto err_free_mem;
2004
2005 error = usb_driver_claim_interface(&ims_pcu_driver,
2006 pcu->data_intf, pcu);
2007 if (error) {
2008 dev_err(&intf->dev,
2009 "Unable to claim corresponding data interface: %d\n",
2010 error);
2011 goto err_free_mem;
2012 }
2013
2014 usb_set_intfdata(pcu->ctrl_intf, pcu);
2015 usb_set_intfdata(pcu->data_intf, pcu);
2016
2017 error = ims_pcu_buffers_alloc(pcu);
2018 if (error)
2019 goto err_unclaim_intf;
2020
2021 error = ims_pcu_start_io(pcu);
2022 if (error)
2023 goto err_free_buffers;
2024
2025 error = ims_pcu_line_setup(pcu);
2026 if (error)
2027 goto err_stop_io;
2028
2029 error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
2030 if (error)
2031 goto err_stop_io;
2032
2033 error = pcu->bootloader_mode ?
2034 ims_pcu_init_bootloader_mode(pcu) :
2035 ims_pcu_init_application_mode(pcu);
2036 if (error)
2037 goto err_remove_sysfs;
2038
2039 return 0;
2040
2041err_remove_sysfs:
2042 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2043err_stop_io:
2044 ims_pcu_stop_io(pcu);
2045err_free_buffers:
2046 ims_pcu_buffers_free(pcu);
2047err_unclaim_intf:
2048 usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
2049err_free_mem:
2050 kfree(pcu);
2051 return error;
2052}
2053
2054static void ims_pcu_disconnect(struct usb_interface *intf)
2055{
2056 struct ims_pcu *pcu = usb_get_intfdata(intf);
2057 struct usb_host_interface *alt = intf->cur_altsetting;
2058
2059 usb_set_intfdata(intf, NULL);
2060
2061
2062
2063
2064
2065 if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
2066 return;
2067
2068 sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
2069
2070 ims_pcu_stop_io(pcu);
2071
2072 if (pcu->bootloader_mode)
2073 ims_pcu_destroy_bootloader_mode(pcu);
2074 else
2075 ims_pcu_destroy_application_mode(pcu);
2076
2077 ims_pcu_buffers_free(pcu);
2078 kfree(pcu);
2079}
2080
2081#ifdef CONFIG_PM
2082static int ims_pcu_suspend(struct usb_interface *intf,
2083 pm_message_t message)
2084{
2085 struct ims_pcu *pcu = usb_get_intfdata(intf);
2086 struct usb_host_interface *alt = intf->cur_altsetting;
2087
2088 if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
2089 ims_pcu_stop_io(pcu);
2090
2091 return 0;
2092}
2093
2094static int ims_pcu_resume(struct usb_interface *intf)
2095{
2096 struct ims_pcu *pcu = usb_get_intfdata(intf);
2097 struct usb_host_interface *alt = intf->cur_altsetting;
2098 int retval = 0;
2099
2100 if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
2101 retval = ims_pcu_start_io(pcu);
2102 if (retval == 0)
2103 retval = ims_pcu_line_setup(pcu);
2104 }
2105
2106 return retval;
2107}
2108#endif
2109
2110static const struct usb_device_id ims_pcu_id_table[] = {
2111 {
2112 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
2113 USB_CLASS_COMM,
2114 USB_CDC_SUBCLASS_ACM,
2115 USB_CDC_ACM_PROTO_AT_V25TER),
2116 .driver_info = IMS_PCU_APPLICATION_MODE,
2117 },
2118 {
2119 USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
2120 USB_CLASS_COMM,
2121 USB_CDC_SUBCLASS_ACM,
2122 USB_CDC_ACM_PROTO_AT_V25TER),
2123 .driver_info = IMS_PCU_BOOTLOADER_MODE,
2124 },
2125 { }
2126};
2127
2128static struct usb_driver ims_pcu_driver = {
2129 .name = "ims_pcu",
2130 .id_table = ims_pcu_id_table,
2131 .probe = ims_pcu_probe,
2132 .disconnect = ims_pcu_disconnect,
2133#ifdef CONFIG_PM
2134 .suspend = ims_pcu_suspend,
2135 .resume = ims_pcu_resume,
2136 .reset_resume = ims_pcu_resume,
2137#endif
2138};
2139
2140module_usb_driver(ims_pcu_driver);
2141
2142MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
2143MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
2144MODULE_LICENSE("GPL");
2145
