projects/linux·blob master · refs

2262 lines · 55.1 KiB

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