Lines Matching refs:data

48 /* CEIR Wake-Up Registers, relative to data->wbase                      */
60 /* CEIR Enhanced Functionality Registers, relative to data->ebase */
67 /* SP3 Banked Registers, relative to data->sbase */
70 #define WBCIR_REG_SP3_RXDATA 0x00 /* FIFO RX data (r) */
71 #define WBCIR_REG_SP3_TXDATA 0x00 /* FIFO TX data (w) */
110 /* RX data bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
112 /* TX data low bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
116 /* TX data empty bit for WBCEIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
120 /* RX data available bit for WBCIR_REG_SP3_LSR */
122 /* RX data overrun error bit for WBCIR_REG_SP3_LSR */
128 /* TX data underrun error bit for WBCIR_REG_SP3_ASCR */
188 /* Per-device data */
242 wbcir_select_bank(struct wbcir_data *data, enum wbcir_bank bank)
244 outb(bank, data->sbase + WBCIR_REG_SP3_BSR);
248 wbcir_set_irqmask(struct wbcir_data *data, u8 irqmask)
250 if (data->irqmask == irqmask)
253 wbcir_select_bank(data, WBCIR_BANK_0);
254 outb(irqmask, data->sbase + WBCIR_REG_SP3_IER);
255 data->irqmask = irqmask;
261 struct wbcir_data *data = container_of(led_cdev,
265 if (inb(data->ebase + WBCIR_REG_ECEIR_CTS) & WBCIR_LED_ENABLE)
275 struct wbcir_data *data = container_of(led_cdev,
279 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CTS,
310 wbcir_carrier_report(struct wbcir_data *data)
312 unsigned counter = inb(data->ebase + WBCIR_REG_ECEIR_CNT_LO) |
313 inb(data->ebase + WBCIR_REG_ECEIR_CNT_HI) << 8;
319 data->pulse_duration)
322 ir_raw_event_store(data->dev, &ev);
326 data->pulse_duration = 0;
327 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CCTL, WBCIR_CNTR_R,
329 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CCTL, WBCIR_CNTR_EN,
336 struct wbcir_data *data = dev->priv;
338 if (!idle && data->rxstate == WBCIR_RXSTATE_INACTIVE)
339 data->rxstate = WBCIR_RXSTATE_ACTIVE;
341 if (idle && data->rxstate != WBCIR_RXSTATE_INACTIVE) {
342 data->rxstate = WBCIR_RXSTATE_INACTIVE;
344 if (data->carrier_report_enabled)
345 wbcir_carrier_report(data);
348 outb(WBCIR_RX_DISABLE, data->sbase + WBCIR_REG_SP3_ASCR);
353 wbcir_irq_rx(struct wbcir_data *data, struct pnp_dev *device)
359 while (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_AVAIL) {
360 irdata = inb(data->sbase + WBCIR_REG_SP3_RXDATA);
361 if (data->rxstate == WBCIR_RXSTATE_ERROR)
365 (data->carrier_report_enabled ? 2 : 10);
369 data->pulse_duration += rawir.duration;
371 ir_raw_event_store_with_filter(data->dev, &rawir);
374 ir_raw_event_handle(data->dev);
378 wbcir_irq_tx(struct wbcir_data *data)
385 if (!data->txbuf)
388 switch (data->txstate) {
405 * TX data is run-length coded in bytes: YXXXXXXX
409 for (used = 0; used < space && data->txoff != data->txlen; used++) {
410 if (data->txbuf[data->txoff] == 0) {
411 data->txoff++;
414 byte = min((u32)0x80, data->txbuf[data->txoff]);
415 data->txbuf[data->txoff] -= byte;
417 byte |= (data->txoff % 2 ? 0x80 : 0x00); /* pulse/space */
421 while (data->txoff != data->txlen && data->txbuf[data->txoff] == 0)
422 data->txoff++;
426 if (data->txstate == WBCIR_TXSTATE_ERROR)
428 outb(WBCIR_TX_UNDERRUN, data->sbase + WBCIR_REG_SP3_ASCR);
429 wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR);
430 kfree(data->txbuf);
431 data->txbuf = NULL;
432 data->txstate = WBCIR_TXSTATE_INACTIVE;
433 } else if (data->txoff == data->txlen) {
435 outsb(data->sbase + WBCIR_REG_SP3_TXDATA, bytes, used - 1);
436 outb(WBCIR_TX_EOT, data->sbase + WBCIR_REG_SP3_ASCR);
437 outb(bytes[used - 1], data->sbase + WBCIR_REG_SP3_TXDATA);
438 wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
441 /* More data to follow... */
442 outsb(data->sbase + WBCIR_REG_SP3_RXDATA, bytes, used);
443 if (data->txstate == WBCIR_TXSTATE_INACTIVE) {
444 wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR |
446 data->txstate = WBCIR_TXSTATE_ACTIVE;
455 struct wbcir_data *data = pnp_get_drvdata(device);
459 spin_lock_irqsave(&data->spinlock, flags);
460 wbcir_select_bank(data, WBCIR_BANK_0);
461 status = inb(data->sbase + WBCIR_REG_SP3_EIR);
462 status &= data->irqmask;
465 spin_unlock_irqrestore(&data->spinlock, flags);
471 if (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_OVERRUN) {
472 data->rxstate = WBCIR_RXSTATE_ERROR;
473 ir_raw_event_reset(data->dev);
477 if (inb(data->sbase + WBCIR_REG_SP3_ASCR) & WBCIR_TX_UNDERRUN)
478 data->txstate = WBCIR_TXSTATE_ERROR;
482 wbcir_irq_rx(data, device);
485 wbcir_irq_tx(data);
487 spin_unlock_irqrestore(&data->spinlock, flags);
500 struct wbcir_data *data = dev->priv;
503 spin_lock_irqsave(&data->spinlock, flags);
505 if (data->carrier_report_enabled == enable) {
506 spin_unlock_irqrestore(&data->spinlock, flags);
510 data->pulse_duration = 0;
511 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CCTL, WBCIR_CNTR_R,
514 if (enable && data->dev->idle)
515 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CCTL,
519 wbcir_select_bank(data, WBCIR_BANK_2);
520 data->dev->rx_resolution = enable ? 2 : 10;
521 outb(enable ? 0x03 : 0x0f, data->sbase + WBCIR_REG_SP3_BGDL);
522 outb(0x00, data->sbase + WBCIR_REG_SP3_BGDH);
525 wbcir_select_bank(data, WBCIR_BANK_7);
526 wbcir_set_bits(data->sbase + WBCIR_REG_SP3_RCCFG,
529 data->carrier_report_enabled = enable;
530 spin_unlock_irqrestore(&data->spinlock, flags);
538 struct wbcir_data *data = dev->priv;
564 spin_lock_irqsave(&data->spinlock, flags);
565 if (data->txstate != WBCIR_TXSTATE_INACTIVE) {
566 spin_unlock_irqrestore(&data->spinlock, flags);
570 if (data->txcarrier != freq) {
571 wbcir_select_bank(data, WBCIR_BANK_7);
572 wbcir_set_bits(data->sbase + WBCIR_REG_SP3_IRTXMC, val, 0x1F);
573 data->txcarrier = freq;
576 spin_unlock_irqrestore(&data->spinlock, flags);
583 struct wbcir_data *data = dev->priv;
609 spin_lock_irqsave(&data->spinlock, flags);
610 if (data->txstate != WBCIR_TXSTATE_INACTIVE) {
611 spin_unlock_irqrestore(&data->spinlock, flags);
615 if (data->txmask != mask) {
616 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CTS, val, 0x0c);
617 data->txmask = mask;
620 spin_unlock_irqrestore(&data->spinlock, flags);
627 struct wbcir_data *data = dev->priv;
641 spin_lock_irqsave(&data->spinlock, flags);
642 if (data->txstate != WBCIR_TXSTATE_INACTIVE) {
643 spin_unlock_irqrestore(&data->spinlock, flags);
649 data->txbuf = buf;
650 data->txlen = count;
651 data->txoff = 0;
652 wbcir_irq_tx(data);
655 spin_unlock_irqrestore(&data->spinlock, flags);
669 struct wbcir_data *data = pnp_get_drvdata(device);
670 struct rc_dev *rc = data->dev;
676 u32 wake_sc = rc->scancode_wakeup_filter.data;
825 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX,
828 outsb(data->wbase + WBCIR_REG_WCEIR_DATA, match, 11);
829 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX,
832 outsb(data->wbase + WBCIR_REG_WCEIR_DATA, mask, 11);
835 outb(rc6_csl, data->wbase + WBCIR_REG_WCEIR_CSL);
838 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
841 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x01, 0x07);
844 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL,
849 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
852 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01);
861 wbcir_set_irqmask(data, WBCIR_IRQ_NONE);
862 disable_irq(data->irq);
877 struct wbcir_data *data = pnp_get_drvdata(device);
878 led_classdev_suspend(&data->led);
884 wbcir_init_hw(struct wbcir_data *data)
887 wbcir_set_irqmask(data, WBCIR_IRQ_NONE);
890 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, invert ? 8 : 0, 0x09);
893 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
896 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
899 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CFG1, 0x4A, 0x7F);
903 outb(WBCIR_IRTX_INV, data->ebase + WBCIR_REG_ECEIR_CCTL);
905 outb(0x00, data->ebase + WBCIR_REG_ECEIR_CCTL);
911 outb(0x10, data->ebase + WBCIR_REG_ECEIR_CTS);
912 data->txmask = 0x1;
915 wbcir_select_bank(data, WBCIR_BANK_2);
916 outb(WBCIR_EXT_ENABLE, data->sbase + WBCIR_REG_SP3_EXCR1);
919 * Configure baud generator, IR data will be sampled at
930 outb(0x30, data->sbase + WBCIR_REG_SP3_EXCR2);
933 outb(0x0f, data->sbase + WBCIR_REG_SP3_BGDL);
934 outb(0x00, data->sbase + WBCIR_REG_SP3_BGDH);
937 wbcir_select_bank(data, WBCIR_BANK_0);
938 outb(0xC0, data->sbase + WBCIR_REG_SP3_MCR);
939 inb(data->sbase + WBCIR_REG_SP3_LSR); /* Clear LSR */
940 inb(data->sbase + WBCIR_REG_SP3_MSR); /* Clear MSR */
943 wbcir_select_bank(data, WBCIR_BANK_7);
944 outb(0x90, data->sbase + WBCIR_REG_SP3_RCCFG);
947 wbcir_select_bank(data, WBCIR_BANK_4);
948 outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR1);
951 wbcir_select_bank(data, WBCIR_BANK_5);
952 outb(txandrx ? 0x03 : 0x02, data->sbase + WBCIR_REG_SP3_IRCR2);
955 wbcir_select_bank(data, WBCIR_BANK_6);
956 outb(0x20, data->sbase + WBCIR_REG_SP3_IRCR3);
959 wbcir_select_bank(data, WBCIR_BANK_7);
960 outb(0xF2, data->sbase + WBCIR_REG_SP3_IRRXDC);
963 outb(0x69, data->sbase + WBCIR_REG_SP3_IRTXMC);
964 data->txcarrier = 36000;
968 outb(0x10, data->sbase + WBCIR_REG_SP3_IRCFG4);
970 outb(0x00, data->sbase + WBCIR_REG_SP3_IRCFG4);
973 wbcir_select_bank(data, WBCIR_BANK_0);
974 outb(0x97, data->sbase + WBCIR_REG_SP3_FCR);
977 outb(0xE0, data->sbase + WBCIR_REG_SP3_ASCR);
980 data->rxstate = WBCIR_RXSTATE_INACTIVE;
981 wbcir_idle_rx(data->dev, true);
984 if (data->txstate == WBCIR_TXSTATE_ACTIVE) {
985 kfree(data->txbuf);
986 data->txbuf = NULL;
987 data->txstate = WBCIR_TXSTATE_INACTIVE;
991 wbcir_set_irqmask(data, WBCIR_IRQ_RX | WBCIR_IRQ_ERR);
997 struct wbcir_data *data = pnp_get_drvdata(device);
999 wbcir_init_hw(data);
1000 ir_raw_event_reset(data->dev);
1001 enable_irq(data->irq);
1002 led_classdev_resume(&data->led);
1011 struct wbcir_data *data;
1021 data = kzalloc(sizeof(*data), GFP_KERNEL);
1022 if (!data) {
1027 pnp_set_drvdata(device, data);
1029 spin_lock_init(&data->spinlock);
1030 data->ebase = pnp_port_start(device, 0);
1031 data->wbase = pnp_port_start(device, 1);
1032 data->sbase = pnp_port_start(device, 2);
1033 data->irq = pnp_irq(device, 0);
1035 if (data->wbase == 0 || data->ebase == 0 ||
1036 data->sbase == 0 || data->irq == -1) {
1043 data->wbase, data->ebase, data->sbase, data->irq);
1045 data->led.name = "cir::activity";
1046 data->led.default_trigger = "rc-feedback";
1047 data->led.brightness_set = wbcir_led_brightness_set;
1048 data->led.brightness_get = wbcir_led_brightness_get;
1049 err = led_classdev_register(&device->dev, &data->led);
1053 data->dev = rc_allocate_device(RC_DRIVER_IR_RAW);
1054 if (!data->dev) {
1059 data->dev->driver_name = DRVNAME;
1060 data->dev->device_name = WBCIR_NAME;
1061 data->dev->input_phys = "wbcir/cir0";
1062 data->dev->input_id.bustype = BUS_HOST;
1063 data->dev->input_id.vendor = PCI_VENDOR_ID_WINBOND;
1064 data->dev->input_id.product = WBCIR_ID_FAMILY;
1065 data->dev->input_id.version = WBCIR_ID_CHIP;
1066 data->dev->map_name = RC_MAP_RC6_MCE;
1067 data->dev->s_idle = wbcir_idle_rx;
1068 data->dev->s_carrier_report = wbcir_set_carrier_report;
1069 data->dev->s_tx_mask = wbcir_txmask;
1070 data->dev->s_tx_carrier = wbcir_txcarrier;
1071 data->dev->tx_ir = wbcir_tx;
1072 data->dev->priv = data;
1073 data->dev->dev.parent = &device->dev;
1074 data->dev->min_timeout = 1;
1075 data->dev->timeout = IR_DEFAULT_TIMEOUT;
1076 data->dev->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
1077 data->dev->rx_resolution = 2;
1078 data->dev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
1079 data->dev->allowed_wakeup_protocols = RC_PROTO_BIT_NEC |
1084 data->dev->wakeup_protocol = RC_PROTO_RC6_MCE;
1085 data->dev->scancode_wakeup_filter.data = 0x800f040c;
1086 data->dev->scancode_wakeup_filter.mask = 0xffff7fff;
1087 data->dev->s_wakeup_filter = wbcir_set_wakeup_filter;
1089 err = rc_register_device(data->dev);
1093 if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) {
1095 data->wbase, data->wbase + WAKEUP_IOMEM_LEN - 1);
1100 if (!request_region(data->ebase, EHFUNC_IOMEM_LEN, DRVNAME)) {
1102 data->ebase, data->ebase + EHFUNC_IOMEM_LEN - 1);
1107 if (!request_region(data->sbase, SP_IOMEM_LEN, DRVNAME)) {
1109 data->sbase, data->sbase + SP_IOMEM_LEN - 1);
1114 err = request_irq(data->irq, wbcir_irq_handler,
1117 dev_err(dev, "Failed to claim IRQ %u\n", data->irq);
1124 wbcir_init_hw(data);
1129 release_region(data->sbase, SP_IOMEM_LEN);
1131 release_region(data->ebase, EHFUNC_IOMEM_LEN);
1133 release_region(data->wbase, WAKEUP_IOMEM_LEN);
1135 rc_unregister_device(data->dev);
1136 data->dev = NULL;
1138 rc_free_device(data->dev);
1140 led_classdev_unregister(&data->led);
1142 kfree(data);
1151 struct wbcir_data *data = pnp_get_drvdata(device);
1154 wbcir_set_irqmask(data, WBCIR_IRQ_NONE);
1155 free_irq(data->irq, device);
1158 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
1161 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01);
1164 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
1166 rc_unregister_device(data->dev);
1168 led_classdev_unregister(&data->led);
1170 /* This is ok since &data->led isn't actually used */
1171 wbcir_led_brightness_set(&data->led, LED_OFF);
1173 release_region(data->wbase, WAKEUP_IOMEM_LEN);
1174 release_region(data->ebase, EHFUNC_IOMEM_LEN);
1175 release_region(data->sbase, SP_IOMEM_LEN);
1177 kfree(data);