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