#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);
git.openpandora.org / pandora-kernel.git / commitdiff