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