V4L/DVB: IR/mceusb: misc cleanups and init fixes

#define USB_BUFLEN	32	/* USB reception buffer length */

#define IRBUF_SIZE	256	/* IR work buffer length */

#define USB_CTRL_MSG_SZ	2	/* Size of usb ctrl msg on gen1 hw */

#define MCE_G1_INIT_MSGS 40	/* Init messages on gen1 hw to throw out */

/* MCE constants */

#define MCE_CMDBUF_SIZE	384 /* MCE Command buffer length */

	{}

};

static struct usb_device_id std_tx_mask_list[] = {

	{ USB_DEVICE(VENDOR_MICROSOFT, 0x006d) },

	{ USB_DEVICE(VENDOR_PHILIPS, 0x060c) },

	{ USB_DEVICE(VENDOR_SMK, 0x031d) },

	{ USB_DEVICE(VENDOR_SMK, 0x0322) },

	{ USB_DEVICE(VENDOR_SMK, 0x0334) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x0001) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x0006) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x0007) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x0008) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x000a) },

	{ USB_DEVICE(VENDOR_TOPSEED, 0x0011) },

	{ USB_DEVICE(VENDOR_PINNACLE, 0x0225) },

	{}

};

/* data structure for each usb transceiver */

struct mceusb_dev {

	/* ir-core bits */

	struct ir_input_dev *irdev;

	struct ir_dev_props *props;

	struct ir_input_state *state;

	struct ir_raw_event rawir;

	/* core device bits */

	struct {

		u32 connected:1;

		u32 def_xmit_mask_set:1;

		u32 tx_mask_inverted:1;

		u32 microsoft_gen1:1;

		u32 gen3:1;

		u32 reserved:28;

	char name[128];

	char phys[64];

	unsigned char def_xmit_mask;

	unsigned char cur_xmit_mask;

	unsigned char tx_mask;

};

/*

	int i;

	u8 cmd, subcmd, data1, data2;

	struct device *dev = ir->dev;

	int idx = 0;

	if (len <= 0)

		return;

	/* skip meaningless 0xb1 0x60 header bytes on orig receiver */

	if (ir->flags.microsoft_gen1 && !out)

		idx = 2;

	if (ir->flags.microsoft_gen1 && len <= 2)

	if (len <= idx)

		return;

	for (i = 0; i < len && i < USB_BUFLEN; i++)

	else

		strcpy(inout, "Got\0");

	cmd    = buf[0] & 0xff;

	subcmd = buf[1] & 0xff;

	data1  = buf[2] & 0xff;

	data2  = buf[3] & 0xff;

	cmd    = buf[idx] & 0xff;

	subcmd = buf[idx + 1] & 0xff;

	data1  = buf[idx + 2] & 0xff;

	data2  = buf[idx + 3] & 0xff;

	switch (cmd) {

	case 0x00:

			else

				dev_info(dev, "hw/sw rev 0x%02x 0x%02x "

					 "0x%02x 0x%02x\n", data1, data2,

					 buf[4], buf[5]);

					 buf[idx + 4], buf[idx + 5]);

			break;

		case 0xaa:

			dev_info(dev, "Device reset requested\n");

	mce_request_packet(ir, ir->usb_ep_in, data, size, MCEUSB_RX);

}

/* Sets active IR outputs -- mce devices typically (all?) have two */

static int mceusb_set_tx_mask(void *priv, u32 mask)

{

	struct mceusb_dev *ir = priv;

	if (ir->flags.tx_mask_inverted)

		ir->tx_mask = (mask != 0x03 ? mask ^ 0x03 : mask) << 1;

	else

		ir->tx_mask = mask;

	return 0;

}

static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)

{

	struct ir_raw_event rawir = { .pulse = false, .duration = 0 };

	}

}

static void mceusb_set_default_xmit_mask(struct urb *urb)

{

	struct mceusb_dev *ir = urb->context;

	char *buffer = urb->transfer_buffer;

	u8 cmd, subcmd, def_xmit_mask;

	cmd    = buffer[0] & 0xff;

	subcmd = buffer[1] & 0xff;

	if (cmd == 0x9f && subcmd == 0x08) {

		def_xmit_mask = buffer[2] & 0xff;

		dev_dbg(ir->dev, "%s: setting xmit mask to 0x%02x\n",

			__func__, def_xmit_mask);

		ir->def_xmit_mask = def_xmit_mask;

		ir->flags.def_xmit_mask_set = 1;

	}

}

static void mceusb_dev_recv(struct urb *urb, struct pt_regs *regs)

{

	struct mceusb_dev *ir;

	buf_len = urb->actual_length;

	if (!ir->flags.def_xmit_mask_set)

		mceusb_set_default_xmit_mask(urb);

	if (debug)

		mceusb_dev_printdata(ir, urb->transfer_buffer, buf_len, false);

static void mceusb_gen1_init(struct mceusb_dev *ir)

{

	int i, ret;

	char junk[64], data[8];

	int partial = 0;

	struct device *dev = ir->dev;

	char *junk, *data;

	junk = kmalloc(2 * USB_BUFLEN, GFP_KERNEL);

	if (!junk) {

		dev_err(dev, "%s: memory allocation failed!\n", __func__);

		return;

	}

	data = kzalloc(USB_CTRL_MSG_SZ, GFP_KERNEL);

	if (!data) {

		dev_err(dev, "%s: memory allocation failed!\n", __func__);

		kfree(junk);

		return;

	}

	/*

	 * Clear off the first few messages. These look like calibration

	 * or test data, I can't really tell. This also flushes in case

	 * we have random ir data queued up.

	 */

	for (i = 0; i < 40; i++)

	for (i = 0; i < MCE_G1_INIT_MSGS; i++)

		usb_bulk_msg(ir->usbdev,

			usb_rcvbulkpipe(ir->usbdev,

				ir->usb_ep_in->bEndpointAddress),

			junk, 64, &partial, HZ * 10);

	memset(data, 0, 8);

			junk, sizeof(junk), &partial, HZ * 10);

	/* Get Status */

	ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),

			      USB_REQ_GET_STATUS, USB_DIR_IN,

			      0, 0, data, 2, HZ * 3);

			      0, 0, data, USB_CTRL_MSG_SZ, HZ * 3);

	/*    ret = usb_get_status( ir->usbdev, 0, 0, data ); */

	dev_dbg(dev, "%s - ret = %d status = 0x%x 0x%x\n", __func__,

	 * This is a strange one. They issue a set address to the device

	 * on the receive control pipe and expect a certain value pair back

	 */

	memset(data, 0, 8);

	memset(data, 0, sizeof(data));

	ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),

			      USB_REQ_SET_ADDRESS, USB_TYPE_VENDOR, 0, 0,

			      data, 2, HZ * 3);

			      data, USB_CTRL_MSG_SZ, HZ * 3);

	dev_dbg(dev, "%s - ret = %d\n", __func__, ret);

	dev_dbg(dev, "%s - data[0] = %d, data[1] = %d\n",

		__func__, data[0], data[1]);

			      2, USB_TYPE_VENDOR,

			      0x0000, 0x0100, NULL, 0, HZ * 3);

	dev_dbg(dev, "%s - retC = %d\n", __func__, ret);

	kfree(data);

	kfree(junk);

};

static void mceusb_gen2_init(struct mceusb_dev *ir)

	struct input_dev *idev;

	struct ir_dev_props *props;

	struct ir_input_dev *irdev;

	struct ir_input_state *state;

	struct device *dev = ir->dev;

	int ret = -ENODEV;

		goto ir_dev_alloc_failed;

	}

	state = kzalloc(sizeof(struct ir_input_state), GFP_KERNEL);

	if (!state) {

		dev_err(dev, "remote ir state allocation failed\n");

		goto ir_state_alloc_failed;

	}

	snprintf(ir->name, sizeof(ir->name), "Media Center Edition eHome "

		 "Infrared Remote Transceiver (%04x:%04x)",

		 le16_to_cpu(ir->usbdev->descriptor.idVendor),

		 le16_to_cpu(ir->usbdev->descriptor.idProduct));

	ret = ir_input_init(idev, state, IR_TYPE_RC6);

	if (ret < 0)

		goto irdev_failed;

	idev->name = ir->name;

	usb_make_path(ir->usbdev, ir->phys, sizeof(ir->phys));

	strlcat(ir->phys, "/input0", sizeof(ir->phys));

	idev->phys = ir->phys;

	/* FIXME: no EV_REP (yet), we may need our own auto-repeat handling */

	idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);

	idev->keybit[BIT_WORD(BTN_MOUSE)] =

		BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);

	idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) |

		BIT_MASK(REL_WHEEL);

	props->priv = ir;

	props->driver_type = RC_DRIVER_IR_RAW;

	props->allowed_protos = IR_TYPE_ALL;

	ir->props = props;

	ir->irdev = irdev;

	ir->state = state;

	input_set_drvdata(idev, irdev);

	return idev;

irdev_failed:

	kfree(state);

ir_state_alloc_failed:

	kfree(irdev);

ir_dev_alloc_failed:

	kfree(props);

	bool is_gen3;

	bool is_microsoft_gen1;

	bool is_pinnacle;

	bool tx_mask_inverted;

	dev_dbg(&intf->dev, ": %s called\n", __func__);

	is_gen3 = usb_match_id(intf, gen3_list) ? 1 : 0;

	is_microsoft_gen1 = usb_match_id(intf, microsoft_gen1_list) ? 1 : 0;

	is_pinnacle = usb_match_id(intf, pinnacle_list) ? 1 : 0;

	tx_mask_inverted = usb_match_id(intf, std_tx_mask_list) ? 0 : 1;

	/* step through the endpoints to find first bulk in and out endpoint */

	for (i = 0; i < idesc->desc.bNumEndpoints; ++i) {

	ir->len_in = maxp;

	ir->flags.gen3 = is_gen3;

	ir->flags.microsoft_gen1 = is_microsoft_gen1;

	ir->flags.tx_mask_inverted = tx_mask_inverted;

	/* Saving usb interface data for use by the transmitter routine */

	ir->usb_ep_in = ep_in;

	mce_sync_in(ir, NULL, maxp);

	/* We've already done this on gen3 devices */

	if (!ir->flags.def_xmit_mask_set) {

		mce_async_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));

		mce_sync_in(ir, NULL, maxp);

	}

	mceusb_set_tx_mask(ir, MCE_DEFAULT_TX_MASK);

	usb_set_intfdata(intf, ir);