1 /* 2 * Driver for ITE Tech Inc. IT8712F/IT8512 CIR 3 * 4 * Copyright (C) 2010 Juan Jesús García de Soria <skandalfo@gmail.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation; either version 2 of the 9 * License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 19 * USA. 20 * 21 * Inspired by the original lirc_it87 and lirc_ite8709 drivers, on top of the 22 * skeleton provided by the nuvoton-cir driver. 23 * 24 * The lirc_it87 driver was originally written by Hans-Gunter Lutke Uphues 25 * <hg_lu@web.de> in 2001, with enhancements by Christoph Bartelmus 26 * <lirc@bartelmus.de>, Andrew Calkin <r_tay@hotmail.com> and James Edwards 27 * <jimbo-lirc@edwardsclan.net>. 28 * 29 * The lirc_ite8709 driver was written by Grégory Lardière 30 * <spmf2004-lirc@yahoo.fr> in 2008. 31 */ 32 33 #include <linux/kernel.h> 34 #include <linux/module.h> 35 #include <linux/pnp.h> 36 #include <linux/io.h> 37 #include <linux/interrupt.h> 38 #include <linux/sched.h> 39 #include <linux/slab.h> 40 #include <linux/input.h> 41 #include <linux/bitops.h> 42 #include <media/rc-core.h> 43 #include <linux/pci_ids.h> 44 45 #include "ite-cir.h" 46 47 /* module parameters */ 48 49 /* debug level */ 50 static int debug; 51 module_param(debug, int, S_IRUGO | S_IWUSR); 52 MODULE_PARM_DESC(debug, "Enable debugging output"); 53 54 /* low limit for RX carrier freq, Hz, 0 for no RX demodulation */ 55 static int rx_low_carrier_freq; 56 module_param(rx_low_carrier_freq, int, S_IRUGO | S_IWUSR); 57 MODULE_PARM_DESC(rx_low_carrier_freq, "Override low RX carrier frequency, Hz, " 58 "0 for no RX demodulation"); 59 60 /* high limit for RX carrier freq, Hz, 0 for no RX demodulation */ 61 static int rx_high_carrier_freq; 62 module_param(rx_high_carrier_freq, int, S_IRUGO | S_IWUSR); 63 MODULE_PARM_DESC(rx_high_carrier_freq, "Override high RX carrier frequency, " 64 "Hz, 0 for no RX demodulation"); 65 66 /* override tx carrier frequency */ 67 static int tx_carrier_freq; 68 module_param(tx_carrier_freq, int, S_IRUGO | S_IWUSR); 69 MODULE_PARM_DESC(tx_carrier_freq, "Override TX carrier frequency, Hz"); 70 71 /* override tx duty cycle */ 72 static int tx_duty_cycle; 73 module_param(tx_duty_cycle, int, S_IRUGO | S_IWUSR); 74 MODULE_PARM_DESC(tx_duty_cycle, "Override TX duty cycle, 1-100"); 75 76 /* override default sample period */ 77 static long sample_period; 78 module_param(sample_period, long, S_IRUGO | S_IWUSR); 79 MODULE_PARM_DESC(sample_period, "Override carrier sample period, us"); 80 81 /* override detected model id */ 82 static int model_number = -1; 83 module_param(model_number, int, S_IRUGO | S_IWUSR); 84 MODULE_PARM_DESC(model_number, "Use this model number, don't autodetect"); 85 86 87 /* HW-independent code functions */ 88 89 /* check whether carrier frequency is high frequency */ 90 static inline bool ite_is_high_carrier_freq(unsigned int freq) 91 { 92 return freq >= ITE_HCF_MIN_CARRIER_FREQ; 93 } 94 95 /* get the bits required to program the carrier frequency in CFQ bits, 96 * unshifted */ 97 static u8 ite_get_carrier_freq_bits(unsigned int freq) 98 { 99 if (ite_is_high_carrier_freq(freq)) { 100 if (freq < 425000) 101 return ITE_CFQ_400; 102 103 else if (freq < 465000) 104 return ITE_CFQ_450; 105 106 else if (freq < 490000) 107 return ITE_CFQ_480; 108 109 else 110 return ITE_CFQ_500; 111 } else { 112 /* trim to limits */ 113 if (freq < ITE_LCF_MIN_CARRIER_FREQ) 114 freq = ITE_LCF_MIN_CARRIER_FREQ; 115 if (freq > ITE_LCF_MAX_CARRIER_FREQ) 116 freq = ITE_LCF_MAX_CARRIER_FREQ; 117 118 /* convert to kHz and subtract the base freq */ 119 freq = 120 DIV_ROUND_CLOSEST(freq - ITE_LCF_MIN_CARRIER_FREQ, 121 1000); 122 123 return (u8) freq; 124 } 125 } 126 127 /* get the bits required to program the pulse with in TXMPW */ 128 static u8 ite_get_pulse_width_bits(unsigned int freq, int duty_cycle) 129 { 130 unsigned long period_ns, on_ns; 131 132 /* sanitize freq into range */ 133 if (freq < ITE_LCF_MIN_CARRIER_FREQ) 134 freq = ITE_LCF_MIN_CARRIER_FREQ; 135 if (freq > ITE_HCF_MAX_CARRIER_FREQ) 136 freq = ITE_HCF_MAX_CARRIER_FREQ; 137 138 period_ns = 1000000000UL / freq; 139 on_ns = period_ns * duty_cycle / 100; 140 141 if (ite_is_high_carrier_freq(freq)) { 142 if (on_ns < 750) 143 return ITE_TXMPW_A; 144 145 else if (on_ns < 850) 146 return ITE_TXMPW_B; 147 148 else if (on_ns < 950) 149 return ITE_TXMPW_C; 150 151 else if (on_ns < 1080) 152 return ITE_TXMPW_D; 153 154 else 155 return ITE_TXMPW_E; 156 } else { 157 if (on_ns < 6500) 158 return ITE_TXMPW_A; 159 160 else if (on_ns < 7850) 161 return ITE_TXMPW_B; 162 163 else if (on_ns < 9650) 164 return ITE_TXMPW_C; 165 166 else if (on_ns < 11950) 167 return ITE_TXMPW_D; 168 169 else 170 return ITE_TXMPW_E; 171 } 172 } 173 174 /* decode raw bytes as received by the hardware, and push them to the ir-core 175 * layer */ 176 static void ite_decode_bytes(struct ite_dev *dev, const u8 * data, int 177 length) 178 { 179 u32 sample_period; 180 unsigned long *ldata; 181 unsigned int next_one, next_zero, size; 182 DEFINE_IR_RAW_EVENT(ev); 183 184 if (length == 0) 185 return; 186 187 sample_period = dev->params.sample_period; 188 ldata = (unsigned long *)data; 189 size = length << 3; 190 next_one = find_next_bit_le(ldata, size, 0); 191 if (next_one > 0) { 192 ev.pulse = true; 193 ev.duration = 194 ITE_BITS_TO_NS(next_one, sample_period); 195 ir_raw_event_store_with_filter(dev->rdev, &ev); 196 } 197 198 while (next_one < size) { 199 next_zero = find_next_zero_bit_le(ldata, size, next_one + 1); 200 ev.pulse = false; 201 ev.duration = ITE_BITS_TO_NS(next_zero - next_one, sample_period); 202 ir_raw_event_store_with_filter(dev->rdev, &ev); 203 204 if (next_zero < size) { 205 next_one = 206 find_next_bit_le(ldata, 207 size, 208 next_zero + 1); 209 ev.pulse = true; 210 ev.duration = 211 ITE_BITS_TO_NS(next_one - next_zero, 212 sample_period); 213 ir_raw_event_store_with_filter 214 (dev->rdev, &ev); 215 } else 216 next_one = size; 217 } 218 219 ir_raw_event_handle(dev->rdev); 220 221 ite_dbg_verbose("decoded %d bytes.", length); 222 } 223 224 /* set all the rx/tx carrier parameters; this must be called with the device 225 * spinlock held */ 226 static void ite_set_carrier_params(struct ite_dev *dev) 227 { 228 unsigned int freq, low_freq, high_freq; 229 int allowance; 230 bool use_demodulator; 231 bool for_tx = dev->transmitting; 232 233 ite_dbg("%s called", __func__); 234 235 if (for_tx) { 236 /* we don't need no stinking calculations */ 237 freq = dev->params.tx_carrier_freq; 238 allowance = ITE_RXDCR_DEFAULT; 239 use_demodulator = false; 240 } else { 241 low_freq = dev->params.rx_low_carrier_freq; 242 high_freq = dev->params.rx_high_carrier_freq; 243 244 if (low_freq == 0) { 245 /* don't demodulate */ 246 freq = 247 ITE_DEFAULT_CARRIER_FREQ; 248 allowance = ITE_RXDCR_DEFAULT; 249 use_demodulator = false; 250 } else { 251 /* calculate the middle freq */ 252 freq = (low_freq + high_freq) / 2; 253 254 /* calculate the allowance */ 255 allowance = 256 DIV_ROUND_CLOSEST(10000 * (high_freq - low_freq), 257 ITE_RXDCR_PER_10000_STEP 258 * (high_freq + low_freq)); 259 260 if (allowance < 1) 261 allowance = 1; 262 263 if (allowance > ITE_RXDCR_MAX) 264 allowance = ITE_RXDCR_MAX; 265 } 266 } 267 268 /* set the carrier parameters in a device-dependent way */ 269 dev->params.set_carrier_params(dev, ite_is_high_carrier_freq(freq), 270 use_demodulator, ite_get_carrier_freq_bits(freq), allowance, 271 ite_get_pulse_width_bits(freq, dev->params.tx_duty_cycle)); 272 } 273 274 /* interrupt service routine for incoming and outgoing CIR data */ 275 static irqreturn_t ite_cir_isr(int irq, void *data) 276 { 277 struct ite_dev *dev = data; 278 unsigned long flags; 279 irqreturn_t ret = IRQ_RETVAL(IRQ_NONE); 280 u8 rx_buf[ITE_RX_FIFO_LEN]; 281 int rx_bytes; 282 int iflags; 283 284 ite_dbg_verbose("%s firing", __func__); 285 286 /* grab the spinlock */ 287 spin_lock_irqsave(&dev->lock, flags); 288 289 /* read the interrupt flags */ 290 iflags = dev->params.get_irq_causes(dev); 291 292 /* check for the receive interrupt */ 293 if (iflags & (ITE_IRQ_RX_FIFO | ITE_IRQ_RX_FIFO_OVERRUN)) { 294 /* read the FIFO bytes */ 295 rx_bytes = 296 dev->params.get_rx_bytes(dev, rx_buf, 297 ITE_RX_FIFO_LEN); 298 299 if (rx_bytes > 0) { 300 /* drop the spinlock, since the ir-core layer 301 * may call us back again through 302 * ite_s_idle() */ 303 spin_unlock_irqrestore(&dev-> 304 lock, 305 flags); 306 307 /* decode the data we've just received */ 308 ite_decode_bytes(dev, rx_buf, 309 rx_bytes); 310 311 /* reacquire the spinlock */ 312 spin_lock_irqsave(&dev->lock, 313 flags); 314 315 /* mark the interrupt as serviced */ 316 ret = IRQ_RETVAL(IRQ_HANDLED); 317 } 318 } else if (iflags & ITE_IRQ_TX_FIFO) { 319 /* FIFO space available interrupt */ 320 ite_dbg_verbose("got interrupt for TX FIFO"); 321 322 /* wake any sleeping transmitter */ 323 wake_up_interruptible(&dev->tx_queue); 324 325 /* mark the interrupt as serviced */ 326 ret = IRQ_RETVAL(IRQ_HANDLED); 327 } 328 329 /* drop the spinlock */ 330 spin_unlock_irqrestore(&dev->lock, flags); 331 332 ite_dbg_verbose("%s done returning %d", __func__, (int)ret); 333 334 return ret; 335 } 336 337 /* set the rx carrier freq range, guess it's in Hz... */ 338 static int ite_set_rx_carrier_range(struct rc_dev *rcdev, u32 carrier_low, u32 339 carrier_high) 340 { 341 unsigned long flags; 342 struct ite_dev *dev = rcdev->priv; 343 344 spin_lock_irqsave(&dev->lock, flags); 345 dev->params.rx_low_carrier_freq = carrier_low; 346 dev->params.rx_high_carrier_freq = carrier_high; 347 ite_set_carrier_params(dev); 348 spin_unlock_irqrestore(&dev->lock, flags); 349 350 return 0; 351 } 352 353 /* set the tx carrier freq, guess it's in Hz... */ 354 static int ite_set_tx_carrier(struct rc_dev *rcdev, u32 carrier) 355 { 356 unsigned long flags; 357 struct ite_dev *dev = rcdev->priv; 358 359 spin_lock_irqsave(&dev->lock, flags); 360 dev->params.tx_carrier_freq = carrier; 361 ite_set_carrier_params(dev); 362 spin_unlock_irqrestore(&dev->lock, flags); 363 364 return 0; 365 } 366 367 /* set the tx duty cycle by controlling the pulse width */ 368 static int ite_set_tx_duty_cycle(struct rc_dev *rcdev, u32 duty_cycle) 369 { 370 unsigned long flags; 371 struct ite_dev *dev = rcdev->priv; 372 373 spin_lock_irqsave(&dev->lock, flags); 374 dev->params.tx_duty_cycle = duty_cycle; 375 ite_set_carrier_params(dev); 376 spin_unlock_irqrestore(&dev->lock, flags); 377 378 return 0; 379 } 380 381 /* transmit out IR pulses; what you get here is a batch of alternating 382 * pulse/space/pulse/space lengths that we should write out completely through 383 * the FIFO, blocking on a full FIFO */ 384 static int ite_tx_ir(struct rc_dev *rcdev, int *txbuf, u32 n) 385 { 386 unsigned long flags; 387 struct ite_dev *dev = rcdev->priv; 388 bool is_pulse = false; 389 int remaining_us, fifo_avail, fifo_remaining, last_idx = 0; 390 int max_rle_us, next_rle_us; 391 int ret = n; 392 u8 last_sent[ITE_TX_FIFO_LEN]; 393 u8 val; 394 395 ite_dbg("%s called", __func__); 396 397 /* clear the array just in case */ 398 memset(last_sent, 0, ARRAY_SIZE(last_sent)); 399 400 /* n comes in bytes; convert to ints */ 401 n /= sizeof(int); 402 403 spin_lock_irqsave(&dev->lock, flags); 404 405 /* let everybody know we're now transmitting */ 406 dev->transmitting = true; 407 408 /* and set the carrier values for transmission */ 409 ite_set_carrier_params(dev); 410 411 /* calculate how much time we can send in one byte */ 412 max_rle_us = 413 (ITE_BAUDRATE_DIVISOR * dev->params.sample_period * 414 ITE_TX_MAX_RLE) / 1000; 415 416 /* disable the receiver */ 417 dev->params.disable_rx(dev); 418 419 /* this is where we'll begin filling in the FIFO, until it's full. 420 * then we'll just activate the interrupt, wait for it to wake us up 421 * again, disable it, continue filling the FIFO... until everything 422 * has been pushed out */ 423 fifo_avail = 424 ITE_TX_FIFO_LEN - dev->params.get_tx_used_slots(dev); 425 426 while (n > 0 && dev->in_use) { 427 /* transmit the next sample */ 428 is_pulse = !is_pulse; 429 remaining_us = *(txbuf++); 430 n--; 431 432 ite_dbg("%s: %ld", 433 ((is_pulse) ? "pulse" : "space"), 434 (long int) 435 remaining_us); 436 437 /* repeat while the pulse is non-zero length */ 438 while (remaining_us > 0 && dev->in_use) { 439 if (remaining_us > max_rle_us) 440 next_rle_us = max_rle_us; 441 442 else 443 next_rle_us = remaining_us; 444 445 remaining_us -= next_rle_us; 446 447 /* check what's the length we have to pump out */ 448 val = (ITE_TX_MAX_RLE * next_rle_us) / max_rle_us; 449 450 /* put it into the sent buffer */ 451 last_sent[last_idx++] = val; 452 last_idx &= (ITE_TX_FIFO_LEN); 453 454 /* encode it for 7 bits */ 455 val = (val - 1) & ITE_TX_RLE_MASK; 456 457 /* take into account pulse/space prefix */ 458 if (is_pulse) 459 val |= ITE_TX_PULSE; 460 461 else 462 val |= ITE_TX_SPACE; 463 464 /* 465 * if we get to 0 available, read again, just in case 466 * some other slot got freed 467 */ 468 if (fifo_avail <= 0) 469 fifo_avail = ITE_TX_FIFO_LEN - dev->params.get_tx_used_slots(dev); 470 471 /* if it's still full */ 472 if (fifo_avail <= 0) { 473 /* enable the tx interrupt */ 474 dev->params. 475 enable_tx_interrupt(dev); 476 477 /* drop the spinlock */ 478 spin_unlock_irqrestore(&dev->lock, flags); 479 480 /* wait for the FIFO to empty enough */ 481 wait_event_interruptible(dev->tx_queue, (fifo_avail = ITE_TX_FIFO_LEN - dev->params.get_tx_used_slots(dev)) >= 8); 482 483 /* get the spinlock again */ 484 spin_lock_irqsave(&dev->lock, flags); 485 486 /* disable the tx interrupt again. */ 487 dev->params. 488 disable_tx_interrupt(dev); 489 } 490 491 /* now send the byte through the FIFO */ 492 dev->params.put_tx_byte(dev, val); 493 fifo_avail--; 494 } 495 } 496 497 /* wait and don't return until the whole FIFO has been sent out; 498 * otherwise we could configure the RX carrier params instead of the 499 * TX ones while the transmission is still being performed! */ 500 fifo_remaining = dev->params.get_tx_used_slots(dev); 501 remaining_us = 0; 502 while (fifo_remaining > 0) { 503 fifo_remaining--; 504 last_idx--; 505 last_idx &= (ITE_TX_FIFO_LEN - 1); 506 remaining_us += last_sent[last_idx]; 507 } 508 remaining_us = (remaining_us * max_rle_us) / (ITE_TX_MAX_RLE); 509 510 /* drop the spinlock while we sleep */ 511 spin_unlock_irqrestore(&dev->lock, flags); 512 513 /* sleep remaining_us microseconds */ 514 mdelay(DIV_ROUND_UP(remaining_us, 1000)); 515 516 /* reacquire the spinlock */ 517 spin_lock_irqsave(&dev->lock, flags); 518 519 /* now we're not transmitting anymore */ 520 dev->transmitting = false; 521 522 /* and set the carrier values for reception */ 523 ite_set_carrier_params(dev); 524 525 /* reenable the receiver */ 526 if (dev->in_use) 527 dev->params.enable_rx(dev); 528 529 /* notify transmission end */ 530 wake_up_interruptible(&dev->tx_ended); 531 532 spin_unlock_irqrestore(&dev->lock, flags); 533 534 return ret; 535 } 536 537 /* idle the receiver if needed */ 538 static void ite_s_idle(struct rc_dev *rcdev, bool enable) 539 { 540 unsigned long flags; 541 struct ite_dev *dev = rcdev->priv; 542 543 ite_dbg("%s called", __func__); 544 545 if (enable) { 546 spin_lock_irqsave(&dev->lock, flags); 547 dev->params.idle_rx(dev); 548 spin_unlock_irqrestore(&dev->lock, flags); 549 } 550 } 551 552 553 /* IT8712F HW-specific functions */ 554 555 /* retrieve a bitmask of the current causes for a pending interrupt; this may 556 * be composed of ITE_IRQ_TX_FIFO, ITE_IRQ_RX_FIFO and ITE_IRQ_RX_FIFO_OVERRUN 557 * */ 558 static int it87_get_irq_causes(struct ite_dev *dev) 559 { 560 u8 iflags; 561 int ret = 0; 562 563 ite_dbg("%s called", __func__); 564 565 /* read the interrupt flags */ 566 iflags = inb(dev->cir_addr + IT87_IIR) & IT87_II; 567 568 switch (iflags) { 569 case IT87_II_RXDS: 570 ret = ITE_IRQ_RX_FIFO; 571 break; 572 case IT87_II_RXFO: 573 ret = ITE_IRQ_RX_FIFO_OVERRUN; 574 break; 575 case IT87_II_TXLDL: 576 ret = ITE_IRQ_TX_FIFO; 577 break; 578 } 579 580 return ret; 581 } 582 583 /* set the carrier parameters; to be called with the spinlock held */ 584 static void it87_set_carrier_params(struct ite_dev *dev, bool high_freq, 585 bool use_demodulator, 586 u8 carrier_freq_bits, u8 allowance_bits, 587 u8 pulse_width_bits) 588 { 589 u8 val; 590 591 ite_dbg("%s called", __func__); 592 593 /* program the RCR register */ 594 val = inb(dev->cir_addr + IT87_RCR) 595 & ~(IT87_HCFS | IT87_RXEND | IT87_RXDCR); 596 597 if (high_freq) 598 val |= IT87_HCFS; 599 600 if (use_demodulator) 601 val |= IT87_RXEND; 602 603 val |= allowance_bits; 604 605 outb(val, dev->cir_addr + IT87_RCR); 606 607 /* program the TCR2 register */ 608 outb((carrier_freq_bits << IT87_CFQ_SHIFT) | pulse_width_bits, 609 dev->cir_addr + IT87_TCR2); 610 } 611 612 /* read up to buf_size bytes from the RX FIFO; to be called with the spinlock 613 * held */ 614 static int it87_get_rx_bytes(struct ite_dev *dev, u8 * buf, int buf_size) 615 { 616 int fifo, read = 0; 617 618 ite_dbg("%s called", __func__); 619 620 /* read how many bytes are still in the FIFO */ 621 fifo = inb(dev->cir_addr + IT87_RSR) & IT87_RXFBC; 622 623 while (fifo > 0 && buf_size > 0) { 624 *(buf++) = inb(dev->cir_addr + IT87_DR); 625 fifo--; 626 read++; 627 buf_size--; 628 } 629 630 return read; 631 } 632 633 /* return how many bytes are still in the FIFO; this will be called 634 * with the device spinlock NOT HELD while waiting for the TX FIFO to get 635 * empty; let's expect this won't be a problem */ 636 static int it87_get_tx_used_slots(struct ite_dev *dev) 637 { 638 ite_dbg("%s called", __func__); 639 640 return inb(dev->cir_addr + IT87_TSR) & IT87_TXFBC; 641 } 642 643 /* put a byte to the TX fifo; this should be called with the spinlock held */ 644 static void it87_put_tx_byte(struct ite_dev *dev, u8 value) 645 { 646 outb(value, dev->cir_addr + IT87_DR); 647 } 648 649 /* idle the receiver so that we won't receive samples until another 650 pulse is detected; this must be called with the device spinlock held */ 651 static void it87_idle_rx(struct ite_dev *dev) 652 { 653 ite_dbg("%s called", __func__); 654 655 /* disable streaming by clearing RXACT writing it as 1 */ 656 outb(inb(dev->cir_addr + IT87_RCR) | IT87_RXACT, 657 dev->cir_addr + IT87_RCR); 658 659 /* clear the FIFO */ 660 outb(inb(dev->cir_addr + IT87_TCR1) | IT87_FIFOCLR, 661 dev->cir_addr + IT87_TCR1); 662 } 663 664 /* disable the receiver; this must be called with the device spinlock held */ 665 static void it87_disable_rx(struct ite_dev *dev) 666 { 667 ite_dbg("%s called", __func__); 668 669 /* disable the receiver interrupts */ 670 outb(inb(dev->cir_addr + IT87_IER) & ~(IT87_RDAIE | IT87_RFOIE), 671 dev->cir_addr + IT87_IER); 672 673 /* disable the receiver */ 674 outb(inb(dev->cir_addr + IT87_RCR) & ~IT87_RXEN, 675 dev->cir_addr + IT87_RCR); 676 677 /* clear the FIFO and RXACT (actually RXACT should have been cleared 678 * in the previous outb() call) */ 679 it87_idle_rx(dev); 680 } 681 682 /* enable the receiver; this must be called with the device spinlock held */ 683 static void it87_enable_rx(struct ite_dev *dev) 684 { 685 ite_dbg("%s called", __func__); 686 687 /* enable the receiver by setting RXEN */ 688 outb(inb(dev->cir_addr + IT87_RCR) | IT87_RXEN, 689 dev->cir_addr + IT87_RCR); 690 691 /* just prepare it to idle for the next reception */ 692 it87_idle_rx(dev); 693 694 /* enable the receiver interrupts and master enable flag */ 695 outb(inb(dev->cir_addr + IT87_IER) | IT87_RDAIE | IT87_RFOIE | IT87_IEC, 696 dev->cir_addr + IT87_IER); 697 } 698 699 /* disable the transmitter interrupt; this must be called with the device 700 * spinlock held */ 701 static void it87_disable_tx_interrupt(struct ite_dev *dev) 702 { 703 ite_dbg("%s called", __func__); 704 705 /* disable the transmitter interrupts */ 706 outb(inb(dev->cir_addr + IT87_IER) & ~IT87_TLDLIE, 707 dev->cir_addr + IT87_IER); 708 } 709 710 /* enable the transmitter interrupt; this must be called with the device 711 * spinlock held */ 712 static void it87_enable_tx_interrupt(struct ite_dev *dev) 713 { 714 ite_dbg("%s called", __func__); 715 716 /* enable the transmitter interrupts and master enable flag */ 717 outb(inb(dev->cir_addr + IT87_IER) | IT87_TLDLIE | IT87_IEC, 718 dev->cir_addr + IT87_IER); 719 } 720 721 /* disable the device; this must be called with the device spinlock held */ 722 static void it87_disable(struct ite_dev *dev) 723 { 724 ite_dbg("%s called", __func__); 725 726 /* clear out all interrupt enable flags */ 727 outb(inb(dev->cir_addr + IT87_IER) & 728 ~(IT87_IEC | IT87_RFOIE | IT87_RDAIE | IT87_TLDLIE), 729 dev->cir_addr + IT87_IER); 730 731 /* disable the receiver */ 732 it87_disable_rx(dev); 733 734 /* erase the FIFO */ 735 outb(IT87_FIFOCLR | inb(dev->cir_addr + IT87_TCR1), 736 dev->cir_addr + IT87_TCR1); 737 } 738 739 /* initialize the hardware */ 740 static void it87_init_hardware(struct ite_dev *dev) 741 { 742 ite_dbg("%s called", __func__); 743 744 /* enable just the baud rate divisor register, 745 disabling all the interrupts at the same time */ 746 outb((inb(dev->cir_addr + IT87_IER) & 747 ~(IT87_IEC | IT87_RFOIE | IT87_RDAIE | IT87_TLDLIE)) | IT87_BR, 748 dev->cir_addr + IT87_IER); 749 750 /* write out the baud rate divisor */ 751 outb(ITE_BAUDRATE_DIVISOR & 0xff, dev->cir_addr + IT87_BDLR); 752 outb((ITE_BAUDRATE_DIVISOR >> 8) & 0xff, dev->cir_addr + IT87_BDHR); 753 754 /* disable the baud rate divisor register again */ 755 outb(inb(dev->cir_addr + IT87_IER) & ~IT87_BR, 756 dev->cir_addr + IT87_IER); 757 758 /* program the RCR register defaults */ 759 outb(ITE_RXDCR_DEFAULT, dev->cir_addr + IT87_RCR); 760 761 /* program the TCR1 register */ 762 outb(IT87_TXMPM_DEFAULT | IT87_TXENDF | IT87_TXRLE 763 | IT87_FIFOTL_DEFAULT | IT87_FIFOCLR, 764 dev->cir_addr + IT87_TCR1); 765 766 /* program the carrier parameters */ 767 ite_set_carrier_params(dev); 768 } 769 770 /* IT8512F on ITE8708 HW-specific functions */ 771 772 /* retrieve a bitmask of the current causes for a pending interrupt; this may 773 * be composed of ITE_IRQ_TX_FIFO, ITE_IRQ_RX_FIFO and ITE_IRQ_RX_FIFO_OVERRUN 774 * */ 775 static int it8708_get_irq_causes(struct ite_dev *dev) 776 { 777 u8 iflags; 778 int ret = 0; 779 780 ite_dbg("%s called", __func__); 781 782 /* read the interrupt flags */ 783 iflags = inb(dev->cir_addr + IT8708_C0IIR); 784 785 if (iflags & IT85_TLDLI) 786 ret |= ITE_IRQ_TX_FIFO; 787 if (iflags & IT85_RDAI) 788 ret |= ITE_IRQ_RX_FIFO; 789 if (iflags & IT85_RFOI) 790 ret |= ITE_IRQ_RX_FIFO_OVERRUN; 791 792 return ret; 793 } 794 795 /* set the carrier parameters; to be called with the spinlock held */ 796 static void it8708_set_carrier_params(struct ite_dev *dev, bool high_freq, 797 bool use_demodulator, 798 u8 carrier_freq_bits, u8 allowance_bits, 799 u8 pulse_width_bits) 800 { 801 u8 val; 802 803 ite_dbg("%s called", __func__); 804 805 /* program the C0CFR register, with HRAE=1 */ 806 outb(inb(dev->cir_addr + IT8708_BANKSEL) | IT8708_HRAE, 807 dev->cir_addr + IT8708_BANKSEL); 808 809 val = (inb(dev->cir_addr + IT8708_C0CFR) 810 & ~(IT85_HCFS | IT85_CFQ)) | carrier_freq_bits; 811 812 if (high_freq) 813 val |= IT85_HCFS; 814 815 outb(val, dev->cir_addr + IT8708_C0CFR); 816 817 outb(inb(dev->cir_addr + IT8708_BANKSEL) & ~IT8708_HRAE, 818 dev->cir_addr + IT8708_BANKSEL); 819 820 /* program the C0RCR register */ 821 val = inb(dev->cir_addr + IT8708_C0RCR) 822 & ~(IT85_RXEND | IT85_RXDCR); 823 824 if (use_demodulator) 825 val |= IT85_RXEND; 826 827 val |= allowance_bits; 828 829 outb(val, dev->cir_addr + IT8708_C0RCR); 830 831 /* program the C0TCR register */ 832 val = inb(dev->cir_addr + IT8708_C0TCR) & ~IT85_TXMPW; 833 val |= pulse_width_bits; 834 outb(val, dev->cir_addr + IT8708_C0TCR); 835 } 836 837 /* read up to buf_size bytes from the RX FIFO; to be called with the spinlock 838 * held */ 839 static int it8708_get_rx_bytes(struct ite_dev *dev, u8 * buf, int buf_size) 840 { 841 int fifo, read = 0; 842 843 ite_dbg("%s called", __func__); 844 845 /* read how many bytes are still in the FIFO */ 846 fifo = inb(dev->cir_addr + IT8708_C0RFSR) & IT85_RXFBC; 847 848 while (fifo > 0 && buf_size > 0) { 849 *(buf++) = inb(dev->cir_addr + IT8708_C0DR); 850 fifo--; 851 read++; 852 buf_size--; 853 } 854 855 return read; 856 } 857 858 /* return how many bytes are still in the FIFO; this will be called 859 * with the device spinlock NOT HELD while waiting for the TX FIFO to get 860 * empty; let's expect this won't be a problem */ 861 static int it8708_get_tx_used_slots(struct ite_dev *dev) 862 { 863 ite_dbg("%s called", __func__); 864 865 return inb(dev->cir_addr + IT8708_C0TFSR) & IT85_TXFBC; 866 } 867 868 /* put a byte to the TX fifo; this should be called with the spinlock held */ 869 static void it8708_put_tx_byte(struct ite_dev *dev, u8 value) 870 { 871 outb(value, dev->cir_addr + IT8708_C0DR); 872 } 873 874 /* idle the receiver so that we won't receive samples until another 875 pulse is detected; this must be called with the device spinlock held */ 876 static void it8708_idle_rx(struct ite_dev *dev) 877 { 878 ite_dbg("%s called", __func__); 879 880 /* disable streaming by clearing RXACT writing it as 1 */ 881 outb(inb(dev->cir_addr + IT8708_C0RCR) | IT85_RXACT, 882 dev->cir_addr + IT8708_C0RCR); 883 884 /* clear the FIFO */ 885 outb(inb(dev->cir_addr + IT8708_C0MSTCR) | IT85_FIFOCLR, 886 dev->cir_addr + IT8708_C0MSTCR); 887 } 888 889 /* disable the receiver; this must be called with the device spinlock held */ 890 static void it8708_disable_rx(struct ite_dev *dev) 891 { 892 ite_dbg("%s called", __func__); 893 894 /* disable the receiver interrupts */ 895 outb(inb(dev->cir_addr + IT8708_C0IER) & 896 ~(IT85_RDAIE | IT85_RFOIE), 897 dev->cir_addr + IT8708_C0IER); 898 899 /* disable the receiver */ 900 outb(inb(dev->cir_addr + IT8708_C0RCR) & ~IT85_RXEN, 901 dev->cir_addr + IT8708_C0RCR); 902 903 /* clear the FIFO and RXACT (actually RXACT should have been cleared 904 * in the previous outb() call) */ 905 it8708_idle_rx(dev); 906 } 907 908 /* enable the receiver; this must be called with the device spinlock held */ 909 static void it8708_enable_rx(struct ite_dev *dev) 910 { 911 ite_dbg("%s called", __func__); 912 913 /* enable the receiver by setting RXEN */ 914 outb(inb(dev->cir_addr + IT8708_C0RCR) | IT85_RXEN, 915 dev->cir_addr + IT8708_C0RCR); 916 917 /* just prepare it to idle for the next reception */ 918 it8708_idle_rx(dev); 919 920 /* enable the receiver interrupts and master enable flag */ 921 outb(inb(dev->cir_addr + IT8708_C0IER) 922 |IT85_RDAIE | IT85_RFOIE | IT85_IEC, 923 dev->cir_addr + IT8708_C0IER); 924 } 925 926 /* disable the transmitter interrupt; this must be called with the device 927 * spinlock held */ 928 static void it8708_disable_tx_interrupt(struct ite_dev *dev) 929 { 930 ite_dbg("%s called", __func__); 931 932 /* disable the transmitter interrupts */ 933 outb(inb(dev->cir_addr + IT8708_C0IER) & ~IT85_TLDLIE, 934 dev->cir_addr + IT8708_C0IER); 935 } 936 937 /* enable the transmitter interrupt; this must be called with the device 938 * spinlock held */ 939 static void it8708_enable_tx_interrupt(struct ite_dev *dev) 940 { 941 ite_dbg("%s called", __func__); 942 943 /* enable the transmitter interrupts and master enable flag */ 944 outb(inb(dev->cir_addr + IT8708_C0IER) 945 |IT85_TLDLIE | IT85_IEC, 946 dev->cir_addr + IT8708_C0IER); 947 } 948 949 /* disable the device; this must be called with the device spinlock held */ 950 static void it8708_disable(struct ite_dev *dev) 951 { 952 ite_dbg("%s called", __func__); 953 954 /* clear out all interrupt enable flags */ 955 outb(inb(dev->cir_addr + IT8708_C0IER) & 956 ~(IT85_IEC | IT85_RFOIE | IT85_RDAIE | IT85_TLDLIE), 957 dev->cir_addr + IT8708_C0IER); 958 959 /* disable the receiver */ 960 it8708_disable_rx(dev); 961 962 /* erase the FIFO */ 963 outb(IT85_FIFOCLR | inb(dev->cir_addr + IT8708_C0MSTCR), 964 dev->cir_addr + IT8708_C0MSTCR); 965 } 966 967 /* initialize the hardware */ 968 static void it8708_init_hardware(struct ite_dev *dev) 969 { 970 ite_dbg("%s called", __func__); 971 972 /* disable all the interrupts */ 973 outb(inb(dev->cir_addr + IT8708_C0IER) & 974 ~(IT85_IEC | IT85_RFOIE | IT85_RDAIE | IT85_TLDLIE), 975 dev->cir_addr + IT8708_C0IER); 976 977 /* program the baud rate divisor */ 978 outb(inb(dev->cir_addr + IT8708_BANKSEL) | IT8708_HRAE, 979 dev->cir_addr + IT8708_BANKSEL); 980 981 outb(ITE_BAUDRATE_DIVISOR & 0xff, dev->cir_addr + IT8708_C0BDLR); 982 outb((ITE_BAUDRATE_DIVISOR >> 8) & 0xff, 983 dev->cir_addr + IT8708_C0BDHR); 984 985 outb(inb(dev->cir_addr + IT8708_BANKSEL) & ~IT8708_HRAE, 986 dev->cir_addr + IT8708_BANKSEL); 987 988 /* program the C0MSTCR register defaults */ 989 outb((inb(dev->cir_addr + IT8708_C0MSTCR) & 990 ~(IT85_ILSEL | IT85_ILE | IT85_FIFOTL | 991 IT85_FIFOCLR | IT85_RESET)) | 992 IT85_FIFOTL_DEFAULT, 993 dev->cir_addr + IT8708_C0MSTCR); 994 995 /* program the C0RCR register defaults */ 996 outb((inb(dev->cir_addr + IT8708_C0RCR) & 997 ~(IT85_RXEN | IT85_RDWOS | IT85_RXEND | 998 IT85_RXACT | IT85_RXDCR)) | 999 ITE_RXDCR_DEFAULT, 1000 dev->cir_addr + IT8708_C0RCR); 1001 1002 /* program the C0TCR register defaults */ 1003 outb((inb(dev->cir_addr + IT8708_C0TCR) & 1004 ~(IT85_TXMPM | IT85_TXMPW)) 1005 |IT85_TXRLE | IT85_TXENDF | 1006 IT85_TXMPM_DEFAULT | IT85_TXMPW_DEFAULT, 1007 dev->cir_addr + IT8708_C0TCR); 1008 1009 /* program the carrier parameters */ 1010 ite_set_carrier_params(dev); 1011 } 1012 1013 /* IT8512F on ITE8709 HW-specific functions */ 1014 1015 /* read a byte from the SRAM module */ 1016 static inline u8 it8709_rm(struct ite_dev *dev, int index) 1017 { 1018 outb(index, dev->cir_addr + IT8709_RAM_IDX); 1019 return inb(dev->cir_addr + IT8709_RAM_VAL); 1020 } 1021 1022 /* write a byte to the SRAM module */ 1023 static inline void it8709_wm(struct ite_dev *dev, u8 val, int index) 1024 { 1025 outb(index, dev->cir_addr + IT8709_RAM_IDX); 1026 outb(val, dev->cir_addr + IT8709_RAM_VAL); 1027 } 1028 1029 static void it8709_wait(struct ite_dev *dev) 1030 { 1031 int i = 0; 1032 /* 1033 * loop until device tells it's ready to continue 1034 * iterations count is usually ~750 but can sometimes achieve 13000 1035 */ 1036 for (i = 0; i < 15000; i++) { 1037 udelay(2); 1038 if (it8709_rm(dev, IT8709_MODE) == IT8709_IDLE) 1039 break; 1040 } 1041 } 1042 1043 /* read the value of a CIR register */ 1044 static u8 it8709_rr(struct ite_dev *dev, int index) 1045 { 1046 /* just wait in case the previous access was a write */ 1047 it8709_wait(dev); 1048 it8709_wm(dev, index, IT8709_REG_IDX); 1049 it8709_wm(dev, IT8709_READ, IT8709_MODE); 1050 1051 /* wait for the read data to be available */ 1052 it8709_wait(dev); 1053 1054 /* return the read value */ 1055 return it8709_rm(dev, IT8709_REG_VAL); 1056 } 1057 1058 /* write the value of a CIR register */ 1059 static void it8709_wr(struct ite_dev *dev, u8 val, int index) 1060 { 1061 /* we wait before writing, and not afterwards, since this allows us to 1062 * pipeline the host CPU with the microcontroller */ 1063 it8709_wait(dev); 1064 it8709_wm(dev, val, IT8709_REG_VAL); 1065 it8709_wm(dev, index, IT8709_REG_IDX); 1066 it8709_wm(dev, IT8709_WRITE, IT8709_MODE); 1067 } 1068 1069 /* retrieve a bitmask of the current causes for a pending interrupt; this may 1070 * be composed of ITE_IRQ_TX_FIFO, ITE_IRQ_RX_FIFO and ITE_IRQ_RX_FIFO_OVERRUN 1071 * */ 1072 static int it8709_get_irq_causes(struct ite_dev *dev) 1073 { 1074 u8 iflags; 1075 int ret = 0; 1076 1077 ite_dbg("%s called", __func__); 1078 1079 /* read the interrupt flags */ 1080 iflags = it8709_rm(dev, IT8709_IIR); 1081 1082 if (iflags & IT85_TLDLI) 1083 ret |= ITE_IRQ_TX_FIFO; 1084 if (iflags & IT85_RDAI) 1085 ret |= ITE_IRQ_RX_FIFO; 1086 if (iflags & IT85_RFOI) 1087 ret |= ITE_IRQ_RX_FIFO_OVERRUN; 1088 1089 return ret; 1090 } 1091 1092 /* set the carrier parameters; to be called with the spinlock held */ 1093 static void it8709_set_carrier_params(struct ite_dev *dev, bool high_freq, 1094 bool use_demodulator, 1095 u8 carrier_freq_bits, u8 allowance_bits, 1096 u8 pulse_width_bits) 1097 { 1098 u8 val; 1099 1100 ite_dbg("%s called", __func__); 1101 1102 val = (it8709_rr(dev, IT85_C0CFR) 1103 &~(IT85_HCFS | IT85_CFQ)) | 1104 carrier_freq_bits; 1105 1106 if (high_freq) 1107 val |= IT85_HCFS; 1108 1109 it8709_wr(dev, val, IT85_C0CFR); 1110 1111 /* program the C0RCR register */ 1112 val = it8709_rr(dev, IT85_C0RCR) 1113 & ~(IT85_RXEND | IT85_RXDCR); 1114 1115 if (use_demodulator) 1116 val |= IT85_RXEND; 1117 1118 val |= allowance_bits; 1119 1120 it8709_wr(dev, val, IT85_C0RCR); 1121 1122 /* program the C0TCR register */ 1123 val = it8709_rr(dev, IT85_C0TCR) & ~IT85_TXMPW; 1124 val |= pulse_width_bits; 1125 it8709_wr(dev, val, IT85_C0TCR); 1126 } 1127 1128 /* read up to buf_size bytes from the RX FIFO; to be called with the spinlock 1129 * held */ 1130 static int it8709_get_rx_bytes(struct ite_dev *dev, u8 * buf, int buf_size) 1131 { 1132 int fifo, read = 0; 1133 1134 ite_dbg("%s called", __func__); 1135 1136 /* read how many bytes are still in the FIFO */ 1137 fifo = it8709_rm(dev, IT8709_RFSR) & IT85_RXFBC; 1138 1139 while (fifo > 0 && buf_size > 0) { 1140 *(buf++) = it8709_rm(dev, IT8709_FIFO + read); 1141 fifo--; 1142 read++; 1143 buf_size--; 1144 } 1145 1146 /* 'clear' the FIFO by setting the writing index to 0; this is 1147 * completely bound to be racy, but we can't help it, since it's a 1148 * limitation of the protocol */ 1149 it8709_wm(dev, 0, IT8709_RFSR); 1150 1151 return read; 1152 } 1153 1154 /* return how many bytes are still in the FIFO; this will be called 1155 * with the device spinlock NOT HELD while waiting for the TX FIFO to get 1156 * empty; let's expect this won't be a problem */ 1157 static int it8709_get_tx_used_slots(struct ite_dev *dev) 1158 { 1159 ite_dbg("%s called", __func__); 1160 1161 return it8709_rr(dev, IT85_C0TFSR) & IT85_TXFBC; 1162 } 1163 1164 /* put a byte to the TX fifo; this should be called with the spinlock held */ 1165 static void it8709_put_tx_byte(struct ite_dev *dev, u8 value) 1166 { 1167 it8709_wr(dev, value, IT85_C0DR); 1168 } 1169 1170 /* idle the receiver so that we won't receive samples until another 1171 pulse is detected; this must be called with the device spinlock held */ 1172 static void it8709_idle_rx(struct ite_dev *dev) 1173 { 1174 ite_dbg("%s called", __func__); 1175 1176 /* disable streaming by clearing RXACT writing it as 1 */ 1177 it8709_wr(dev, it8709_rr(dev, IT85_C0RCR) | IT85_RXACT, 1178 IT85_C0RCR); 1179 1180 /* clear the FIFO */ 1181 it8709_wr(dev, it8709_rr(dev, IT85_C0MSTCR) | IT85_FIFOCLR, 1182 IT85_C0MSTCR); 1183 } 1184 1185 /* disable the receiver; this must be called with the device spinlock held */ 1186 static void it8709_disable_rx(struct ite_dev *dev) 1187 { 1188 ite_dbg("%s called", __func__); 1189 1190 /* disable the receiver interrupts */ 1191 it8709_wr(dev, it8709_rr(dev, IT85_C0IER) & 1192 ~(IT85_RDAIE | IT85_RFOIE), 1193 IT85_C0IER); 1194 1195 /* disable the receiver */ 1196 it8709_wr(dev, it8709_rr(dev, IT85_C0RCR) & ~IT85_RXEN, 1197 IT85_C0RCR); 1198 1199 /* clear the FIFO and RXACT (actually RXACT should have been cleared 1200 * in the previous it8709_wr(dev, ) call) */ 1201 it8709_idle_rx(dev); 1202 } 1203 1204 /* enable the receiver; this must be called with the device spinlock held */ 1205 static void it8709_enable_rx(struct ite_dev *dev) 1206 { 1207 ite_dbg("%s called", __func__); 1208 1209 /* enable the receiver by setting RXEN */ 1210 it8709_wr(dev, it8709_rr(dev, IT85_C0RCR) | IT85_RXEN, 1211 IT85_C0RCR); 1212 1213 /* just prepare it to idle for the next reception */ 1214 it8709_idle_rx(dev); 1215 1216 /* enable the receiver interrupts and master enable flag */ 1217 it8709_wr(dev, it8709_rr(dev, IT85_C0IER) 1218 |IT85_RDAIE | IT85_RFOIE | IT85_IEC, 1219 IT85_C0IER); 1220 } 1221 1222 /* disable the transmitter interrupt; this must be called with the device 1223 * spinlock held */ 1224 static void it8709_disable_tx_interrupt(struct ite_dev *dev) 1225 { 1226 ite_dbg("%s called", __func__); 1227 1228 /* disable the transmitter interrupts */ 1229 it8709_wr(dev, it8709_rr(dev, IT85_C0IER) & ~IT85_TLDLIE, 1230 IT85_C0IER); 1231 } 1232 1233 /* enable the transmitter interrupt; this must be called with the device 1234 * spinlock held */ 1235 static void it8709_enable_tx_interrupt(struct ite_dev *dev) 1236 { 1237 ite_dbg("%s called", __func__); 1238 1239 /* enable the transmitter interrupts and master enable flag */ 1240 it8709_wr(dev, it8709_rr(dev, IT85_C0IER) 1241 |IT85_TLDLIE | IT85_IEC, 1242 IT85_C0IER); 1243 } 1244 1245 /* disable the device; this must be called with the device spinlock held */ 1246 static void it8709_disable(struct ite_dev *dev) 1247 { 1248 ite_dbg("%s called", __func__); 1249 1250 /* clear out all interrupt enable flags */ 1251 it8709_wr(dev, 1252 it8709_rr(dev, 1253 IT85_C0IER) & ~(IT85_IEC | IT85_RFOIE | 1254 IT85_RDAIE | 1255 IT85_TLDLIE), IT85_C0IER); 1256 1257 /* disable the receiver */ 1258 it8709_disable_rx(dev); 1259 1260 /* erase the FIFO */ 1261 it8709_wr(dev, IT85_FIFOCLR | it8709_rr(dev, IT85_C0MSTCR), 1262 IT85_C0MSTCR); 1263 } 1264 1265 /* initialize the hardware */ 1266 static void it8709_init_hardware(struct ite_dev *dev) 1267 { 1268 ite_dbg("%s called", __func__); 1269 1270 /* disable all the interrupts */ 1271 it8709_wr(dev, 1272 it8709_rr(dev, 1273 IT85_C0IER) & ~(IT85_IEC | IT85_RFOIE | 1274 IT85_RDAIE | 1275 IT85_TLDLIE), IT85_C0IER); 1276 1277 /* program the baud rate divisor */ 1278 it8709_wr(dev, ITE_BAUDRATE_DIVISOR & 0xff, IT85_C0BDLR); 1279 it8709_wr(dev, (ITE_BAUDRATE_DIVISOR >> 8) & 0xff, 1280 IT85_C0BDHR); 1281 1282 /* program the C0MSTCR register defaults */ 1283 it8709_wr(dev, (it8709_rr(dev, IT85_C0MSTCR) & ~(IT85_ILSEL | 1284 IT85_ILE 1285 | IT85_FIFOTL 1286 | 1287 IT85_FIFOCLR 1288 | 1289 IT85_RESET)) 1290 | IT85_FIFOTL_DEFAULT, IT85_C0MSTCR); 1291 1292 /* program the C0RCR register defaults */ 1293 it8709_wr(dev, 1294 (it8709_rr(dev, IT85_C0RCR) & 1295 ~(IT85_RXEN | IT85_RDWOS | IT85_RXEND 1296 | IT85_RXACT | IT85_RXDCR)) | 1297 ITE_RXDCR_DEFAULT, IT85_C0RCR); 1298 1299 /* program the C0TCR register defaults */ 1300 it8709_wr(dev, (it8709_rr(dev, IT85_C0TCR) 1301 &~(IT85_TXMPM | IT85_TXMPW)) 1302 |IT85_TXRLE | IT85_TXENDF | 1303 IT85_TXMPM_DEFAULT | 1304 IT85_TXMPW_DEFAULT, IT85_C0TCR); 1305 1306 /* program the carrier parameters */ 1307 ite_set_carrier_params(dev); 1308 } 1309 1310 1311 /* generic hardware setup/teardown code */ 1312 1313 /* activate the device for use */ 1314 static int ite_open(struct rc_dev *rcdev) 1315 { 1316 struct ite_dev *dev = rcdev->priv; 1317 unsigned long flags; 1318 1319 ite_dbg("%s called", __func__); 1320 1321 spin_lock_irqsave(&dev->lock, flags); 1322 dev->in_use = true; 1323 1324 /* enable the receiver */ 1325 dev->params.enable_rx(dev); 1326 1327 spin_unlock_irqrestore(&dev->lock, flags); 1328 1329 return 0; 1330 } 1331 1332 /* deactivate the device for use */ 1333 static void ite_close(struct rc_dev *rcdev) 1334 { 1335 struct ite_dev *dev = rcdev->priv; 1336 unsigned long flags; 1337 1338 ite_dbg("%s called", __func__); 1339 1340 spin_lock_irqsave(&dev->lock, flags); 1341 dev->in_use = false; 1342 1343 /* wait for any transmission to end */ 1344 spin_unlock_irqrestore(&dev->lock, flags); 1345 wait_event_interruptible(dev->tx_ended, !dev->transmitting); 1346 spin_lock_irqsave(&dev->lock, flags); 1347 1348 dev->params.disable(dev); 1349 1350 spin_unlock_irqrestore(&dev->lock, flags); 1351 } 1352 1353 /* supported models and their parameters */ 1354 static const struct ite_dev_params ite_dev_descs[] = { 1355 { /* 0: ITE8704 */ 1356 .model = "ITE8704 CIR transceiver", 1357 .io_region_size = IT87_IOREG_LENGTH, 1358 .hw_tx_capable = true, 1359 .sample_period = (u32) (1000000000ULL / 115200), 1360 .tx_carrier_freq = 38000, 1361 .tx_duty_cycle = 33, 1362 .rx_low_carrier_freq = 0, 1363 .rx_high_carrier_freq = 0, 1364 1365 /* operations */ 1366 .get_irq_causes = it87_get_irq_causes, 1367 .enable_rx = it87_enable_rx, 1368 .idle_rx = it87_idle_rx, 1369 .disable_rx = it87_idle_rx, 1370 .get_rx_bytes = it87_get_rx_bytes, 1371 .enable_tx_interrupt = it87_enable_tx_interrupt, 1372 .disable_tx_interrupt = it87_disable_tx_interrupt, 1373 .get_tx_used_slots = it87_get_tx_used_slots, 1374 .put_tx_byte = it87_put_tx_byte, 1375 .disable = it87_disable, 1376 .init_hardware = it87_init_hardware, 1377 .set_carrier_params = it87_set_carrier_params, 1378 }, 1379 { /* 1: ITE8713 */ 1380 .model = "ITE8713 CIR transceiver", 1381 .io_region_size = IT87_IOREG_LENGTH, 1382 .hw_tx_capable = true, 1383 .sample_period = (u32) (1000000000ULL / 115200), 1384 .tx_carrier_freq = 38000, 1385 .tx_duty_cycle = 33, 1386 .rx_low_carrier_freq = 0, 1387 .rx_high_carrier_freq = 0, 1388 1389 /* operations */ 1390 .get_irq_causes = it87_get_irq_causes, 1391 .enable_rx = it87_enable_rx, 1392 .idle_rx = it87_idle_rx, 1393 .disable_rx = it87_idle_rx, 1394 .get_rx_bytes = it87_get_rx_bytes, 1395 .enable_tx_interrupt = it87_enable_tx_interrupt, 1396 .disable_tx_interrupt = it87_disable_tx_interrupt, 1397 .get_tx_used_slots = it87_get_tx_used_slots, 1398 .put_tx_byte = it87_put_tx_byte, 1399 .disable = it87_disable, 1400 .init_hardware = it87_init_hardware, 1401 .set_carrier_params = it87_set_carrier_params, 1402 }, 1403 { /* 2: ITE8708 */ 1404 .model = "ITE8708 CIR transceiver", 1405 .io_region_size = IT8708_IOREG_LENGTH, 1406 .hw_tx_capable = true, 1407 .sample_period = (u32) (1000000000ULL / 115200), 1408 .tx_carrier_freq = 38000, 1409 .tx_duty_cycle = 33, 1410 .rx_low_carrier_freq = 0, 1411 .rx_high_carrier_freq = 0, 1412 1413 /* operations */ 1414 .get_irq_causes = it8708_get_irq_causes, 1415 .enable_rx = it8708_enable_rx, 1416 .idle_rx = it8708_idle_rx, 1417 .disable_rx = it8708_idle_rx, 1418 .get_rx_bytes = it8708_get_rx_bytes, 1419 .enable_tx_interrupt = it8708_enable_tx_interrupt, 1420 .disable_tx_interrupt = 1421 it8708_disable_tx_interrupt, 1422 .get_tx_used_slots = it8708_get_tx_used_slots, 1423 .put_tx_byte = it8708_put_tx_byte, 1424 .disable = it8708_disable, 1425 .init_hardware = it8708_init_hardware, 1426 .set_carrier_params = it8708_set_carrier_params, 1427 }, 1428 { /* 3: ITE8709 */ 1429 .model = "ITE8709 CIR transceiver", 1430 .io_region_size = IT8709_IOREG_LENGTH, 1431 .hw_tx_capable = true, 1432 .sample_period = (u32) (1000000000ULL / 115200), 1433 .tx_carrier_freq = 38000, 1434 .tx_duty_cycle = 33, 1435 .rx_low_carrier_freq = 0, 1436 .rx_high_carrier_freq = 0, 1437 1438 /* operations */ 1439 .get_irq_causes = it8709_get_irq_causes, 1440 .enable_rx = it8709_enable_rx, 1441 .idle_rx = it8709_idle_rx, 1442 .disable_rx = it8709_idle_rx, 1443 .get_rx_bytes = it8709_get_rx_bytes, 1444 .enable_tx_interrupt = it8709_enable_tx_interrupt, 1445 .disable_tx_interrupt = 1446 it8709_disable_tx_interrupt, 1447 .get_tx_used_slots = it8709_get_tx_used_slots, 1448 .put_tx_byte = it8709_put_tx_byte, 1449 .disable = it8709_disable, 1450 .init_hardware = it8709_init_hardware, 1451 .set_carrier_params = it8709_set_carrier_params, 1452 }, 1453 }; 1454 1455 static const struct pnp_device_id ite_ids[] = { 1456 {"ITE8704", 0}, /* Default model */ 1457 {"ITE8713", 1}, /* CIR found in EEEBox 1501U */ 1458 {"ITE8708", 2}, /* Bridged IT8512 */ 1459 {"ITE8709", 3}, /* SRAM-Bridged IT8512 */ 1460 {"", 0}, 1461 }; 1462 1463 /* allocate memory, probe hardware, and initialize everything */ 1464 static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id 1465 *dev_id) 1466 { 1467 const struct ite_dev_params *dev_desc = NULL; 1468 struct ite_dev *itdev = NULL; 1469 struct rc_dev *rdev = NULL; 1470 int ret = -ENOMEM; 1471 int model_no; 1472 1473 ite_dbg("%s called", __func__); 1474 1475 itdev = kzalloc(sizeof(struct ite_dev), GFP_KERNEL); 1476 if (!itdev) 1477 return ret; 1478 1479 /* input device for IR remote (and tx) */ 1480 rdev = rc_allocate_device(); 1481 if (!rdev) 1482 goto failure; 1483 1484 ret = -ENODEV; 1485 1486 /* get the model number */ 1487 model_no = (int)dev_id->driver_data; 1488 ite_pr(KERN_NOTICE, "Auto-detected model: %s\n", 1489 ite_dev_descs[model_no].model); 1490 1491 if (model_number >= 0 && model_number < ARRAY_SIZE(ite_dev_descs)) { 1492 model_no = model_number; 1493 ite_pr(KERN_NOTICE, "The model has been fixed by a module " 1494 "parameter."); 1495 } 1496 1497 ite_pr(KERN_NOTICE, "Using model: %s\n", ite_dev_descs[model_no].model); 1498 1499 /* get the description for the device */ 1500 dev_desc = &ite_dev_descs[model_no]; 1501 1502 /* validate pnp resources */ 1503 if (!pnp_port_valid(pdev, 0) || 1504 pnp_port_len(pdev, 0) != dev_desc->io_region_size) { 1505 dev_err(&pdev->dev, "IR PNP Port not valid!\n"); 1506 goto failure; 1507 } 1508 1509 if (!pnp_irq_valid(pdev, 0)) { 1510 dev_err(&pdev->dev, "PNP IRQ not valid!\n"); 1511 goto failure; 1512 } 1513 1514 /* store resource values */ 1515 itdev->cir_addr = pnp_port_start(pdev, 0); 1516 itdev->cir_irq = pnp_irq(pdev, 0); 1517 1518 /* initialize spinlocks */ 1519 spin_lock_init(&itdev->lock); 1520 1521 /* initialize raw event */ 1522 init_ir_raw_event(&itdev->rawir); 1523 1524 ret = -EBUSY; 1525 /* now claim resources */ 1526 if (!request_region(itdev->cir_addr, 1527 dev_desc->io_region_size, ITE_DRIVER_NAME)) 1528 goto failure; 1529 1530 if (request_irq(itdev->cir_irq, ite_cir_isr, IRQF_SHARED, 1531 ITE_DRIVER_NAME, (void *)itdev)) 1532 goto failure; 1533 1534 /* set driver data into the pnp device */ 1535 pnp_set_drvdata(pdev, itdev); 1536 itdev->pdev = pdev; 1537 1538 /* initialize waitqueues for transmission */ 1539 init_waitqueue_head(&itdev->tx_queue); 1540 init_waitqueue_head(&itdev->tx_ended); 1541 1542 /* copy model-specific parameters */ 1543 itdev->params = *dev_desc; 1544 1545 /* apply any overrides */ 1546 if (sample_period > 0) 1547 itdev->params.sample_period = sample_period; 1548 1549 if (tx_carrier_freq > 0) 1550 itdev->params.tx_carrier_freq = tx_carrier_freq; 1551 1552 if (tx_duty_cycle > 0 && tx_duty_cycle <= 100) 1553 itdev->params.tx_duty_cycle = tx_duty_cycle; 1554 1555 if (rx_low_carrier_freq > 0) 1556 itdev->params.rx_low_carrier_freq = rx_low_carrier_freq; 1557 1558 if (rx_high_carrier_freq > 0) 1559 itdev->params.rx_high_carrier_freq = rx_high_carrier_freq; 1560 1561 /* print out parameters */ 1562 ite_pr(KERN_NOTICE, "TX-capable: %d\n", (int) 1563 itdev->params.hw_tx_capable); 1564 ite_pr(KERN_NOTICE, "Sample period (ns): %ld\n", (long) 1565 itdev->params.sample_period); 1566 ite_pr(KERN_NOTICE, "TX carrier frequency (Hz): %d\n", (int) 1567 itdev->params.tx_carrier_freq); 1568 ite_pr(KERN_NOTICE, "TX duty cycle (%%): %d\n", (int) 1569 itdev->params.tx_duty_cycle); 1570 ite_pr(KERN_NOTICE, "RX low carrier frequency (Hz): %d\n", (int) 1571 itdev->params.rx_low_carrier_freq); 1572 ite_pr(KERN_NOTICE, "RX high carrier frequency (Hz): %d\n", (int) 1573 itdev->params.rx_high_carrier_freq); 1574 1575 /* set up hardware initial state */ 1576 itdev->params.init_hardware(itdev); 1577 1578 /* set up ir-core props */ 1579 rdev->priv = itdev; 1580 rdev->driver_type = RC_DRIVER_IR_RAW; 1581 rdev->allowed_protos = RC_TYPE_ALL; 1582 rdev->open = ite_open; 1583 rdev->close = ite_close; 1584 rdev->s_idle = ite_s_idle; 1585 rdev->s_rx_carrier_range = ite_set_rx_carrier_range; 1586 rdev->min_timeout = ITE_MIN_IDLE_TIMEOUT; 1587 rdev->max_timeout = ITE_MAX_IDLE_TIMEOUT; 1588 rdev->timeout = ITE_IDLE_TIMEOUT; 1589 rdev->rx_resolution = ITE_BAUDRATE_DIVISOR * 1590 itdev->params.sample_period; 1591 rdev->tx_resolution = ITE_BAUDRATE_DIVISOR * 1592 itdev->params.sample_period; 1593 1594 /* set up transmitter related values if needed */ 1595 if (itdev->params.hw_tx_capable) { 1596 rdev->tx_ir = ite_tx_ir; 1597 rdev->s_tx_carrier = ite_set_tx_carrier; 1598 rdev->s_tx_duty_cycle = ite_set_tx_duty_cycle; 1599 } 1600 1601 rdev->input_name = dev_desc->model; 1602 rdev->input_id.bustype = BUS_HOST; 1603 rdev->input_id.vendor = PCI_VENDOR_ID_ITE; 1604 rdev->input_id.product = 0; 1605 rdev->input_id.version = 0; 1606 rdev->driver_name = ITE_DRIVER_NAME; 1607 rdev->map_name = RC_MAP_RC6_MCE; 1608 1609 ret = rc_register_device(rdev); 1610 if (ret) 1611 goto failure; 1612 1613 itdev->rdev = rdev; 1614 ite_pr(KERN_NOTICE, "driver has been successfully loaded\n"); 1615 1616 return 0; 1617 1618 failure: 1619 if (itdev->cir_irq) 1620 free_irq(itdev->cir_irq, itdev); 1621 1622 if (itdev->cir_addr) 1623 release_region(itdev->cir_addr, itdev->params.io_region_size); 1624 1625 rc_free_device(rdev); 1626 kfree(itdev); 1627 1628 return ret; 1629 } 1630 1631 static void __devexit ite_remove(struct pnp_dev *pdev) 1632 { 1633 struct ite_dev *dev = pnp_get_drvdata(pdev); 1634 unsigned long flags; 1635 1636 ite_dbg("%s called", __func__); 1637 1638 spin_lock_irqsave(&dev->lock, flags); 1639 1640 /* disable hardware */ 1641 dev->params.disable(dev); 1642 1643 spin_unlock_irqrestore(&dev->lock, flags); 1644 1645 /* free resources */ 1646 free_irq(dev->cir_irq, dev); 1647 release_region(dev->cir_addr, dev->params.io_region_size); 1648 1649 rc_unregister_device(dev->rdev); 1650 1651 kfree(dev); 1652 } 1653 1654 static int ite_suspend(struct pnp_dev *pdev, pm_message_t state) 1655 { 1656 struct ite_dev *dev = pnp_get_drvdata(pdev); 1657 unsigned long flags; 1658 1659 ite_dbg("%s called", __func__); 1660 1661 spin_lock_irqsave(&dev->lock, flags); 1662 1663 /* disable all interrupts */ 1664 dev->params.disable(dev); 1665 1666 spin_unlock_irqrestore(&dev->lock, flags); 1667 1668 return 0; 1669 } 1670 1671 static int ite_resume(struct pnp_dev *pdev) 1672 { 1673 int ret = 0; 1674 struct ite_dev *dev = pnp_get_drvdata(pdev); 1675 unsigned long flags; 1676 1677 ite_dbg("%s called", __func__); 1678 1679 spin_lock_irqsave(&dev->lock, flags); 1680 1681 if (dev->transmitting) { 1682 /* wake up the transmitter */ 1683 wake_up_interruptible(&dev->tx_queue); 1684 } else { 1685 /* enable the receiver */ 1686 dev->params.enable_rx(dev); 1687 } 1688 1689 spin_unlock_irqrestore(&dev->lock, flags); 1690 1691 return ret; 1692 } 1693 1694 static void ite_shutdown(struct pnp_dev *pdev) 1695 { 1696 struct ite_dev *dev = pnp_get_drvdata(pdev); 1697 unsigned long flags; 1698 1699 ite_dbg("%s called", __func__); 1700 1701 spin_lock_irqsave(&dev->lock, flags); 1702 1703 /* disable all interrupts */ 1704 dev->params.disable(dev); 1705 1706 spin_unlock_irqrestore(&dev->lock, flags); 1707 } 1708 1709 static struct pnp_driver ite_driver = { 1710 .name = ITE_DRIVER_NAME, 1711 .id_table = ite_ids, 1712 .probe = ite_probe, 1713 .remove = __devexit_p(ite_remove), 1714 .suspend = ite_suspend, 1715 .resume = ite_resume, 1716 .shutdown = ite_shutdown, 1717 }; 1718 1719 int ite_init(void) 1720 { 1721 return pnp_register_driver(&ite_driver); 1722 } 1723 1724 void ite_exit(void) 1725 { 1726 pnp_unregister_driver(&ite_driver); 1727 } 1728 1729 MODULE_DEVICE_TABLE(pnp, ite_ids); 1730 MODULE_DESCRIPTION("ITE Tech Inc. IT8712F/ITE8512F CIR driver"); 1731 1732 MODULE_AUTHOR("Juan J. Garcia de Soria <skandalfo@gmail.com>"); 1733 MODULE_LICENSE("GPL"); 1734 1735 module_init(ite_init); 1736 module_exit(ite_exit); 1737