1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * driver for ENE KB3926 B/C/D/E/F CIR (pnp id: ENE0XXX) 4 * 5 * Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com> 6 * 7 * Special thanks to: 8 * Sami R. <maesesami@gmail.com> for lot of help in debugging and therefore 9 * bringing to life support for transmission & learning mode. 10 * 11 * Charlie Andrews <charliethepilot@googlemail.com> for lots of help in 12 * bringing up the support of new firmware buffer that is popular 13 * on latest notebooks 14 * 15 * ENE for partial device documentation 16 */ 17 18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 19 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/pnp.h> 23 #include <linux/io.h> 24 #include <linux/interrupt.h> 25 #include <linux/sched.h> 26 #include <linux/slab.h> 27 #include <media/rc-core.h> 28 #include "ene_ir.h" 29 30 static int sample_period; 31 static bool learning_mode_force; 32 static int debug; 33 static bool txsim; 34 35 static void ene_set_reg_addr(struct ene_device *dev, u16 reg) 36 { 37 outb(reg >> 8, dev->hw_io + ENE_ADDR_HI); 38 outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO); 39 } 40 41 /* read a hardware register */ 42 static u8 ene_read_reg(struct ene_device *dev, u16 reg) 43 { 44 u8 retval; 45 ene_set_reg_addr(dev, reg); 46 retval = inb(dev->hw_io + ENE_IO); 47 dbg_regs("reg %04x == %02x", reg, retval); 48 return retval; 49 } 50 51 /* write a hardware register */ 52 static void ene_write_reg(struct ene_device *dev, u16 reg, u8 value) 53 { 54 dbg_regs("reg %04x <- %02x", reg, value); 55 ene_set_reg_addr(dev, reg); 56 outb(value, dev->hw_io + ENE_IO); 57 } 58 59 /* Set bits in hardware register */ 60 static void ene_set_reg_mask(struct ene_device *dev, u16 reg, u8 mask) 61 { 62 dbg_regs("reg %04x |= %02x", reg, mask); 63 ene_set_reg_addr(dev, reg); 64 outb(inb(dev->hw_io + ENE_IO) | mask, dev->hw_io + ENE_IO); 65 } 66 67 /* Clear bits in hardware register */ 68 static void ene_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask) 69 { 70 dbg_regs("reg %04x &= ~%02x ", reg, mask); 71 ene_set_reg_addr(dev, reg); 72 outb(inb(dev->hw_io + ENE_IO) & ~mask, dev->hw_io + ENE_IO); 73 } 74 75 /* A helper to set/clear a bit in register according to boolean variable */ 76 static void ene_set_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask, 77 bool set) 78 { 79 if (set) 80 ene_set_reg_mask(dev, reg, mask); 81 else 82 ene_clear_reg_mask(dev, reg, mask); 83 } 84 85 /* detect hardware features */ 86 static int ene_hw_detect(struct ene_device *dev) 87 { 88 u8 chip_major, chip_minor; 89 u8 hw_revision, old_ver; 90 u8 fw_reg2, fw_reg1; 91 92 ene_clear_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD); 93 chip_major = ene_read_reg(dev, ENE_ECVER_MAJOR); 94 chip_minor = ene_read_reg(dev, ENE_ECVER_MINOR); 95 ene_set_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD); 96 97 hw_revision = ene_read_reg(dev, ENE_ECHV); 98 old_ver = ene_read_reg(dev, ENE_HW_VER_OLD); 99 100 dev->pll_freq = (ene_read_reg(dev, ENE_PLLFRH) << 4) + 101 (ene_read_reg(dev, ENE_PLLFRL) >> 4); 102 103 if (sample_period != ENE_DEFAULT_SAMPLE_PERIOD) 104 dev->rx_period_adjust = 105 dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 2 : 4; 106 107 if (hw_revision == 0xFF) { 108 pr_warn("device seems to be disabled\n"); 109 pr_warn("send a mail to lirc-list@lists.sourceforge.net\n"); 110 pr_warn("please attach output of acpidump and dmidecode\n"); 111 return -ENODEV; 112 } 113 114 pr_notice("chip is 0x%02x%02x - kbver = 0x%02x, rev = 0x%02x\n", 115 chip_major, chip_minor, old_ver, hw_revision); 116 117 pr_notice("PLL freq = %d\n", dev->pll_freq); 118 119 if (chip_major == 0x33) { 120 pr_warn("chips 0x33xx aren't supported\n"); 121 return -ENODEV; 122 } 123 124 if (chip_major == 0x39 && chip_minor == 0x26 && hw_revision == 0xC0) { 125 dev->hw_revision = ENE_HW_C; 126 pr_notice("KB3926C detected\n"); 127 } else if (old_ver == 0x24 && hw_revision == 0xC0) { 128 dev->hw_revision = ENE_HW_B; 129 pr_notice("KB3926B detected\n"); 130 } else { 131 dev->hw_revision = ENE_HW_D; 132 pr_notice("KB3926D or higher detected\n"); 133 } 134 135 /* detect features hardware supports */ 136 if (dev->hw_revision < ENE_HW_C) 137 return 0; 138 139 fw_reg1 = ene_read_reg(dev, ENE_FW1); 140 fw_reg2 = ene_read_reg(dev, ENE_FW2); 141 142 pr_notice("Firmware regs: %02x %02x\n", fw_reg1, fw_reg2); 143 144 dev->hw_use_gpio_0a = !!(fw_reg2 & ENE_FW2_GP0A); 145 dev->hw_learning_and_tx_capable = !!(fw_reg2 & ENE_FW2_LEARNING); 146 dev->hw_extra_buffer = !!(fw_reg1 & ENE_FW1_HAS_EXTRA_BUF); 147 148 if (dev->hw_learning_and_tx_capable) 149 dev->hw_fan_input = !!(fw_reg2 & ENE_FW2_FAN_INPUT); 150 151 pr_notice("Hardware features:\n"); 152 153 if (dev->hw_learning_and_tx_capable) { 154 pr_notice("* Supports transmitting & learning mode\n"); 155 pr_notice(" This feature is rare and therefore,\n"); 156 pr_notice(" you are welcome to test it,\n"); 157 pr_notice(" and/or contact the author via:\n"); 158 pr_notice(" lirc-list@lists.sourceforge.net\n"); 159 pr_notice(" or maximlevitsky@gmail.com\n"); 160 161 pr_notice("* Uses GPIO %s for IR raw input\n", 162 dev->hw_use_gpio_0a ? "40" : "0A"); 163 164 if (dev->hw_fan_input) 165 pr_notice("* Uses unused fan feedback input as source of demodulated IR data\n"); 166 } 167 168 if (!dev->hw_fan_input) 169 pr_notice("* Uses GPIO %s for IR demodulated input\n", 170 dev->hw_use_gpio_0a ? "0A" : "40"); 171 172 if (dev->hw_extra_buffer) 173 pr_notice("* Uses new style input buffer\n"); 174 return 0; 175 } 176 177 /* Read properties of hw sample buffer */ 178 static void ene_rx_setup_hw_buffer(struct ene_device *dev) 179 { 180 u16 tmp; 181 182 ene_rx_read_hw_pointer(dev); 183 dev->r_pointer = dev->w_pointer; 184 185 if (!dev->hw_extra_buffer) { 186 dev->buffer_len = ENE_FW_PACKET_SIZE * 2; 187 return; 188 } 189 190 tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER); 191 tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER+1) << 8; 192 dev->extra_buf1_address = tmp; 193 194 dev->extra_buf1_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 2); 195 196 tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 3); 197 tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 4) << 8; 198 dev->extra_buf2_address = tmp; 199 200 dev->extra_buf2_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 5); 201 202 dev->buffer_len = dev->extra_buf1_len + dev->extra_buf2_len + 8; 203 204 pr_notice("Hardware uses 2 extended buffers:\n"); 205 pr_notice(" 0x%04x - len : %d\n", 206 dev->extra_buf1_address, dev->extra_buf1_len); 207 pr_notice(" 0x%04x - len : %d\n", 208 dev->extra_buf2_address, dev->extra_buf2_len); 209 210 pr_notice("Total buffer len = %d\n", dev->buffer_len); 211 212 if (dev->buffer_len > 64 || dev->buffer_len < 16) 213 goto error; 214 215 if (dev->extra_buf1_address > 0xFBFC || 216 dev->extra_buf1_address < 0xEC00) 217 goto error; 218 219 if (dev->extra_buf2_address > 0xFBFC || 220 dev->extra_buf2_address < 0xEC00) 221 goto error; 222 223 if (dev->r_pointer > dev->buffer_len) 224 goto error; 225 226 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND); 227 return; 228 error: 229 pr_warn("Error validating extra buffers, device probably won't work\n"); 230 dev->hw_extra_buffer = false; 231 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND); 232 } 233 234 235 /* Restore the pointers to extra buffers - to make module reload work*/ 236 static void ene_rx_restore_hw_buffer(struct ene_device *dev) 237 { 238 if (!dev->hw_extra_buffer) 239 return; 240 241 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 0, 242 dev->extra_buf1_address & 0xFF); 243 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 1, 244 dev->extra_buf1_address >> 8); 245 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 2, dev->extra_buf1_len); 246 247 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 3, 248 dev->extra_buf2_address & 0xFF); 249 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 4, 250 dev->extra_buf2_address >> 8); 251 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 5, 252 dev->extra_buf2_len); 253 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND); 254 } 255 256 /* Read hardware write pointer */ 257 static void ene_rx_read_hw_pointer(struct ene_device *dev) 258 { 259 if (dev->hw_extra_buffer) 260 dev->w_pointer = ene_read_reg(dev, ENE_FW_RX_POINTER); 261 else 262 dev->w_pointer = ene_read_reg(dev, ENE_FW2) 263 & ENE_FW2_BUF_WPTR ? 0 : ENE_FW_PACKET_SIZE; 264 265 dbg_verbose("RB: HW write pointer: %02x, driver read pointer: %02x", 266 dev->w_pointer, dev->r_pointer); 267 } 268 269 /* Gets address of next sample from HW ring buffer */ 270 static int ene_rx_get_sample_reg(struct ene_device *dev) 271 { 272 int r_pointer; 273 274 if (dev->r_pointer == dev->w_pointer) { 275 dbg_verbose("RB: hit end, try update w_pointer"); 276 ene_rx_read_hw_pointer(dev); 277 } 278 279 if (dev->r_pointer == dev->w_pointer) { 280 dbg_verbose("RB: end of data at %d", dev->r_pointer); 281 return 0; 282 } 283 284 dbg_verbose("RB: reading at offset %d", dev->r_pointer); 285 r_pointer = dev->r_pointer; 286 287 dev->r_pointer++; 288 if (dev->r_pointer == dev->buffer_len) 289 dev->r_pointer = 0; 290 291 dbg_verbose("RB: next read will be from offset %d", dev->r_pointer); 292 293 if (r_pointer < 8) { 294 dbg_verbose("RB: read at main buffer at %d", r_pointer); 295 return ENE_FW_SAMPLE_BUFFER + r_pointer; 296 } 297 298 r_pointer -= 8; 299 300 if (r_pointer < dev->extra_buf1_len) { 301 dbg_verbose("RB: read at 1st extra buffer at %d", r_pointer); 302 return dev->extra_buf1_address + r_pointer; 303 } 304 305 r_pointer -= dev->extra_buf1_len; 306 307 if (r_pointer < dev->extra_buf2_len) { 308 dbg_verbose("RB: read at 2nd extra buffer at %d", r_pointer); 309 return dev->extra_buf2_address + r_pointer; 310 } 311 312 dbg("attempt to read beyond ring buffer end"); 313 return 0; 314 } 315 316 /* Sense current received carrier */ 317 static void ene_rx_sense_carrier(struct ene_device *dev) 318 { 319 int carrier, duty_cycle; 320 int period = ene_read_reg(dev, ENE_CIRCAR_PRD); 321 int hperiod = ene_read_reg(dev, ENE_CIRCAR_HPRD); 322 323 if (!(period & ENE_CIRCAR_PRD_VALID)) 324 return; 325 326 period &= ~ENE_CIRCAR_PRD_VALID; 327 328 if (!period) 329 return; 330 331 dbg("RX: hardware carrier period = %02x", period); 332 dbg("RX: hardware carrier pulse period = %02x", hperiod); 333 334 carrier = 2000000 / period; 335 duty_cycle = (hperiod * 100) / period; 336 dbg("RX: sensed carrier = %d Hz, duty cycle %d%%", 337 carrier, duty_cycle); 338 if (dev->carrier_detect_enabled) { 339 struct ir_raw_event ev = { 340 .carrier_report = true, 341 .carrier = carrier, 342 .duty_cycle = duty_cycle 343 }; 344 ir_raw_event_store(dev->rdev, &ev); 345 } 346 } 347 348 /* this enables/disables the CIR RX engine */ 349 static void ene_rx_enable_cir_engine(struct ene_device *dev, bool enable) 350 { 351 ene_set_clear_reg_mask(dev, ENE_CIRCFG, 352 ENE_CIRCFG_RX_EN | ENE_CIRCFG_RX_IRQ, enable); 353 } 354 355 /* this selects input for CIR engine. Ether GPIO 0A or GPIO40*/ 356 static void ene_rx_select_input(struct ene_device *dev, bool gpio_0a) 357 { 358 ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_GPIO0A, gpio_0a); 359 } 360 361 /* 362 * this enables alternative input via fan tachometer sensor and bypasses 363 * the hw CIR engine 364 */ 365 static void ene_rx_enable_fan_input(struct ene_device *dev, bool enable) 366 { 367 if (!dev->hw_fan_input) 368 return; 369 370 if (!enable) 371 ene_write_reg(dev, ENE_FAN_AS_IN1, 0); 372 else { 373 ene_write_reg(dev, ENE_FAN_AS_IN1, ENE_FAN_AS_IN1_EN); 374 ene_write_reg(dev, ENE_FAN_AS_IN2, ENE_FAN_AS_IN2_EN); 375 } 376 } 377 378 /* setup the receiver for RX*/ 379 static void ene_rx_setup(struct ene_device *dev) 380 { 381 bool learning_mode = dev->learning_mode_enabled || 382 dev->carrier_detect_enabled; 383 int sample_period_adjust = 0; 384 385 dbg("RX: setup receiver, learning mode = %d", learning_mode); 386 387 388 /* This selects RLC input and clears CFG2 settings */ 389 ene_write_reg(dev, ENE_CIRCFG2, 0x00); 390 391 /* set sample period*/ 392 if (sample_period == ENE_DEFAULT_SAMPLE_PERIOD) 393 sample_period_adjust = 394 dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 1 : 2; 395 396 ene_write_reg(dev, ENE_CIRRLC_CFG, 397 (sample_period + sample_period_adjust) | 398 ENE_CIRRLC_CFG_OVERFLOW); 399 /* revB doesn't support inputs */ 400 if (dev->hw_revision < ENE_HW_C) 401 goto select_timeout; 402 403 if (learning_mode) { 404 405 WARN_ON(!dev->hw_learning_and_tx_capable); 406 407 /* Enable the opposite of the normal input 408 That means that if GPIO40 is normally used, use GPIO0A 409 and vice versa. 410 This input will carry non demodulated 411 signal, and we will tell the hw to demodulate it itself */ 412 ene_rx_select_input(dev, !dev->hw_use_gpio_0a); 413 dev->rx_fan_input_inuse = false; 414 415 /* Enable carrier demodulation */ 416 ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD); 417 418 /* Enable carrier detection */ 419 ene_write_reg(dev, ENE_CIRCAR_PULS, 0x63); 420 ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT, 421 dev->carrier_detect_enabled || debug); 422 } else { 423 if (dev->hw_fan_input) 424 dev->rx_fan_input_inuse = true; 425 else 426 ene_rx_select_input(dev, dev->hw_use_gpio_0a); 427 428 /* Disable carrier detection & demodulation */ 429 ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD); 430 ene_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT); 431 } 432 433 select_timeout: 434 if (dev->rx_fan_input_inuse) { 435 dev->rdev->rx_resolution = US_TO_NS(ENE_FW_SAMPLE_PERIOD_FAN); 436 437 /* Fan input doesn't support timeouts, it just ends the 438 input with a maximum sample */ 439 dev->rdev->min_timeout = dev->rdev->max_timeout = 440 US_TO_NS(ENE_FW_SMPL_BUF_FAN_MSK * 441 ENE_FW_SAMPLE_PERIOD_FAN); 442 } else { 443 dev->rdev->rx_resolution = US_TO_NS(sample_period); 444 445 /* Theoreticly timeout is unlimited, but we cap it 446 * because it was seen that on one device, it 447 * would stop sending spaces after around 250 msec. 448 * Besides, this is close to 2^32 anyway and timeout is u32. 449 */ 450 dev->rdev->min_timeout = US_TO_NS(127 * sample_period); 451 dev->rdev->max_timeout = US_TO_NS(200000); 452 } 453 454 if (dev->hw_learning_and_tx_capable) 455 dev->rdev->tx_resolution = US_TO_NS(sample_period); 456 457 if (dev->rdev->timeout > dev->rdev->max_timeout) 458 dev->rdev->timeout = dev->rdev->max_timeout; 459 if (dev->rdev->timeout < dev->rdev->min_timeout) 460 dev->rdev->timeout = dev->rdev->min_timeout; 461 } 462 463 /* Enable the device for receive */ 464 static void ene_rx_enable_hw(struct ene_device *dev) 465 { 466 u8 reg_value; 467 468 /* Enable system interrupt */ 469 if (dev->hw_revision < ENE_HW_C) { 470 ene_write_reg(dev, ENEB_IRQ, dev->irq << 1); 471 ene_write_reg(dev, ENEB_IRQ_UNK1, 0x01); 472 } else { 473 reg_value = ene_read_reg(dev, ENE_IRQ) & 0xF0; 474 reg_value |= ENE_IRQ_UNK_EN; 475 reg_value &= ~ENE_IRQ_STATUS; 476 reg_value |= (dev->irq & ENE_IRQ_MASK); 477 ene_write_reg(dev, ENE_IRQ, reg_value); 478 } 479 480 /* Enable inputs */ 481 ene_rx_enable_fan_input(dev, dev->rx_fan_input_inuse); 482 ene_rx_enable_cir_engine(dev, !dev->rx_fan_input_inuse); 483 484 /* ack any pending irqs - just in case */ 485 ene_irq_status(dev); 486 487 /* enable firmware bits */ 488 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ); 489 490 /* enter idle mode */ 491 ir_raw_event_set_idle(dev->rdev, true); 492 } 493 494 /* Enable the device for receive - wrapper to track the state*/ 495 static void ene_rx_enable(struct ene_device *dev) 496 { 497 ene_rx_enable_hw(dev); 498 dev->rx_enabled = true; 499 } 500 501 /* Disable the device receiver */ 502 static void ene_rx_disable_hw(struct ene_device *dev) 503 { 504 /* disable inputs */ 505 ene_rx_enable_cir_engine(dev, false); 506 ene_rx_enable_fan_input(dev, false); 507 508 /* disable hardware IRQ and firmware flag */ 509 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ); 510 ir_raw_event_set_idle(dev->rdev, true); 511 } 512 513 /* Disable the device receiver - wrapper to track the state */ 514 static void ene_rx_disable(struct ene_device *dev) 515 { 516 ene_rx_disable_hw(dev); 517 dev->rx_enabled = false; 518 } 519 520 /* This resets the receiver. Useful to stop stream of spaces at end of 521 * transmission 522 */ 523 static void ene_rx_reset(struct ene_device *dev) 524 { 525 ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN); 526 ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN); 527 } 528 529 /* Set up the TX carrier frequency and duty cycle */ 530 static void ene_tx_set_carrier(struct ene_device *dev) 531 { 532 u8 tx_puls_width; 533 unsigned long flags; 534 535 spin_lock_irqsave(&dev->hw_lock, flags); 536 537 ene_set_clear_reg_mask(dev, ENE_CIRCFG, 538 ENE_CIRCFG_TX_CARR, dev->tx_period > 0); 539 540 if (!dev->tx_period) 541 goto unlock; 542 543 BUG_ON(dev->tx_duty_cycle >= 100 || dev->tx_duty_cycle <= 0); 544 545 tx_puls_width = dev->tx_period / (100 / dev->tx_duty_cycle); 546 547 if (!tx_puls_width) 548 tx_puls_width = 1; 549 550 dbg("TX: pulse distance = %d * 500 ns", dev->tx_period); 551 dbg("TX: pulse width = %d * 500 ns", tx_puls_width); 552 553 ene_write_reg(dev, ENE_CIRMOD_PRD, dev->tx_period | ENE_CIRMOD_PRD_POL); 554 ene_write_reg(dev, ENE_CIRMOD_HPRD, tx_puls_width); 555 unlock: 556 spin_unlock_irqrestore(&dev->hw_lock, flags); 557 } 558 559 /* Enable/disable transmitters */ 560 static void ene_tx_set_transmitters(struct ene_device *dev) 561 { 562 unsigned long flags; 563 564 spin_lock_irqsave(&dev->hw_lock, flags); 565 ene_set_clear_reg_mask(dev, ENE_GPIOFS8, ENE_GPIOFS8_GPIO41, 566 !!(dev->transmitter_mask & 0x01)); 567 ene_set_clear_reg_mask(dev, ENE_GPIOFS1, ENE_GPIOFS1_GPIO0D, 568 !!(dev->transmitter_mask & 0x02)); 569 spin_unlock_irqrestore(&dev->hw_lock, flags); 570 } 571 572 /* prepare transmission */ 573 static void ene_tx_enable(struct ene_device *dev) 574 { 575 u8 conf1 = ene_read_reg(dev, ENE_CIRCFG); 576 u8 fwreg2 = ene_read_reg(dev, ENE_FW2); 577 578 dev->saved_conf1 = conf1; 579 580 /* Show information about currently connected transmitter jacks */ 581 if (fwreg2 & ENE_FW2_EMMITER1_CONN) 582 dbg("TX: Transmitter #1 is connected"); 583 584 if (fwreg2 & ENE_FW2_EMMITER2_CONN) 585 dbg("TX: Transmitter #2 is connected"); 586 587 if (!(fwreg2 & (ENE_FW2_EMMITER1_CONN | ENE_FW2_EMMITER2_CONN))) 588 pr_warn("TX: transmitter cable isn't connected!\n"); 589 590 /* disable receive on revc */ 591 if (dev->hw_revision == ENE_HW_C) 592 conf1 &= ~ENE_CIRCFG_RX_EN; 593 594 /* Enable TX engine */ 595 conf1 |= ENE_CIRCFG_TX_EN | ENE_CIRCFG_TX_IRQ; 596 ene_write_reg(dev, ENE_CIRCFG, conf1); 597 } 598 599 /* end transmission */ 600 static void ene_tx_disable(struct ene_device *dev) 601 { 602 ene_write_reg(dev, ENE_CIRCFG, dev->saved_conf1); 603 dev->tx_buffer = NULL; 604 } 605 606 607 /* TX one sample - must be called with dev->hw_lock*/ 608 static void ene_tx_sample(struct ene_device *dev) 609 { 610 u8 raw_tx; 611 u32 sample; 612 bool pulse = dev->tx_sample_pulse; 613 614 if (!dev->tx_buffer) { 615 pr_warn("TX: BUG: attempt to transmit NULL buffer\n"); 616 return; 617 } 618 619 /* Grab next TX sample */ 620 if (!dev->tx_sample) { 621 622 if (dev->tx_pos == dev->tx_len) { 623 if (!dev->tx_done) { 624 dbg("TX: no more data to send"); 625 dev->tx_done = true; 626 goto exit; 627 } else { 628 dbg("TX: last sample sent by hardware"); 629 ene_tx_disable(dev); 630 complete(&dev->tx_complete); 631 return; 632 } 633 } 634 635 sample = dev->tx_buffer[dev->tx_pos++]; 636 dev->tx_sample_pulse = !dev->tx_sample_pulse; 637 638 dev->tx_sample = DIV_ROUND_CLOSEST(sample, sample_period); 639 640 if (!dev->tx_sample) 641 dev->tx_sample = 1; 642 } 643 644 raw_tx = min(dev->tx_sample , (unsigned int)ENE_CIRRLC_OUT_MASK); 645 dev->tx_sample -= raw_tx; 646 647 dbg("TX: sample %8d (%s)", raw_tx * sample_period, 648 pulse ? "pulse" : "space"); 649 if (pulse) 650 raw_tx |= ENE_CIRRLC_OUT_PULSE; 651 652 ene_write_reg(dev, 653 dev->tx_reg ? ENE_CIRRLC_OUT1 : ENE_CIRRLC_OUT0, raw_tx); 654 655 dev->tx_reg = !dev->tx_reg; 656 exit: 657 /* simulate TX done interrupt */ 658 if (txsim) 659 mod_timer(&dev->tx_sim_timer, jiffies + HZ / 500); 660 } 661 662 /* timer to simulate tx done interrupt */ 663 static void ene_tx_irqsim(struct timer_list *t) 664 { 665 struct ene_device *dev = from_timer(dev, t, tx_sim_timer); 666 unsigned long flags; 667 668 spin_lock_irqsave(&dev->hw_lock, flags); 669 ene_tx_sample(dev); 670 spin_unlock_irqrestore(&dev->hw_lock, flags); 671 } 672 673 674 /* read irq status and ack it */ 675 static int ene_irq_status(struct ene_device *dev) 676 { 677 u8 irq_status; 678 u8 fw_flags1, fw_flags2; 679 int retval = 0; 680 681 fw_flags2 = ene_read_reg(dev, ENE_FW2); 682 683 if (dev->hw_revision < ENE_HW_C) { 684 irq_status = ene_read_reg(dev, ENEB_IRQ_STATUS); 685 686 if (!(irq_status & ENEB_IRQ_STATUS_IR)) 687 return 0; 688 689 ene_clear_reg_mask(dev, ENEB_IRQ_STATUS, ENEB_IRQ_STATUS_IR); 690 return ENE_IRQ_RX; 691 } 692 693 irq_status = ene_read_reg(dev, ENE_IRQ); 694 if (!(irq_status & ENE_IRQ_STATUS)) 695 return 0; 696 697 /* original driver does that twice - a workaround ? */ 698 ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS); 699 ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS); 700 701 /* check RX interrupt */ 702 if (fw_flags2 & ENE_FW2_RXIRQ) { 703 retval |= ENE_IRQ_RX; 704 ene_write_reg(dev, ENE_FW2, fw_flags2 & ~ENE_FW2_RXIRQ); 705 } 706 707 /* check TX interrupt */ 708 fw_flags1 = ene_read_reg(dev, ENE_FW1); 709 if (fw_flags1 & ENE_FW1_TXIRQ) { 710 ene_write_reg(dev, ENE_FW1, fw_flags1 & ~ENE_FW1_TXIRQ); 711 retval |= ENE_IRQ_TX; 712 } 713 714 return retval; 715 } 716 717 /* interrupt handler */ 718 static irqreturn_t ene_isr(int irq, void *data) 719 { 720 u16 hw_value, reg; 721 int hw_sample, irq_status; 722 bool pulse; 723 unsigned long flags; 724 irqreturn_t retval = IRQ_NONE; 725 struct ene_device *dev = (struct ene_device *)data; 726 struct ir_raw_event ev = {}; 727 728 spin_lock_irqsave(&dev->hw_lock, flags); 729 730 dbg_verbose("ISR called"); 731 ene_rx_read_hw_pointer(dev); 732 irq_status = ene_irq_status(dev); 733 734 if (!irq_status) 735 goto unlock; 736 737 retval = IRQ_HANDLED; 738 739 if (irq_status & ENE_IRQ_TX) { 740 dbg_verbose("TX interrupt"); 741 if (!dev->hw_learning_and_tx_capable) { 742 dbg("TX interrupt on unsupported device!"); 743 goto unlock; 744 } 745 ene_tx_sample(dev); 746 } 747 748 if (!(irq_status & ENE_IRQ_RX)) 749 goto unlock; 750 751 dbg_verbose("RX interrupt"); 752 753 if (dev->hw_learning_and_tx_capable) 754 ene_rx_sense_carrier(dev); 755 756 /* On hardware that don't support extra buffer we need to trust 757 the interrupt and not track the read pointer */ 758 if (!dev->hw_extra_buffer) 759 dev->r_pointer = dev->w_pointer == 0 ? ENE_FW_PACKET_SIZE : 0; 760 761 while (1) { 762 763 reg = ene_rx_get_sample_reg(dev); 764 765 dbg_verbose("next sample to read at: %04x", reg); 766 if (!reg) 767 break; 768 769 hw_value = ene_read_reg(dev, reg); 770 771 if (dev->rx_fan_input_inuse) { 772 773 int offset = ENE_FW_SMPL_BUF_FAN - ENE_FW_SAMPLE_BUFFER; 774 775 /* read high part of the sample */ 776 hw_value |= ene_read_reg(dev, reg + offset) << 8; 777 pulse = hw_value & ENE_FW_SMPL_BUF_FAN_PLS; 778 779 /* clear space bit, and other unused bits */ 780 hw_value &= ENE_FW_SMPL_BUF_FAN_MSK; 781 hw_sample = hw_value * ENE_FW_SAMPLE_PERIOD_FAN; 782 783 } else { 784 pulse = !(hw_value & ENE_FW_SAMPLE_SPACE); 785 hw_value &= ~ENE_FW_SAMPLE_SPACE; 786 hw_sample = hw_value * sample_period; 787 788 if (dev->rx_period_adjust) { 789 hw_sample *= 100; 790 hw_sample /= (100 + dev->rx_period_adjust); 791 } 792 } 793 794 if (!dev->hw_extra_buffer && !hw_sample) { 795 dev->r_pointer = dev->w_pointer; 796 continue; 797 } 798 799 dbg("RX: %d (%s)", hw_sample, pulse ? "pulse" : "space"); 800 801 ev.duration = US_TO_NS(hw_sample); 802 ev.pulse = pulse; 803 ir_raw_event_store_with_filter(dev->rdev, &ev); 804 } 805 806 ir_raw_event_handle(dev->rdev); 807 unlock: 808 spin_unlock_irqrestore(&dev->hw_lock, flags); 809 return retval; 810 } 811 812 /* Initialize default settings */ 813 static void ene_setup_default_settings(struct ene_device *dev) 814 { 815 dev->tx_period = 32; 816 dev->tx_duty_cycle = 50; /*%*/ 817 dev->transmitter_mask = 0x03; 818 dev->learning_mode_enabled = learning_mode_force; 819 820 /* Set reasonable default timeout */ 821 dev->rdev->timeout = US_TO_NS(150000); 822 } 823 824 /* Upload all hardware settings at once. Used at load and resume time */ 825 static void ene_setup_hw_settings(struct ene_device *dev) 826 { 827 if (dev->hw_learning_and_tx_capable) { 828 ene_tx_set_carrier(dev); 829 ene_tx_set_transmitters(dev); 830 } 831 832 ene_rx_setup(dev); 833 } 834 835 /* outside interface: called on first open*/ 836 static int ene_open(struct rc_dev *rdev) 837 { 838 struct ene_device *dev = rdev->priv; 839 unsigned long flags; 840 841 spin_lock_irqsave(&dev->hw_lock, flags); 842 ene_rx_enable(dev); 843 spin_unlock_irqrestore(&dev->hw_lock, flags); 844 return 0; 845 } 846 847 /* outside interface: called on device close*/ 848 static void ene_close(struct rc_dev *rdev) 849 { 850 struct ene_device *dev = rdev->priv; 851 unsigned long flags; 852 spin_lock_irqsave(&dev->hw_lock, flags); 853 854 ene_rx_disable(dev); 855 spin_unlock_irqrestore(&dev->hw_lock, flags); 856 } 857 858 /* outside interface: set transmitter mask */ 859 static int ene_set_tx_mask(struct rc_dev *rdev, u32 tx_mask) 860 { 861 struct ene_device *dev = rdev->priv; 862 dbg("TX: attempt to set transmitter mask %02x", tx_mask); 863 864 /* invalid txmask */ 865 if (!tx_mask || tx_mask & ~0x03) { 866 dbg("TX: invalid mask"); 867 /* return count of transmitters */ 868 return 2; 869 } 870 871 dev->transmitter_mask = tx_mask; 872 ene_tx_set_transmitters(dev); 873 return 0; 874 } 875 876 /* outside interface : set tx carrier */ 877 static int ene_set_tx_carrier(struct rc_dev *rdev, u32 carrier) 878 { 879 struct ene_device *dev = rdev->priv; 880 u32 period; 881 882 dbg("TX: attempt to set tx carrier to %d kHz", carrier); 883 if (carrier == 0) 884 return -EINVAL; 885 886 period = 2000000 / carrier; 887 if (period && (period > ENE_CIRMOD_PRD_MAX || 888 period < ENE_CIRMOD_PRD_MIN)) { 889 890 dbg("TX: out of range %d-%d kHz carrier", 891 2000 / ENE_CIRMOD_PRD_MIN, 2000 / ENE_CIRMOD_PRD_MAX); 892 return -EINVAL; 893 } 894 895 dev->tx_period = period; 896 ene_tx_set_carrier(dev); 897 return 0; 898 } 899 900 /*outside interface : set tx duty cycle */ 901 static int ene_set_tx_duty_cycle(struct rc_dev *rdev, u32 duty_cycle) 902 { 903 struct ene_device *dev = rdev->priv; 904 dbg("TX: setting duty cycle to %d%%", duty_cycle); 905 dev->tx_duty_cycle = duty_cycle; 906 ene_tx_set_carrier(dev); 907 return 0; 908 } 909 910 /* outside interface: enable learning mode */ 911 static int ene_set_learning_mode(struct rc_dev *rdev, int enable) 912 { 913 struct ene_device *dev = rdev->priv; 914 unsigned long flags; 915 if (enable == dev->learning_mode_enabled) 916 return 0; 917 918 spin_lock_irqsave(&dev->hw_lock, flags); 919 dev->learning_mode_enabled = enable; 920 ene_rx_disable(dev); 921 ene_rx_setup(dev); 922 ene_rx_enable(dev); 923 spin_unlock_irqrestore(&dev->hw_lock, flags); 924 return 0; 925 } 926 927 static int ene_set_carrier_report(struct rc_dev *rdev, int enable) 928 { 929 struct ene_device *dev = rdev->priv; 930 unsigned long flags; 931 932 if (enable == dev->carrier_detect_enabled) 933 return 0; 934 935 spin_lock_irqsave(&dev->hw_lock, flags); 936 dev->carrier_detect_enabled = enable; 937 ene_rx_disable(dev); 938 ene_rx_setup(dev); 939 ene_rx_enable(dev); 940 spin_unlock_irqrestore(&dev->hw_lock, flags); 941 return 0; 942 } 943 944 /* outside interface: enable or disable idle mode */ 945 static void ene_set_idle(struct rc_dev *rdev, bool idle) 946 { 947 struct ene_device *dev = rdev->priv; 948 949 if (idle) { 950 ene_rx_reset(dev); 951 dbg("RX: end of data"); 952 } 953 } 954 955 /* outside interface: transmit */ 956 static int ene_transmit(struct rc_dev *rdev, unsigned *buf, unsigned n) 957 { 958 struct ene_device *dev = rdev->priv; 959 unsigned long flags; 960 961 dev->tx_buffer = buf; 962 dev->tx_len = n; 963 dev->tx_pos = 0; 964 dev->tx_reg = 0; 965 dev->tx_done = 0; 966 dev->tx_sample = 0; 967 dev->tx_sample_pulse = false; 968 969 dbg("TX: %d samples", dev->tx_len); 970 971 spin_lock_irqsave(&dev->hw_lock, flags); 972 973 ene_tx_enable(dev); 974 975 /* Transmit first two samples */ 976 ene_tx_sample(dev); 977 ene_tx_sample(dev); 978 979 spin_unlock_irqrestore(&dev->hw_lock, flags); 980 981 if (wait_for_completion_timeout(&dev->tx_complete, 2 * HZ) == 0) { 982 dbg("TX: timeout"); 983 spin_lock_irqsave(&dev->hw_lock, flags); 984 ene_tx_disable(dev); 985 spin_unlock_irqrestore(&dev->hw_lock, flags); 986 } else 987 dbg("TX: done"); 988 return n; 989 } 990 991 /* probe entry */ 992 static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id) 993 { 994 int error = -ENOMEM; 995 struct rc_dev *rdev; 996 struct ene_device *dev; 997 998 /* allocate memory */ 999 dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL); 1000 rdev = rc_allocate_device(RC_DRIVER_IR_RAW); 1001 if (!dev || !rdev) 1002 goto exit_free_dev_rdev; 1003 1004 /* validate resources */ 1005 error = -ENODEV; 1006 1007 /* init these to -1, as 0 is valid for both */ 1008 dev->hw_io = -1; 1009 dev->irq = -1; 1010 1011 if (!pnp_port_valid(pnp_dev, 0) || 1012 pnp_port_len(pnp_dev, 0) < ENE_IO_SIZE) 1013 goto exit_free_dev_rdev; 1014 1015 if (!pnp_irq_valid(pnp_dev, 0)) 1016 goto exit_free_dev_rdev; 1017 1018 spin_lock_init(&dev->hw_lock); 1019 1020 dev->hw_io = pnp_port_start(pnp_dev, 0); 1021 dev->irq = pnp_irq(pnp_dev, 0); 1022 1023 1024 pnp_set_drvdata(pnp_dev, dev); 1025 dev->pnp_dev = pnp_dev; 1026 1027 /* don't allow too short/long sample periods */ 1028 if (sample_period < 5 || sample_period > 0x7F) 1029 sample_period = ENE_DEFAULT_SAMPLE_PERIOD; 1030 1031 /* detect hardware version and features */ 1032 error = ene_hw_detect(dev); 1033 if (error) 1034 goto exit_free_dev_rdev; 1035 1036 if (!dev->hw_learning_and_tx_capable && txsim) { 1037 dev->hw_learning_and_tx_capable = true; 1038 timer_setup(&dev->tx_sim_timer, ene_tx_irqsim, 0); 1039 pr_warn("Simulation of TX activated\n"); 1040 } 1041 1042 if (!dev->hw_learning_and_tx_capable) 1043 learning_mode_force = false; 1044 1045 rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER; 1046 rdev->priv = dev; 1047 rdev->open = ene_open; 1048 rdev->close = ene_close; 1049 rdev->s_idle = ene_set_idle; 1050 rdev->driver_name = ENE_DRIVER_NAME; 1051 rdev->map_name = RC_MAP_RC6_MCE; 1052 rdev->device_name = "ENE eHome Infrared Remote Receiver"; 1053 1054 if (dev->hw_learning_and_tx_capable) { 1055 rdev->s_learning_mode = ene_set_learning_mode; 1056 init_completion(&dev->tx_complete); 1057 rdev->tx_ir = ene_transmit; 1058 rdev->s_tx_mask = ene_set_tx_mask; 1059 rdev->s_tx_carrier = ene_set_tx_carrier; 1060 rdev->s_tx_duty_cycle = ene_set_tx_duty_cycle; 1061 rdev->s_carrier_report = ene_set_carrier_report; 1062 rdev->device_name = "ENE eHome Infrared Remote Transceiver"; 1063 } 1064 1065 dev->rdev = rdev; 1066 1067 ene_rx_setup_hw_buffer(dev); 1068 ene_setup_default_settings(dev); 1069 ene_setup_hw_settings(dev); 1070 1071 device_set_wakeup_capable(&pnp_dev->dev, true); 1072 device_set_wakeup_enable(&pnp_dev->dev, true); 1073 1074 error = rc_register_device(rdev); 1075 if (error < 0) 1076 goto exit_free_dev_rdev; 1077 1078 /* claim the resources */ 1079 error = -EBUSY; 1080 if (!request_region(dev->hw_io, ENE_IO_SIZE, ENE_DRIVER_NAME)) { 1081 goto exit_unregister_device; 1082 } 1083 1084 if (request_irq(dev->irq, ene_isr, 1085 IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev)) { 1086 goto exit_release_hw_io; 1087 } 1088 1089 pr_notice("driver has been successfully loaded\n"); 1090 return 0; 1091 1092 exit_release_hw_io: 1093 release_region(dev->hw_io, ENE_IO_SIZE); 1094 exit_unregister_device: 1095 rc_unregister_device(rdev); 1096 rdev = NULL; 1097 exit_free_dev_rdev: 1098 rc_free_device(rdev); 1099 kfree(dev); 1100 return error; 1101 } 1102 1103 /* main unload function */ 1104 static void ene_remove(struct pnp_dev *pnp_dev) 1105 { 1106 struct ene_device *dev = pnp_get_drvdata(pnp_dev); 1107 unsigned long flags; 1108 1109 spin_lock_irqsave(&dev->hw_lock, flags); 1110 ene_rx_disable(dev); 1111 ene_rx_restore_hw_buffer(dev); 1112 spin_unlock_irqrestore(&dev->hw_lock, flags); 1113 1114 free_irq(dev->irq, dev); 1115 release_region(dev->hw_io, ENE_IO_SIZE); 1116 rc_unregister_device(dev->rdev); 1117 kfree(dev); 1118 } 1119 1120 /* enable wake on IR (wakes on specific button on original remote) */ 1121 static void ene_enable_wake(struct ene_device *dev, bool enable) 1122 { 1123 dbg("wake on IR %s", enable ? "enabled" : "disabled"); 1124 ene_set_clear_reg_mask(dev, ENE_FW1, ENE_FW1_WAKE, enable); 1125 } 1126 1127 #ifdef CONFIG_PM 1128 static int ene_suspend(struct pnp_dev *pnp_dev, pm_message_t state) 1129 { 1130 struct ene_device *dev = pnp_get_drvdata(pnp_dev); 1131 bool wake = device_may_wakeup(&dev->pnp_dev->dev); 1132 1133 if (!wake && dev->rx_enabled) 1134 ene_rx_disable_hw(dev); 1135 1136 ene_enable_wake(dev, wake); 1137 return 0; 1138 } 1139 1140 static int ene_resume(struct pnp_dev *pnp_dev) 1141 { 1142 struct ene_device *dev = pnp_get_drvdata(pnp_dev); 1143 ene_setup_hw_settings(dev); 1144 1145 if (dev->rx_enabled) 1146 ene_rx_enable(dev); 1147 1148 ene_enable_wake(dev, false); 1149 return 0; 1150 } 1151 #endif 1152 1153 static void ene_shutdown(struct pnp_dev *pnp_dev) 1154 { 1155 struct ene_device *dev = pnp_get_drvdata(pnp_dev); 1156 ene_enable_wake(dev, true); 1157 } 1158 1159 static const struct pnp_device_id ene_ids[] = { 1160 {.id = "ENE0100",}, 1161 {.id = "ENE0200",}, 1162 {.id = "ENE0201",}, 1163 {.id = "ENE0202",}, 1164 {}, 1165 }; 1166 1167 static struct pnp_driver ene_driver = { 1168 .name = ENE_DRIVER_NAME, 1169 .id_table = ene_ids, 1170 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, 1171 1172 .probe = ene_probe, 1173 .remove = ene_remove, 1174 #ifdef CONFIG_PM 1175 .suspend = ene_suspend, 1176 .resume = ene_resume, 1177 #endif 1178 .shutdown = ene_shutdown, 1179 }; 1180 1181 module_param(sample_period, int, S_IRUGO); 1182 MODULE_PARM_DESC(sample_period, "Hardware sample period (50 us default)"); 1183 1184 module_param(learning_mode_force, bool, S_IRUGO); 1185 MODULE_PARM_DESC(learning_mode_force, "Enable learning mode by default"); 1186 1187 module_param(debug, int, S_IRUGO | S_IWUSR); 1188 MODULE_PARM_DESC(debug, "Debug level"); 1189 1190 module_param(txsim, bool, S_IRUGO); 1191 MODULE_PARM_DESC(txsim, 1192 "Simulate TX features on unsupported hardware (dangerous)"); 1193 1194 MODULE_DEVICE_TABLE(pnp, ene_ids); 1195 MODULE_DESCRIPTION 1196 ("Infrared input driver for KB3926B/C/D/E/F (aka ENE0100/ENE0200/ENE0201/ENE0202) CIR port"); 1197 1198 MODULE_AUTHOR("Maxim Levitsky"); 1199 MODULE_LICENSE("GPL"); 1200 1201 module_pnp_driver(ene_driver); 1202