Lines Matching refs:ir
14 * Initial port from lirc driver to ir-core drivery by Jarod, based
453 /* ir-core bits */
596 static void mceusb_dev_printdata(struct mceusb_dev *ir, u8 *buf, int buf_len,
602 struct device *dev = ir->dev;
619 if (ir->flags.microsoft_gen1 && !out && !offset) {
781 static void mceusb_defer_kevent(struct mceusb_dev *ir, int kevent)
783 set_bit(kevent, &ir->kevent_flags);
785 if (test_bit(EVENT_RST_PEND, &ir->kevent_flags)) {
786 dev_dbg(ir->dev, "kevent %d dropped pending USB Reset Device",
791 if (!schedule_work(&ir->kevent))
792 dev_dbg(ir->dev, "kevent %d already scheduled", kevent);
794 dev_dbg(ir->dev, "kevent %d scheduled", kevent);
811 static int mce_write(struct mceusb_dev *ir, u8 *data, int size)
815 struct device *dev = ir->dev;
821 mceusb_dev_printdata(ir, data, size, 0, size, true);
838 if (usb_endpoint_xfer_int(ir->usb_ep_out))
839 usb_fill_int_urb(urb, ir->usbdev, ir->pipe_out,
841 ir->usb_ep_out->bInterval);
843 usb_fill_bulk_urb(urb, ir->usbdev, ir->pipe_out,
880 dev_err(ir->dev, "Error: mce write urb status = %d (TX HALT)",
882 mceusb_defer_kevent(ir, EVENT_TX_HALT);
886 dev_err(ir->dev, "Error: mce write urb status = %d",
901 static void mce_command_out(struct mceusb_dev *ir, u8 *data, int size)
905 if (ir->need_reset) {
906 ir->need_reset = false;
907 mce_write(ir, DEVICE_RESUME, rsize);
911 mce_write(ir, data, size);
934 struct mceusb_dev *ir = dev->priv;
942 cmdbuf[2] = ir->tx_mask;
943 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
956 ret = mce_write(ir, irbuf, ircount);
987 ret = mce_write(ir, irbuf, ircount);
1004 ret = mce_write(ir, irbuf, ircount);
1014 struct mceusb_dev *ir = dev->priv;
1017 int emitters = ir->num_txports ? ir->num_txports : 2;
1022 if (ir->flags.tx_mask_normal)
1023 ir->tx_mask = mask;
1025 ir->tx_mask = (mask != MCE_DEFAULT_TX_MASK ?
1034 struct mceusb_dev *ir = dev->priv;
1041 if (ir->carrier != carrier) {
1044 ir->carrier = carrier;
1047 dev_dbg(ir->dev, "disabling carrier modulation");
1048 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1055 ir->carrier = carrier;
1058 dev_dbg(ir->dev, "requesting %u HZ carrier",
1062 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1077 struct mceusb_dev *ir = dev->priv;
1085 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1088 mce_command_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
1100 struct mceusb_dev *ir = dev->priv;
1104 dev_dbg(ir->dev, "select %s-range receive sensor",
1107 ir->wideband_rx_enabled = true;
1110 ir->wideband_rx_enabled = false;
1113 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1114 /* response from device sets ir->learning_active */
1126 struct mceusb_dev *ir = dev->priv;
1130 dev_dbg(ir->dev, "%s short-range receiver carrier reporting",
1133 ir->carrier_report_enabled = true;
1134 if (!ir->learning_active) {
1136 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1139 ir->carrier_report_enabled = false;
1145 if (ir->learning_active && !ir->wideband_rx_enabled) {
1147 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1165 static void mceusb_handle_command(struct mceusb_dev *ir, u8 *buf_in)
1180 ir->txports_cabled |= 1 << *hi;
1185 ir->emver = *hi;
1190 ir->need_reset = true;
1206 ir->rc->timeout = (*hi << 8 | *lo) * MCE_TIME_UNIT;
1209 ir->num_txports = *hi;
1210 ir->num_rxports = *lo;
1221 if (ir->carrier_report_enabled && ir->learning_active &&
1222 ir->pulse_tunit > 0) {
1228 cycles_fix = ir->flags.rx2 == 2 ? ir->pulse_count : 0;
1232 ir->pulse_tunit;
1233 dev_dbg(ir->dev, "RX carrier frequency %u Hz (pulse count = %u, cycles = %u, duration = %u, rx2 = %u)",
1234 rawir.carrier, ir->pulse_count, carrier_cycles,
1235 ir->pulse_tunit, ir->flags.rx2);
1236 ir_raw_event_store(ir->rc, &rawir);
1242 ir->tx_mask = *hi;
1245 ir->learning_active = ((*hi & 0x02) == 0x02);
1246 if (ir->rxports_active != *hi) {
1247 dev_info(ir->dev, "%s-range (0x%x) receiver active",
1248 ir->learning_active ? "short" : "long", *hi);
1249 ir->rxports_active = *hi;
1256 ir->need_reset = true;
1264 static void mceusb_process_ir_data(struct mceusb_dev *ir, int buf_len)
1271 if (ir->flags.microsoft_gen1)
1279 switch (ir->parser_state) {
1281 ir->rem = mceusb_cmd_datasize(ir->cmd, ir->buf_in[i]);
1282 mceusb_dev_printdata(ir, ir->buf_in, buf_len, i - 1,
1283 ir->rem + 2, false);
1284 if (i + ir->rem < buf_len)
1285 mceusb_handle_command(ir, &ir->buf_in[i - 1]);
1286 ir->parser_state = CMD_DATA;
1289 ir->rem--;
1290 rawir.pulse = ((ir->buf_in[i] & MCE_PULSE_BIT) != 0);
1291 rawir.duration = (ir->buf_in[i] & MCE_PULSE_MASK);
1293 dev_dbg(ir->dev, "nonsensical irdata %02x with duration 0",
1294 ir->buf_in[i]);
1298 ir->pulse_tunit += rawir.duration;
1299 ir->pulse_count++;
1303 dev_dbg(ir->dev, "Storing %s %u us (%02x)",
1305 rawir.duration, ir->buf_in[i]);
1307 if (ir_raw_event_store_with_filter(ir->rc, &rawir))
1311 ir->rem--;
1314 ir->cmd = ir->buf_in[i];
1315 if ((ir->cmd == MCE_CMD_PORT_IR) ||
1316 ((ir->cmd & MCE_PORT_MASK) !=
1322 ir->parser_state = SUBCMD;
1330 ir->rem = (ir->cmd & MCE_PACKET_LENGTH_MASK);
1331 mceusb_dev_printdata(ir, ir->buf_in, buf_len,
1332 i, ir->rem + 1, false);
1333 if (ir->rem) {
1334 ir->parser_state = PARSE_IRDATA;
1338 .duration = ir->rc->timeout
1341 if (ir_raw_event_store_with_filter(ir->rc,
1344 ir->pulse_tunit = 0;
1345 ir->pulse_count = 0;
1350 if (ir->parser_state != CMD_HEADER && !ir->rem)
1351 ir->parser_state = CMD_HEADER;
1358 if (ir->parser_state != PARSE_IRDATA || !ir->rem)
1359 ir->parser_state = CMD_HEADER;
1362 dev_dbg(ir->dev, "processed IR data");
1363 ir_raw_event_handle(ir->rc);
1369 struct mceusb_dev *ir;
1374 ir = urb->context;
1375 if (!ir) {
1383 mceusb_process_ir_data(ir, urb->actual_length);
1395 dev_err(ir->dev, "Error: urb status = %d (RX HALT)",
1397 mceusb_defer_kevent(ir, EVENT_RX_HALT);
1401 dev_err(ir->dev, "Error: urb status = %d", urb->status);
1408 static void mceusb_get_emulator_version(struct mceusb_dev *ir)
1411 ir->emver = 1;
1412 mce_command_out(ir, GET_EMVER, sizeof(GET_EMVER));
1415 static void mceusb_gen1_init(struct mceusb_dev *ir)
1418 struct device *dev = ir->dev;
1425 ret = usb_control_msg_recv(ir->usbdev, 0, USB_REQ_SET_ADDRESS,
1434 ret = usb_control_msg_send(ir->usbdev, 0,
1441 ret = usb_control_msg_send(ir->usbdev, 0,
1447 ret = usb_control_msg_send(ir->usbdev, 0,
1453 mce_command_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1456 mce_command_out(ir, GET_REVISION, sizeof(GET_REVISION));
1459 static void mceusb_gen2_init(struct mceusb_dev *ir)
1462 mce_command_out(ir, DEVICE_RESUME, sizeof(DEVICE_RESUME));
1465 mce_command_out(ir, GET_WAKEVERSION, sizeof(GET_WAKEVERSION));
1468 mce_command_out(ir, GET_UNKNOWN2, sizeof(GET_UNKNOWN2));
1471 static void mceusb_get_parameters(struct mceusb_dev *ir)
1478 ir->num_txports = 2;
1479 ir->num_rxports = 2;
1482 mce_command_out(ir, GET_NUM_PORTS, sizeof(GET_NUM_PORTS));
1485 mce_command_out(ir, GET_CARRIER_FREQ, sizeof(GET_CARRIER_FREQ));
1487 if (ir->num_txports && !ir->flags.no_tx)
1489 mce_command_out(ir, GET_TX_BITMASK, sizeof(GET_TX_BITMASK));
1492 mce_command_out(ir, GET_RX_TIMEOUT, sizeof(GET_RX_TIMEOUT));
1495 mce_command_out(ir, GET_RX_SENSOR, sizeof(GET_RX_SENSOR));
1497 for (i = 0; i < ir->num_txports; i++) {
1499 mce_command_out(ir, cmdbuf, sizeof(cmdbuf));
1503 static void mceusb_flash_led(struct mceusb_dev *ir)
1505 if (ir->emver < 2)
1508 mce_command_out(ir, FLASH_LED, sizeof(FLASH_LED));
1514 * specified in ir->kevent bit field.
1520 struct mceusb_dev *ir =
1524 dev_err(ir->dev, "kevent handler called (flags 0x%lx)",
1525 ir->kevent_flags);
1527 if (test_bit(EVENT_RST_PEND, &ir->kevent_flags)) {
1528 dev_err(ir->dev, "kevent handler canceled pending USB Reset Device");
1532 if (test_bit(EVENT_RX_HALT, &ir->kevent_flags)) {
1533 usb_unlink_urb(ir->urb_in);
1534 status = usb_clear_halt(ir->usbdev, ir->pipe_in);
1535 dev_err(ir->dev, "rx clear halt status = %d", status);
1541 dev_err(ir->dev,
1543 usb_queue_reset_device(ir->usbintf);
1544 set_bit(EVENT_RST_PEND, &ir->kevent_flags);
1545 clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1548 clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1551 clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1552 status = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1554 dev_err(ir->dev, "rx unhalt submit urb error = %d",
1559 if (test_bit(EVENT_TX_HALT, &ir->kevent_flags)) {
1560 status = usb_clear_halt(ir->usbdev, ir->pipe_out);
1561 dev_err(ir->dev, "tx clear halt status = %d", status);
1567 dev_err(ir->dev,
1569 usb_queue_reset_device(ir->usbintf);
1570 set_bit(EVENT_RST_PEND, &ir->kevent_flags);
1571 clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1574 clear_bit(EVENT_RX_HALT, &ir->kevent_flags);
1577 clear_bit(EVENT_TX_HALT, &ir->kevent_flags);
1581 static struct rc_dev *mceusb_init_rc_dev(struct mceusb_dev *ir)
1583 struct usb_device *udev = ir->usbdev;
1584 struct device *dev = ir->dev;
1594 snprintf(ir->name, sizeof(ir->name), "%s (%04x:%04x)",
1595 mceusb_model[ir->model].name ?
1596 mceusb_model[ir->model].name :
1598 le16_to_cpu(ir->usbdev->descriptor.idVendor),
1599 le16_to_cpu(ir->usbdev->descriptor.idProduct));
1601 usb_make_path(ir->usbdev, ir->phys, sizeof(ir->phys));
1603 rc->device_name = ir->name;
1604 rc->input_phys = ir->phys;
1605 usb_to_input_id(ir->usbdev, &rc->input_id);
1607 rc->priv = ir;
1611 if (!mceusb_model[ir->model].broken_irtimeout) {
1621 if (!ir->flags.no_tx) {
1626 if (ir->flags.rx2 > 0) {
1642 if (mceusb_model[ir->model].rc_map)
1643 rc->map_name = mceusb_model[ir->model].rc_map;
1666 struct mceusb_dev *ir = NULL;
1725 ir = kzalloc(sizeof(struct mceusb_dev), GFP_KERNEL);
1726 if (!ir)
1729 ir->pipe_in = pipe;
1730 ir->buf_in = usb_alloc_coherent(dev, maxp, GFP_KERNEL, &ir->dma_in);
1731 if (!ir->buf_in)
1734 ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);
1735 if (!ir->urb_in)
1738 ir->usbintf = intf;
1739 ir->usbdev = usb_get_dev(dev);
1740 ir->dev = &intf->dev;
1741 ir->len_in = maxp;
1742 ir->flags.microsoft_gen1 = is_microsoft_gen1;
1743 ir->flags.tx_mask_normal = tx_mask_normal;
1744 ir->flags.no_tx = mceusb_model[model].no_tx;
1745 ir->flags.rx2 = mceusb_model[model].rx2;
1746 ir->model = model;
1749 ir->usb_ep_out = ep_out;
1751 ir->pipe_out = usb_sndintpipe(ir->usbdev,
1754 ir->pipe_out = usb_sndbulkpipe(ir->usbdev,
1771 INIT_WORK(&ir->kevent, mceusb_deferred_kevent);
1773 ir->rc = mceusb_init_rc_dev(ir);
1774 if (!ir->rc)
1779 usb_fill_int_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1780 mceusb_dev_recv, ir, ep_in->bInterval);
1782 usb_fill_bulk_urb(ir->urb_in, dev, pipe, ir->buf_in, maxp,
1783 mceusb_dev_recv, ir);
1785 ir->urb_in->transfer_dma = ir->dma_in;
1786 ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1790 res = usb_submit_urb(ir->urb_in, GFP_KERNEL);
1795 mceusb_get_emulator_version(ir);
1798 if (ir->flags.microsoft_gen1)
1799 mceusb_gen1_init(ir);
1801 mceusb_gen2_init(ir);
1803 mceusb_get_parameters(ir);
1805 mceusb_flash_led(ir);
1807 if (!ir->flags.no_tx)
1808 mceusb_set_tx_mask(ir->rc, MCE_DEFAULT_TX_MASK);
1810 usb_set_intfdata(intf, ir);
1813 device_set_wakeup_capable(ir->dev, true);
1814 device_set_wakeup_enable(ir->dev, true);
1817 name, ir->emver);
1819 ir->num_txports, ir->txports_cabled,
1820 ir->num_rxports, ir->rxports_active);
1826 cancel_work_sync(&ir->kevent);
1827 usb_put_dev(ir->usbdev);
1828 usb_kill_urb(ir->urb_in);
1829 usb_free_urb(ir->urb_in);
1831 usb_free_coherent(dev, maxp, ir->buf_in, ir->dma_in);
1833 kfree(ir);
1844 struct mceusb_dev *ir = usb_get_intfdata(intf);
1850 if (!ir)
1853 ir->usbdev = NULL;
1854 cancel_work_sync(&ir->kevent);
1855 rc_unregister_device(ir->rc);
1856 usb_kill_urb(ir->urb_in);
1857 usb_free_urb(ir->urb_in);
1858 usb_free_coherent(dev, ir->len_in, ir->buf_in, ir->dma_in);
1861 kfree(ir);
1866 struct mceusb_dev *ir = usb_get_intfdata(intf);
1867 dev_info(ir->dev, "suspend");
1868 usb_kill_urb(ir->urb_in);
1874 struct mceusb_dev *ir = usb_get_intfdata(intf);
1875 dev_info(ir->dev, "resume");
1876 if (usb_submit_urb(ir->urb_in, GFP_ATOMIC))