1/* 2 * winbond-cir.c - Driver for the Consumer IR functionality of Winbond 3 * SuperI/O chips. 4 * 5 * Currently supports the Winbond WPCD376i chip (PNP id WEC1022), but 6 * could probably support others (Winbond WEC102X, NatSemi, etc) 7 * with minor modifications. 8 * 9 * Original Author: David H�rdeman <david@hardeman.nu> 10 * Copyright (C) 2009 David H�rdeman <david@hardeman.nu> 11 * 12 * Dedicated to Matilda, my newborn daughter, without whose loving attention 13 * this driver would have been finished in half the time and with a fraction 14 * of the bugs. 15 * 16 * Written using: 17 * o Winbond WPCD376I datasheet helpfully provided by Jesse Barnes at Intel 18 * o NatSemi PC87338/PC97338 datasheet (for the serial port stuff) 19 * o DSDT dumps 20 * 21 * Supported features: 22 * o RC6 23 * o Wake-On-CIR functionality 24 * 25 * To do: 26 * o Test NEC and RC5 27 * 28 * Left as an exercise for the reader: 29 * o Learning (I have neither the hardware, nor the need) 30 * o IR Transmit (ibid) 31 * 32 * This program is free software; you can redistribute it and/or modify 33 * it under the terms of the GNU General Public License as published by 34 * the Free Software Foundation; either version 2 of the License, or 35 * (at your option) any later version. 36 * 37 * This program is distributed in the hope that it will be useful, 38 * but WITHOUT ANY WARRANTY; without even the implied warranty of 39 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 40 * GNU General Public License for more details. 41 * 42 * You should have received a copy of the GNU General Public License 43 * along with this program; if not, write to the Free Software 44 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 45 */ 46 47#include <linux/module.h> 48#include <linux/pnp.h> 49#include <linux/interrupt.h> 50#include <linux/timer.h> 51#include <linux/input.h> 52#include <linux/leds.h> 53#include <linux/list.h> 54#include <linux/spinlock.h> 55#include <linux/pci_ids.h> 56#include <linux/io.h> 57#include <linux/bitrev.h> 58#include <linux/bitops.h> 59#include <linux/slab.h> 60 61#define DRVNAME "winbond-cir" 62 63/* CEIR Wake-Up Registers, relative to data->wbase */ 64#define WBCIR_REG_WCEIR_CTL 0x03 /* CEIR Receiver Control */ 65#define WBCIR_REG_WCEIR_STS 0x04 /* CEIR Receiver Status */ 66#define WBCIR_REG_WCEIR_EV_EN 0x05 /* CEIR Receiver Event Enable */ 67#define WBCIR_REG_WCEIR_CNTL 0x06 /* CEIR Receiver Counter Low */ 68#define WBCIR_REG_WCEIR_CNTH 0x07 /* CEIR Receiver Counter High */ 69#define WBCIR_REG_WCEIR_INDEX 0x08 /* CEIR Receiver Index */ 70#define WBCIR_REG_WCEIR_DATA 0x09 /* CEIR Receiver Data */ 71#define WBCIR_REG_WCEIR_CSL 0x0A /* CEIR Re. Compare Strlen */ 72#define WBCIR_REG_WCEIR_CFG1 0x0B /* CEIR Re. Configuration 1 */ 73#define WBCIR_REG_WCEIR_CFG2 0x0C /* CEIR Re. Configuration 2 */ 74 75/* CEIR Enhanced Functionality Registers, relative to data->ebase */ 76#define WBCIR_REG_ECEIR_CTS 0x00 /* Enhanced IR Control Status */ 77#define WBCIR_REG_ECEIR_CCTL 0x01 /* Infrared Counter Control */ 78#define WBCIR_REG_ECEIR_CNT_LO 0x02 /* Infrared Counter LSB */ 79#define WBCIR_REG_ECEIR_CNT_HI 0x03 /* Infrared Counter MSB */ 80#define WBCIR_REG_ECEIR_IREM 0x04 /* Infrared Emitter Status */ 81 82/* SP3 Banked Registers, relative to data->sbase */ 83#define WBCIR_REG_SP3_BSR 0x03 /* Bank Select, all banks */ 84 /* Bank 0 */ 85#define WBCIR_REG_SP3_RXDATA 0x00 /* FIFO RX data (r) */ 86#define WBCIR_REG_SP3_TXDATA 0x00 /* FIFO TX data (w) */ 87#define WBCIR_REG_SP3_IER 0x01 /* Interrupt Enable */ 88#define WBCIR_REG_SP3_EIR 0x02 /* Event Identification (r) */ 89#define WBCIR_REG_SP3_FCR 0x02 /* FIFO Control (w) */ 90#define WBCIR_REG_SP3_MCR 0x04 /* Mode Control */ 91#define WBCIR_REG_SP3_LSR 0x05 /* Link Status */ 92#define WBCIR_REG_SP3_MSR 0x06 /* Modem Status */ 93#define WBCIR_REG_SP3_ASCR 0x07 /* Aux Status and Control */ 94 /* Bank 2 */ 95#define WBCIR_REG_SP3_BGDL 0x00 /* Baud Divisor LSB */ 96#define WBCIR_REG_SP3_BGDH 0x01 /* Baud Divisor MSB */ 97#define WBCIR_REG_SP3_EXCR1 0x02 /* Extended Control 1 */ 98#define WBCIR_REG_SP3_EXCR2 0x04 /* Extended Control 2 */ 99#define WBCIR_REG_SP3_TXFLV 0x06 /* TX FIFO Level */ 100#define WBCIR_REG_SP3_RXFLV 0x07 /* RX FIFO Level */ 101 /* Bank 3 */ 102#define WBCIR_REG_SP3_MRID 0x00 /* Module Identification */ 103#define WBCIR_REG_SP3_SH_LCR 0x01 /* LCR Shadow */ 104#define WBCIR_REG_SP3_SH_FCR 0x02 /* FCR Shadow */ 105 /* Bank 4 */ 106#define WBCIR_REG_SP3_IRCR1 0x02 /* Infrared Control 1 */ 107 /* Bank 5 */ 108#define WBCIR_REG_SP3_IRCR2 0x04 /* Infrared Control 2 */ 109 /* Bank 6 */ 110#define WBCIR_REG_SP3_IRCR3 0x00 /* Infrared Control 3 */ 111#define WBCIR_REG_SP3_SIR_PW 0x02 /* SIR Pulse Width */ 112 /* Bank 7 */ 113#define WBCIR_REG_SP3_IRRXDC 0x00 /* IR RX Demod Control */ 114#define WBCIR_REG_SP3_IRTXMC 0x01 /* IR TX Mod Control */ 115#define WBCIR_REG_SP3_RCCFG 0x02 /* CEIR Config */ 116#define WBCIR_REG_SP3_IRCFG1 0x04 /* Infrared Config 1 */ 117#define WBCIR_REG_SP3_IRCFG4 0x07 /* Infrared Config 4 */ 118 119/* 120 * Magic values follow 121 */ 122 123/* No interrupts for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ 124#define WBCIR_IRQ_NONE 0x00 125/* RX data bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ 126#define WBCIR_IRQ_RX 0x01 127/* Over/Under-flow bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */ 128#define WBCIR_IRQ_ERR 0x04 129/* Led enable/disable bit for WBCIR_REG_ECEIR_CTS */ 130#define WBCIR_LED_ENABLE 0x80 131/* RX data available bit for WBCIR_REG_SP3_LSR */ 132#define WBCIR_RX_AVAIL 0x01 133/* RX disable bit for WBCIR_REG_SP3_ASCR */ 134#define WBCIR_RX_DISABLE 0x20 135/* Extended mode enable bit for WBCIR_REG_SP3_EXCR1 */ 136#define WBCIR_EXT_ENABLE 0x01 137/* Select compare register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */ 138#define WBCIR_REGSEL_COMPARE 0x10 139/* Select mask register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */ 140#define WBCIR_REGSEL_MASK 0x20 141/* Starting address of selected register in WBCIR_REG_WCEIR_INDEX */ 142#define WBCIR_REG_ADDR0 0x00 143 144/* Valid banks for the SP3 UART */ 145enum wbcir_bank { 146 WBCIR_BANK_0 = 0x00, 147 WBCIR_BANK_1 = 0x80, 148 WBCIR_BANK_2 = 0xE0, 149 WBCIR_BANK_3 = 0xE4, 150 WBCIR_BANK_4 = 0xE8, 151 WBCIR_BANK_5 = 0xEC, 152 WBCIR_BANK_6 = 0xF0, 153 WBCIR_BANK_7 = 0xF4, 154}; 155 156/* Supported IR Protocols */ 157enum wbcir_protocol { 158 IR_PROTOCOL_RC5 = 0x0, 159 IR_PROTOCOL_NEC = 0x1, 160 IR_PROTOCOL_RC6 = 0x2, 161}; 162 163/* Misc */ 164#define WBCIR_NAME "Winbond CIR" 165#define WBCIR_ID_FAMILY 0xF1 /* Family ID for the WPCD376I */ 166#define WBCIR_ID_CHIP 0x04 /* Chip ID for the WPCD376I */ 167#define IR_KEYPRESS_TIMEOUT 250 168#define INVALID_SCANCODE 0x7FFFFFFF /* Invalid with all protos */ 169#define WAKEUP_IOMEM_LEN 0x10 /* Wake-Up I/O Reg Len */ 170#define EHFUNC_IOMEM_LEN 0x10 /* Enhanced Func I/O Reg Len */ 171#define SP_IOMEM_LEN 0x08 /* Serial Port 3 (IR) Reg Len */ 172#define WBCIR_MAX_IDLE_BYTES 10 173 174static DEFINE_SPINLOCK(wbcir_lock); 175static DEFINE_RWLOCK(keytable_lock); 176 177struct wbcir_key { 178 u32 scancode; 179 unsigned int keycode; 180}; 181 182struct wbcir_keyentry { 183 struct wbcir_key key; 184 struct list_head list; 185}; 186 187static struct wbcir_key rc6_def_keymap[] = { 188 { 0x800F0400, KEY_NUMERIC_0 }, 189 { 0x800F0401, KEY_NUMERIC_1 }, 190 { 0x800F0402, KEY_NUMERIC_2 }, 191 { 0x800F0403, KEY_NUMERIC_3 }, 192 { 0x800F0404, KEY_NUMERIC_4 }, 193 { 0x800F0405, KEY_NUMERIC_5 }, 194 { 0x800F0406, KEY_NUMERIC_6 }, 195 { 0x800F0407, KEY_NUMERIC_7 }, 196 { 0x800F0408, KEY_NUMERIC_8 }, 197 { 0x800F0409, KEY_NUMERIC_9 }, 198 { 0x800F041D, KEY_NUMERIC_STAR }, 199 { 0x800F041C, KEY_NUMERIC_POUND }, 200 { 0x800F0410, KEY_VOLUMEUP }, 201 { 0x800F0411, KEY_VOLUMEDOWN }, 202 { 0x800F0412, KEY_CHANNELUP }, 203 { 0x800F0413, KEY_CHANNELDOWN }, 204 { 0x800F040E, KEY_MUTE }, 205 { 0x800F040D, KEY_VENDOR }, /* Vista Logo Key */ 206 { 0x800F041E, KEY_UP }, 207 { 0x800F041F, KEY_DOWN }, 208 { 0x800F0420, KEY_LEFT }, 209 { 0x800F0421, KEY_RIGHT }, 210 { 0x800F0422, KEY_OK }, 211 { 0x800F0423, KEY_ESC }, 212 { 0x800F040F, KEY_INFO }, 213 { 0x800F040A, KEY_CLEAR }, 214 { 0x800F040B, KEY_ENTER }, 215 { 0x800F045B, KEY_RED }, 216 { 0x800F045C, KEY_GREEN }, 217 { 0x800F045D, KEY_YELLOW }, 218 { 0x800F045E, KEY_BLUE }, 219 { 0x800F045A, KEY_TEXT }, 220 { 0x800F0427, KEY_SWITCHVIDEOMODE }, 221 { 0x800F040C, KEY_POWER }, 222 { 0x800F0450, KEY_RADIO }, 223 { 0x800F0448, KEY_PVR }, 224 { 0x800F0447, KEY_AUDIO }, 225 { 0x800F0426, KEY_EPG }, 226 { 0x800F0449, KEY_CAMERA }, 227 { 0x800F0425, KEY_TV }, 228 { 0x800F044A, KEY_VIDEO }, 229 { 0x800F0424, KEY_DVD }, 230 { 0x800F0416, KEY_PLAY }, 231 { 0x800F0418, KEY_PAUSE }, 232 { 0x800F0419, KEY_STOP }, 233 { 0x800F0414, KEY_FASTFORWARD }, 234 { 0x800F041A, KEY_NEXT }, 235 { 0x800F041B, KEY_PREVIOUS }, 236 { 0x800F0415, KEY_REWIND }, 237 { 0x800F0417, KEY_RECORD }, 238}; 239 240/* Registers and other state is protected by wbcir_lock */ 241struct wbcir_data { 242 unsigned long wbase; /* Wake-Up Baseaddr */ 243 unsigned long ebase; /* Enhanced Func. Baseaddr */ 244 unsigned long sbase; /* Serial Port Baseaddr */ 245 unsigned int irq; /* Serial Port IRQ */ 246 247 struct input_dev *input_dev; 248 struct timer_list timer_keyup; 249 struct led_trigger *rxtrigger; 250 struct led_trigger *txtrigger; 251 struct led_classdev led; 252 253 u32 last_scancode; 254 unsigned int last_keycode; 255 u8 last_toggle; 256 u8 keypressed; 257 unsigned long keyup_jiffies; 258 unsigned int idle_count; 259 260 /* RX irdata and parsing state */ 261 unsigned long irdata[30]; 262 unsigned int irdata_count; 263 unsigned int irdata_idle; 264 unsigned int irdata_off; 265 unsigned int irdata_error; 266 267 /* Protected by keytable_lock */ 268 struct list_head keytable; 269}; 270 271static enum wbcir_protocol protocol = IR_PROTOCOL_RC6; 272module_param(protocol, uint, 0444); 273MODULE_PARM_DESC(protocol, "IR protocol to use " 274 "(0 = RC5, 1 = NEC, 2 = RC6A, default)"); 275 276static int invert; /* default = 0 */ 277module_param(invert, bool, 0444); 278MODULE_PARM_DESC(invert, "Invert the signal from the IR receiver"); 279 280static unsigned int wake_sc = 0x800F040C; 281module_param(wake_sc, uint, 0644); 282MODULE_PARM_DESC(wake_sc, "Scancode of the power-on IR command"); 283 284static unsigned int wake_rc6mode = 6; 285module_param(wake_rc6mode, uint, 0644); 286MODULE_PARM_DESC(wake_rc6mode, "RC6 mode for the power-on command " 287 "(0 = 0, 6 = 6A, default)"); 288 289 290 291/***************************************************************************** 292 * 293 * UTILITY FUNCTIONS 294 * 295 *****************************************************************************/ 296 297/* Caller needs to hold wbcir_lock */ 298static void 299wbcir_set_bits(unsigned long addr, u8 bits, u8 mask) 300{ 301 u8 val; 302 303 val = inb(addr); 304 val = ((val & ~mask) | (bits & mask)); 305 outb(val, addr); 306} 307 308/* Selects the register bank for the serial port */ 309static inline void 310wbcir_select_bank(struct wbcir_data *data, enum wbcir_bank bank) 311{ 312 outb(bank, data->sbase + WBCIR_REG_SP3_BSR); 313} 314 315static enum led_brightness 316wbcir_led_brightness_get(struct led_classdev *led_cdev) 317{ 318 struct wbcir_data *data = container_of(led_cdev, 319 struct wbcir_data, 320 led); 321 322 if (inb(data->ebase + WBCIR_REG_ECEIR_CTS) & WBCIR_LED_ENABLE) 323 return LED_FULL; 324 else 325 return LED_OFF; 326} 327 328static void 329wbcir_led_brightness_set(struct led_classdev *led_cdev, 330 enum led_brightness brightness) 331{ 332 struct wbcir_data *data = container_of(led_cdev, 333 struct wbcir_data, 334 led); 335 336 wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CTS, 337 brightness == LED_OFF ? 0x00 : WBCIR_LED_ENABLE, 338 WBCIR_LED_ENABLE); 339} 340 341/* Manchester encodes bits to RC6 message cells (see wbcir_parse_rc6) */ 342static u8 343wbcir_to_rc6cells(u8 val) 344{ 345 u8 coded = 0x00; 346 int i; 347 348 val &= 0x0F; 349 for (i = 0; i < 4; i++) { 350 if (val & 0x01) 351 coded |= 0x02 << (i * 2); 352 else 353 coded |= 0x01 << (i * 2); 354 val >>= 1; 355 } 356 357 return coded; 358} 359 360 361 362/***************************************************************************** 363 * 364 * INPUT FUNCTIONS 365 * 366 *****************************************************************************/ 367 368static unsigned int 369wbcir_do_getkeycode(struct wbcir_data *data, u32 scancode) 370{ 371 struct wbcir_keyentry *keyentry; 372 unsigned int keycode = KEY_RESERVED; 373 unsigned long flags; 374 375 read_lock_irqsave(&keytable_lock, flags); 376 377 list_for_each_entry(keyentry, &data->keytable, list) { 378 if (keyentry->key.scancode == scancode) { 379 keycode = keyentry->key.keycode; 380 break; 381 } 382 } 383 384 read_unlock_irqrestore(&keytable_lock, flags); 385 return keycode; 386} 387 388static int 389wbcir_getkeycode(struct input_dev *dev, 390 unsigned int scancode, unsigned int *keycode) 391{ 392 struct wbcir_data *data = input_get_drvdata(dev); 393 394 *keycode = wbcir_do_getkeycode(data, scancode); 395 return 0; 396} 397 398static int 399wbcir_setkeycode(struct input_dev *dev, 400 unsigned int scancode, unsigned int keycode) 401{ 402 struct wbcir_data *data = input_get_drvdata(dev); 403 struct wbcir_keyentry *keyentry; 404 struct wbcir_keyentry *new_keyentry; 405 unsigned long flags; 406 unsigned int old_keycode = KEY_RESERVED; 407 408 new_keyentry = kmalloc(sizeof(*new_keyentry), GFP_KERNEL); 409 if (!new_keyentry) 410 return -ENOMEM; 411 412 write_lock_irqsave(&keytable_lock, flags); 413 414 list_for_each_entry(keyentry, &data->keytable, list) { 415 if (keyentry->key.scancode != scancode) 416 continue; 417 418 old_keycode = keyentry->key.keycode; 419 keyentry->key.keycode = keycode; 420 421 if (keyentry->key.keycode == KEY_RESERVED) { 422 list_del(&keyentry->list); 423 kfree(keyentry); 424 } 425 426 break; 427 } 428 429 set_bit(keycode, dev->keybit); 430 431 if (old_keycode == KEY_RESERVED) { 432 new_keyentry->key.scancode = scancode; 433 new_keyentry->key.keycode = keycode; 434 list_add(&new_keyentry->list, &data->keytable); 435 } else { 436 kfree(new_keyentry); 437 clear_bit(old_keycode, dev->keybit); 438 list_for_each_entry(keyentry, &data->keytable, list) { 439 if (keyentry->key.keycode == old_keycode) { 440 set_bit(old_keycode, dev->keybit); 441 break; 442 } 443 } 444 } 445 446 write_unlock_irqrestore(&keytable_lock, flags); 447 return 0; 448} 449 450/* 451 * Timer function to report keyup event some time after keydown is 452 * reported by the ISR. 453 */ 454static void 455wbcir_keyup(unsigned long cookie) 456{ 457 struct wbcir_data *data = (struct wbcir_data *)cookie; 458 unsigned long flags; 459 460 /* 461 * data->keyup_jiffies is used to prevent a race condition if a 462 * hardware interrupt occurs at this point and the keyup timer 463 * event is moved further into the future as a result. 464 * 465 * The timer will then be reactivated and this function called 466 * again in the future. We need to exit gracefully in that case 467 * to allow the input subsystem to do its auto-repeat magic or 468 * a keyup event might follow immediately after the keydown. 469 */ 470 471 spin_lock_irqsave(&wbcir_lock, flags); 472 473 if (time_is_after_eq_jiffies(data->keyup_jiffies) && data->keypressed) { 474 data->keypressed = 0; 475 led_trigger_event(data->rxtrigger, LED_OFF); 476 input_report_key(data->input_dev, data->last_keycode, 0); 477 input_sync(data->input_dev); 478 } 479 480 spin_unlock_irqrestore(&wbcir_lock, flags); 481} 482 483static void 484wbcir_keydown(struct wbcir_data *data, u32 scancode, u8 toggle) 485{ 486 unsigned int keycode; 487 488 /* Repeat? */ 489 if (data->last_scancode == scancode && 490 data->last_toggle == toggle && 491 data->keypressed) 492 goto set_timer; 493 data->last_scancode = scancode; 494 495 /* Do we need to release an old keypress? */ 496 if (data->keypressed) { 497 input_report_key(data->input_dev, data->last_keycode, 0); 498 input_sync(data->input_dev); 499 data->keypressed = 0; 500 } 501 502 /* Report scancode */ 503 input_event(data->input_dev, EV_MSC, MSC_SCAN, (int)scancode); 504 505 /* Do we know this scancode? */ 506 keycode = wbcir_do_getkeycode(data, scancode); 507 if (keycode == KEY_RESERVED) 508 goto set_timer; 509 510 /* Register a keypress */ 511 input_report_key(data->input_dev, keycode, 1); 512 data->keypressed = 1; 513 data->last_keycode = keycode; 514 data->last_toggle = toggle; 515 516set_timer: 517 input_sync(data->input_dev); 518 led_trigger_event(data->rxtrigger, 519 data->keypressed ? LED_FULL : LED_OFF); 520 data->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT); 521 mod_timer(&data->timer_keyup, data->keyup_jiffies); 522} 523 524 525 526/***************************************************************************** 527 * 528 * IR PARSING FUNCTIONS 529 * 530 *****************************************************************************/ 531 532/* Resets all irdata */ 533static void 534wbcir_reset_irdata(struct wbcir_data *data) 535{ 536 memset(data->irdata, 0, sizeof(data->irdata)); 537 data->irdata_count = 0; 538 data->irdata_off = 0; 539 data->irdata_error = 0; 540 data->idle_count = 0; 541} 542 543/* Adds one bit of irdata */ 544static void 545add_irdata_bit(struct wbcir_data *data, int set) 546{ 547 if (data->irdata_count >= sizeof(data->irdata) * 8) { 548 data->irdata_error = 1; 549 return; 550 } 551 552 if (set) 553 __set_bit(data->irdata_count, data->irdata); 554 data->irdata_count++; 555} 556 557/* Gets count bits of irdata */ 558static u16 559get_bits(struct wbcir_data *data, int count) 560{ 561 u16 val = 0x0; 562 563 if (data->irdata_count - data->irdata_off < count) { 564 data->irdata_error = 1; 565 return 0x0; 566 } 567 568 while (count > 0) { 569 val <<= 1; 570 if (test_bit(data->irdata_off, data->irdata)) 571 val |= 0x1; 572 count--; 573 data->irdata_off++; 574 } 575 576 return val; 577} 578 579/* Reads 16 cells and converts them to a byte */ 580static u8 581wbcir_rc6cells_to_byte(struct wbcir_data *data) 582{ 583 u16 raw = get_bits(data, 16); 584 u8 val = 0x00; 585 int bit; 586 587 for (bit = 0; bit < 8; bit++) { 588 switch (raw & 0x03) { 589 case 0x01: 590 break; 591 case 0x02: 592 val |= (0x01 << bit); 593 break; 594 default: 595 data->irdata_error = 1; 596 break; 597 } 598 raw >>= 2; 599 } 600 601 return val; 602} 603 604/* Decodes a number of bits from raw RC5 data */ 605static u8 606wbcir_get_rc5bits(struct wbcir_data *data, unsigned int count) 607{ 608 u16 raw = get_bits(data, count * 2); 609 u8 val = 0x00; 610 int bit; 611 612 for (bit = 0; bit < count; bit++) { 613 switch (raw & 0x03) { 614 case 0x01: 615 val |= (0x01 << bit); 616 break; 617 case 0x02: 618 break; 619 default: 620 data->irdata_error = 1; 621 break; 622 } 623 raw >>= 2; 624 } 625 626 return val; 627} 628 629static void 630wbcir_parse_rc6(struct device *dev, struct wbcir_data *data) 631{ 632 /* 633 * Normal bits are manchester coded as follows: 634 * cell0 + cell1 = logic "0" 635 * cell1 + cell0 = logic "1" 636 * 637 * The IR pulse has the following components: 638 * 639 * Leader - 6 * cell1 - discarded 640 * Gap - 2 * cell0 - discarded 641 * Start bit - Normal Coding - always "1" 642 * Mode Bit 2 - 0 - Normal Coding 643 * Toggle bit - Normal Coding with double bit time, 644 * e.g. cell0 + cell0 + cell1 + cell1 645 * means logic "0". 646 * 647 * The rest depends on the mode, the following modes are known: 648 * 649 * MODE 0: 650 * Address Bit 7 - 0 - Normal Coding 651 * Command Bit 7 - 0 - Normal Coding 652 * 653 * MODE 6: 654 * The above Toggle Bit is used as a submode bit, 0 = A, 1 = B. 655 * Submode B is for pointing devices, only remotes using submode A 656 * are supported. 657 * 658 * Customer range bit - 0 => Customer = 7 bits, 0...127 659 * 1 => Customer = 15 bits, 32768...65535 660 * Customer Bits - Normal Coding 661 * 662 * Customer codes are allocated by Philips. The rest of the bits 663 * are customer dependent. The following is commonly used (and the 664 * only supported config): 665 * 666 * Toggle Bit - Normal Coding 667 * Address Bit 6 - 0 - Normal Coding 668 * Command Bit 7 - 0 - Normal Coding 669 * 670 * All modes are followed by at least 6 * cell0. 671 * 672 * MODE 0 msglen: 673 * 1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (toggle) + 674 * 8 * 2 (address) + 8 * 2 (command) = 675 * 44 cells 676 * 677 * MODE 6A msglen: 678 * 1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (submode) + 679 * 1 * 2 (customer range bit) + 7/15 * 2 (customer bits) + 680 * 1 * 2 (toggle bit) + 7 * 2 (address) + 8 * 2 (command) = 681 * 60 - 76 cells 682 */ 683 u8 mode; 684 u8 toggle; 685 u16 customer = 0x0; 686 u8 address; 687 u8 command; 688 u32 scancode; 689 690 /* Leader mark */ 691 while (get_bits(data, 1) && !data->irdata_error) 692 /* Do nothing */; 693 694 /* Leader space */ 695 if (get_bits(data, 1)) { 696 dev_dbg(dev, "RC6 - Invalid leader space\n"); 697 return; 698 } 699 700 /* Start bit */ 701 if (get_bits(data, 2) != 0x02) { 702 dev_dbg(dev, "RC6 - Invalid start bit\n"); 703 return; 704 } 705 706 /* Mode */ 707 mode = get_bits(data, 6); 708 switch (mode) { 709 case 0x15: /* 010101 = b000 */ 710 mode = 0; 711 break; 712 case 0x29: /* 101001 = b110 */ 713 mode = 6; 714 break; 715 default: 716 dev_dbg(dev, "RC6 - Invalid mode\n"); 717 return; 718 } 719 720 /* Toggle bit / Submode bit */ 721 toggle = get_bits(data, 4); 722 switch (toggle) { 723 case 0x03: 724 toggle = 0; 725 break; 726 case 0x0C: 727 toggle = 1; 728 break; 729 default: 730 dev_dbg(dev, "RC6 - Toggle bit error\n"); 731 break; 732 } 733 734 /* Customer */ 735 if (mode == 6) { 736 if (toggle != 0) { 737 dev_dbg(dev, "RC6B - Not Supported\n"); 738 return; 739 } 740 741 customer = wbcir_rc6cells_to_byte(data); 742 743 if (customer & 0x80) { 744 /* 15 bit customer value */ 745 customer <<= 8; 746 customer |= wbcir_rc6cells_to_byte(data); 747 } 748 } 749 750 /* Address */ 751 address = wbcir_rc6cells_to_byte(data); 752 if (mode == 6) { 753 toggle = address >> 7; 754 address &= 0x7F; 755 } 756 757 /* Command */ 758 command = wbcir_rc6cells_to_byte(data); 759 760 /* Create scancode */ 761 scancode = command; 762 scancode |= address << 8; 763 scancode |= customer << 16; 764 765 /* Last sanity check */ 766 if (data->irdata_error) { 767 dev_dbg(dev, "RC6 - Cell error(s)\n"); 768 return; 769 } 770 771 dev_dbg(dev, "IR-RC6 ad 0x%02X cm 0x%02X cu 0x%04X " 772 "toggle %u mode %u scan 0x%08X\n", 773 address, 774 command, 775 customer, 776 (unsigned int)toggle, 777 (unsigned int)mode, 778 scancode); 779 780 wbcir_keydown(data, scancode, toggle); 781} 782 783static void 784wbcir_parse_rc5(struct device *dev, struct wbcir_data *data) 785{ 786 /* 787 * Bits are manchester coded as follows: 788 * cell1 + cell0 = logic "0" 789 * cell0 + cell1 = logic "1" 790 * (i.e. the reverse of RC6) 791 * 792 * Start bit 1 - "1" - discarded 793 * Start bit 2 - Must be inverted to get command bit 6 794 * Toggle bit 795 * Address Bit 4 - 0 796 * Command Bit 5 - 0 797 */ 798 u8 toggle; 799 u8 address; 800 u8 command; 801 u32 scancode; 802 803 /* Start bit 1 */ 804 if (!get_bits(data, 1)) { 805 dev_dbg(dev, "RC5 - Invalid start bit\n"); 806 return; 807 } 808 809 /* Start bit 2 */ 810 if (!wbcir_get_rc5bits(data, 1)) 811 command = 0x40; 812 else 813 command = 0x00; 814 815 toggle = wbcir_get_rc5bits(data, 1); 816 address = wbcir_get_rc5bits(data, 5); 817 command |= wbcir_get_rc5bits(data, 6); 818 scancode = address << 7 | command; 819 820 /* Last sanity check */ 821 if (data->irdata_error) { 822 dev_dbg(dev, "RC5 - Invalid message\n"); 823 return; 824 } 825 826 dev_dbg(dev, "IR-RC5 ad %u cm %u t %u s %u\n", 827 (unsigned int)address, 828 (unsigned int)command, 829 (unsigned int)toggle, 830 (unsigned int)scancode); 831 832 wbcir_keydown(data, scancode, toggle); 833} 834 835static void 836wbcir_parse_nec(struct device *dev, struct wbcir_data *data) 837{ 838 /* 839 * Each bit represents 560 us. 840 * 841 * Leader - 9 ms burst 842 * Gap - 4.5 ms silence 843 * Address1 bit 0 - 7 - Address 1 844 * Address2 bit 0 - 7 - Address 2 845 * Command1 bit 0 - 7 - Command 1 846 * Command2 bit 0 - 7 - Command 2 847 * 848 * Note the bit order! 849 * 850 * With the old NEC protocol, Address2 was the inverse of Address1 851 * and Command2 was the inverse of Command1 and were used as 852 * an error check. 853 * 854 * With NEC extended, Address1 is the LSB of the Address and 855 * Address2 is the MSB, Command parsing remains unchanged. 856 * 857 * A repeat message is coded as: 858 * Leader - 9 ms burst 859 * Gap - 2.25 ms silence 860 * Repeat - 560 us active 861 */ 862 u8 address1; 863 u8 address2; 864 u8 command1; 865 u8 command2; 866 u16 address; 867 u32 scancode; 868 869 /* Leader mark */ 870 while (get_bits(data, 1) && !data->irdata_error) 871 /* Do nothing */; 872 873 /* Leader space */ 874 if (get_bits(data, 4)) { 875 dev_dbg(dev, "NEC - Invalid leader space\n"); 876 return; 877 } 878 879 /* Repeat? */ 880 if (get_bits(data, 1)) { 881 if (!data->keypressed) { 882 dev_dbg(dev, "NEC - Stray repeat message\n"); 883 return; 884 } 885 886 dev_dbg(dev, "IR-NEC repeat s %u\n", 887 (unsigned int)data->last_scancode); 888 889 wbcir_keydown(data, data->last_scancode, data->last_toggle); 890 return; 891 } 892 893 /* Remaining leader space */ 894 if (get_bits(data, 3)) { 895 dev_dbg(dev, "NEC - Invalid leader space\n"); 896 return; 897 } 898 899 address1 = bitrev8(get_bits(data, 8)); 900 address2 = bitrev8(get_bits(data, 8)); 901 command1 = bitrev8(get_bits(data, 8)); 902 command2 = bitrev8(get_bits(data, 8)); 903 904 /* Sanity check */ 905 if (data->irdata_error) { 906 dev_dbg(dev, "NEC - Invalid message\n"); 907 return; 908 } 909 910 /* Check command validity */ 911 if (command1 != ~command2) { 912 dev_dbg(dev, "NEC - Command bytes mismatch\n"); 913 return; 914 } 915 916 /* Check for extended NEC protocol */ 917 address = address1; 918 if (address1 != ~address2) 919 address |= address2 << 8; 920 921 scancode = address << 8 | command1; 922 923 dev_dbg(dev, "IR-NEC ad %u cm %u s %u\n", 924 (unsigned int)address, 925 (unsigned int)command1, 926 (unsigned int)scancode); 927 928 wbcir_keydown(data, scancode, !data->last_toggle); 929} 930 931 932 933/***************************************************************************** 934 * 935 * INTERRUPT FUNCTIONS 936 * 937 *****************************************************************************/ 938 939static irqreturn_t 940wbcir_irq_handler(int irqno, void *cookie) 941{ 942 struct pnp_dev *device = cookie; 943 struct wbcir_data *data = pnp_get_drvdata(device); 944 struct device *dev = &device->dev; 945 u8 status; 946 unsigned long flags; 947 u8 irdata[8]; 948 int i; 949 unsigned int hw; 950 951 spin_lock_irqsave(&wbcir_lock, flags); 952 953 wbcir_select_bank(data, WBCIR_BANK_0); 954 955 status = inb(data->sbase + WBCIR_REG_SP3_EIR); 956 957 if (!(status & (WBCIR_IRQ_RX | WBCIR_IRQ_ERR))) { 958 spin_unlock_irqrestore(&wbcir_lock, flags); 959 return IRQ_NONE; 960 } 961 962 if (status & WBCIR_IRQ_ERR) 963 data->irdata_error = 1; 964 965 if (!(status & WBCIR_IRQ_RX)) 966 goto out; 967 968 /* Since RXHDLEV is set, at least 8 bytes are in the FIFO */ 969 insb(data->sbase + WBCIR_REG_SP3_RXDATA, &irdata[0], 8); 970 971 for (i = 0; i < sizeof(irdata); i++) { 972 hw = hweight8(irdata[i]); 973 if (hw > 4) 974 add_irdata_bit(data, 0); 975 else 976 add_irdata_bit(data, 1); 977 978 if (hw == 8) 979 data->idle_count++; 980 else 981 data->idle_count = 0; 982 } 983 984 if (data->idle_count > WBCIR_MAX_IDLE_BYTES) { 985 /* Set RXINACTIVE... */ 986 outb(WBCIR_RX_DISABLE, data->sbase + WBCIR_REG_SP3_ASCR); 987 988 /* ...and drain the FIFO */ 989 while (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_AVAIL) 990 inb(data->sbase + WBCIR_REG_SP3_RXDATA); 991 992 dev_dbg(dev, "IRDATA:\n"); 993 for (i = 0; i < data->irdata_count; i += BITS_PER_LONG) 994 dev_dbg(dev, "0x%08lX\n", data->irdata[i/BITS_PER_LONG]); 995 996 switch (protocol) { 997 case IR_PROTOCOL_RC5: 998 wbcir_parse_rc5(dev, data); 999 break; 1000 case IR_PROTOCOL_RC6: 1001 wbcir_parse_rc6(dev, data); 1002 break; 1003 case IR_PROTOCOL_NEC: 1004 wbcir_parse_nec(dev, data); 1005 break; 1006 } 1007 1008 wbcir_reset_irdata(data); 1009 } 1010 1011out: 1012 spin_unlock_irqrestore(&wbcir_lock, flags); 1013 return IRQ_HANDLED; 1014} 1015 1016 1017 1018/***************************************************************************** 1019 * 1020 * SETUP/INIT/SUSPEND/RESUME FUNCTIONS 1021 * 1022 *****************************************************************************/ 1023 1024static void 1025wbcir_shutdown(struct pnp_dev *device) 1026{ 1027 struct device *dev = &device->dev; 1028 struct wbcir_data *data = pnp_get_drvdata(device); 1029 int do_wake = 1; 1030 u8 match[11]; 1031 u8 mask[11]; 1032 u8 rc6_csl = 0; 1033 int i; 1034 1035 memset(match, 0, sizeof(match)); 1036 memset(mask, 0, sizeof(mask)); 1037 1038 if (wake_sc == INVALID_SCANCODE || !device_may_wakeup(dev)) { 1039 do_wake = 0; 1040 goto finish; 1041 } 1042 1043 switch (protocol) { 1044 case IR_PROTOCOL_RC5: 1045 if (wake_sc > 0xFFF) { 1046 do_wake = 0; 1047 dev_err(dev, "RC5 - Invalid wake scancode\n"); 1048 break; 1049 } 1050 1051 /* Mask = 13 bits, ex toggle */ 1052 mask[0] = 0xFF; 1053 mask[1] = 0x17; 1054 1055 match[0] = (wake_sc & 0x003F); /* 6 command bits */ 1056 match[0] |= (wake_sc & 0x0180) >> 1; /* 2 address bits */ 1057 match[1] = (wake_sc & 0x0E00) >> 9; /* 3 address bits */ 1058 if (!(wake_sc & 0x0040)) /* 2nd start bit */ 1059 match[1] |= 0x10; 1060 1061 break; 1062 1063 case IR_PROTOCOL_NEC: 1064 if (wake_sc > 0xFFFFFF) { 1065 do_wake = 0; 1066 dev_err(dev, "NEC - Invalid wake scancode\n"); 1067 break; 1068 } 1069 1070 mask[0] = mask[1] = mask[2] = mask[3] = 0xFF; 1071 1072 match[1] = bitrev8((wake_sc & 0xFF)); 1073 match[0] = ~match[1]; 1074 1075 match[3] = bitrev8((wake_sc & 0xFF00) >> 8); 1076 if (wake_sc > 0xFFFF) 1077 match[2] = bitrev8((wake_sc & 0xFF0000) >> 16); 1078 else 1079 match[2] = ~match[3]; 1080 1081 break; 1082 1083 case IR_PROTOCOL_RC6: 1084 1085 if (wake_rc6mode == 0) { 1086 if (wake_sc > 0xFFFF) { 1087 do_wake = 0; 1088 dev_err(dev, "RC6 - Invalid wake scancode\n"); 1089 break; 1090 } 1091 1092 /* Command */ 1093 match[0] = wbcir_to_rc6cells(wake_sc >> 0); 1094 mask[0] = 0xFF; 1095 match[1] = wbcir_to_rc6cells(wake_sc >> 4); 1096 mask[1] = 0xFF; 1097 1098 /* Address */ 1099 match[2] = wbcir_to_rc6cells(wake_sc >> 8); 1100 mask[2] = 0xFF; 1101 match[3] = wbcir_to_rc6cells(wake_sc >> 12); 1102 mask[3] = 0xFF; 1103 1104 /* Header */ 1105 match[4] = 0x50; /* mode1 = mode0 = 0, ignore toggle */ 1106 mask[4] = 0xF0; 1107 match[5] = 0x09; /* start bit = 1, mode2 = 0 */ 1108 mask[5] = 0x0F; 1109 1110 rc6_csl = 44; 1111 1112 } else if (wake_rc6mode == 6) { 1113 i = 0; 1114 1115 /* Command */ 1116 match[i] = wbcir_to_rc6cells(wake_sc >> 0); 1117 mask[i++] = 0xFF; 1118 match[i] = wbcir_to_rc6cells(wake_sc >> 4); 1119 mask[i++] = 0xFF; 1120 1121 /* Address + Toggle */ 1122 match[i] = wbcir_to_rc6cells(wake_sc >> 8); 1123 mask[i++] = 0xFF; 1124 match[i] = wbcir_to_rc6cells(wake_sc >> 12); 1125 mask[i++] = 0x3F; 1126 1127 /* Customer bits 7 - 0 */ 1128 match[i] = wbcir_to_rc6cells(wake_sc >> 16); 1129 mask[i++] = 0xFF; 1130 match[i] = wbcir_to_rc6cells(wake_sc >> 20); 1131 mask[i++] = 0xFF; 1132 1133 if (wake_sc & 0x80000000) { 1134 /* Customer range bit and bits 15 - 8 */ 1135 match[i] = wbcir_to_rc6cells(wake_sc >> 24); 1136 mask[i++] = 0xFF; 1137 match[i] = wbcir_to_rc6cells(wake_sc >> 28); 1138 mask[i++] = 0xFF; 1139 rc6_csl = 76; 1140 } else if (wake_sc <= 0x007FFFFF) { 1141 rc6_csl = 60; 1142 } else { 1143 do_wake = 0; 1144 dev_err(dev, "RC6 - Invalid wake scancode\n"); 1145 break; 1146 } 1147 1148 /* Header */ 1149 match[i] = 0x93; /* mode1 = mode0 = 1, submode = 0 */ 1150 mask[i++] = 0xFF; 1151 match[i] = 0x0A; /* start bit = 1, mode2 = 1 */ 1152 mask[i++] = 0x0F; 1153 1154 } else { 1155 do_wake = 0; 1156 dev_err(dev, "RC6 - Invalid wake mode\n"); 1157 } 1158 1159 break; 1160 1161 default: 1162 do_wake = 0; 1163 break; 1164 } 1165 1166finish: 1167 if (do_wake) { 1168 /* Set compare and compare mask */ 1169 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX, 1170 WBCIR_REGSEL_COMPARE | WBCIR_REG_ADDR0, 1171 0x3F); 1172 outsb(data->wbase + WBCIR_REG_WCEIR_DATA, match, 11); 1173 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX, 1174 WBCIR_REGSEL_MASK | WBCIR_REG_ADDR0, 1175 0x3F); 1176 outsb(data->wbase + WBCIR_REG_WCEIR_DATA, mask, 11); 1177 1178 /* RC6 Compare String Len */ 1179 outb(rc6_csl, data->wbase + WBCIR_REG_WCEIR_CSL); 1180 1181 /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ 1182 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); 1183 1184 /* Clear BUFF_EN, Clear END_EN, Set MATCH_EN */ 1185 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x01, 0x07); 1186 1187 /* Set CEIR_EN */ 1188 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x01, 0x01); 1189 1190 } else { 1191 /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */ 1192 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); 1193 1194 /* Clear CEIR_EN */ 1195 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01); 1196 } 1197 1198 /* Disable interrupts */ 1199 wbcir_select_bank(data, WBCIR_BANK_0); 1200 outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); 1201 1202 /* 1203 * ACPI will set the HW disable bit for SP3 which means that the 1204 * output signals are left in an undefined state which may cause 1205 * spurious interrupts which we need to ignore until the hardware 1206 * is reinitialized. 1207 */ 1208 disable_irq(data->irq); 1209} 1210 1211static int 1212wbcir_suspend(struct pnp_dev *device, pm_message_t state) 1213{ 1214 wbcir_shutdown(device); 1215 return 0; 1216} 1217 1218static void 1219wbcir_init_hw(struct wbcir_data *data) 1220{ 1221 u8 tmp; 1222 1223 /* Disable interrupts */ 1224 wbcir_select_bank(data, WBCIR_BANK_0); 1225 outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); 1226 1227 /* Set PROT_SEL, RX_INV, Clear CEIR_EN (needed for the led) */ 1228 tmp = protocol << 4; 1229 if (invert) 1230 tmp |= 0x08; 1231 outb(tmp, data->wbase + WBCIR_REG_WCEIR_CTL); 1232 1233 /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ 1234 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); 1235 1236 /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */ 1237 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); 1238 1239 /* Set RC5 cell time to correspond to 36 kHz */ 1240 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CFG1, 0x4A, 0x7F); 1241 1242 /* Set IRTX_INV */ 1243 if (invert) 1244 outb(0x04, data->ebase + WBCIR_REG_ECEIR_CCTL); 1245 else 1246 outb(0x00, data->ebase + WBCIR_REG_ECEIR_CCTL); 1247 1248 /* 1249 * Clear IR LED, set SP3 clock to 24Mhz 1250 * set SP3_IRRX_SW to binary 01, helpfully not documented 1251 */ 1252 outb(0x10, data->ebase + WBCIR_REG_ECEIR_CTS); 1253 1254 /* Enable extended mode */ 1255 wbcir_select_bank(data, WBCIR_BANK_2); 1256 outb(WBCIR_EXT_ENABLE, data->sbase + WBCIR_REG_SP3_EXCR1); 1257 1258 /* 1259 * Configure baud generator, IR data will be sampled at 1260 * a bitrate of: (24Mhz * prescaler) / (divisor * 16). 1261 * 1262 * The ECIR registers include a flag to change the 1263 * 24Mhz clock freq to 48Mhz. 1264 * 1265 * It's not documented in the specs, but fifo levels 1266 * other than 16 seems to be unsupported. 1267 */ 1268 1269 /* prescaler 1.0, tx/rx fifo lvl 16 */ 1270 outb(0x30, data->sbase + WBCIR_REG_SP3_EXCR2); 1271 1272 /* Set baud divisor to generate one byte per bit/cell */ 1273 switch (protocol) { 1274 case IR_PROTOCOL_RC5: 1275 outb(0xA7, data->sbase + WBCIR_REG_SP3_BGDL); 1276 break; 1277 case IR_PROTOCOL_RC6: 1278 outb(0x53, data->sbase + WBCIR_REG_SP3_BGDL); 1279 break; 1280 case IR_PROTOCOL_NEC: 1281 outb(0x69, data->sbase + WBCIR_REG_SP3_BGDL); 1282 break; 1283 } 1284 outb(0x00, data->sbase + WBCIR_REG_SP3_BGDH); 1285 1286 /* Set CEIR mode */ 1287 wbcir_select_bank(data, WBCIR_BANK_0); 1288 outb(0xC0, data->sbase + WBCIR_REG_SP3_MCR); 1289 inb(data->sbase + WBCIR_REG_SP3_LSR); /* Clear LSR */ 1290 inb(data->sbase + WBCIR_REG_SP3_MSR); /* Clear MSR */ 1291 1292 /* Disable RX demod, run-length encoding/decoding, set freq span */ 1293 wbcir_select_bank(data, WBCIR_BANK_7); 1294 outb(0x10, data->sbase + WBCIR_REG_SP3_RCCFG); 1295 1296 /* Disable timer */ 1297 wbcir_select_bank(data, WBCIR_BANK_4); 1298 outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR1); 1299 1300 /* Enable MSR interrupt, Clear AUX_IRX */ 1301 wbcir_select_bank(data, WBCIR_BANK_5); 1302 outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR2); 1303 1304 /* Disable CRC */ 1305 wbcir_select_bank(data, WBCIR_BANK_6); 1306 outb(0x20, data->sbase + WBCIR_REG_SP3_IRCR3); 1307 1308 /* Set RX/TX (de)modulation freq, not really used */ 1309 wbcir_select_bank(data, WBCIR_BANK_7); 1310 outb(0xF2, data->sbase + WBCIR_REG_SP3_IRRXDC); 1311 outb(0x69, data->sbase + WBCIR_REG_SP3_IRTXMC); 1312 1313 /* Set invert and pin direction */ 1314 if (invert) 1315 outb(0x10, data->sbase + WBCIR_REG_SP3_IRCFG4); 1316 else 1317 outb(0x00, data->sbase + WBCIR_REG_SP3_IRCFG4); 1318 1319 /* Set FIFO thresholds (RX = 8, TX = 3), reset RX/TX */ 1320 wbcir_select_bank(data, WBCIR_BANK_0); 1321 outb(0x97, data->sbase + WBCIR_REG_SP3_FCR); 1322 1323 /* Clear AUX status bits */ 1324 outb(0xE0, data->sbase + WBCIR_REG_SP3_ASCR); 1325 1326 /* Enable interrupts */ 1327 wbcir_reset_irdata(data); 1328 outb(WBCIR_IRQ_RX | WBCIR_IRQ_ERR, data->sbase + WBCIR_REG_SP3_IER); 1329} 1330 1331static int 1332wbcir_resume(struct pnp_dev *device) 1333{ 1334 struct wbcir_data *data = pnp_get_drvdata(device); 1335 1336 wbcir_init_hw(data); 1337 enable_irq(data->irq); 1338 1339 return 0; 1340} 1341 1342static int __devinit 1343wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id) 1344{ 1345 struct device *dev = &device->dev; 1346 struct wbcir_data *data; 1347 int err; 1348 1349 if (!(pnp_port_len(device, 0) == EHFUNC_IOMEM_LEN && 1350 pnp_port_len(device, 1) == WAKEUP_IOMEM_LEN && 1351 pnp_port_len(device, 2) == SP_IOMEM_LEN)) { 1352 dev_err(dev, "Invalid resources\n"); 1353 return -ENODEV; 1354 } 1355 1356 data = kzalloc(sizeof(*data), GFP_KERNEL); 1357 if (!data) { 1358 err = -ENOMEM; 1359 goto exit; 1360 } 1361 1362 pnp_set_drvdata(device, data); 1363 1364 data->ebase = pnp_port_start(device, 0); 1365 data->wbase = pnp_port_start(device, 1); 1366 data->sbase = pnp_port_start(device, 2); 1367 data->irq = pnp_irq(device, 0); 1368 1369 if (data->wbase == 0 || data->ebase == 0 || 1370 data->sbase == 0 || data->irq == 0) { 1371 err = -ENODEV; 1372 dev_err(dev, "Invalid resources\n"); 1373 goto exit_free_data; 1374 } 1375 1376 dev_dbg(&device->dev, "Found device " 1377 "(w: 0x%lX, e: 0x%lX, s: 0x%lX, i: %u)\n", 1378 data->wbase, data->ebase, data->sbase, data->irq); 1379 1380 if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) { 1381 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", 1382 data->wbase, data->wbase + WAKEUP_IOMEM_LEN - 1); 1383 err = -EBUSY; 1384 goto exit_free_data; 1385 } 1386 1387 if (!request_region(data->ebase, EHFUNC_IOMEM_LEN, DRVNAME)) { 1388 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", 1389 data->ebase, data->ebase + EHFUNC_IOMEM_LEN - 1); 1390 err = -EBUSY; 1391 goto exit_release_wbase; 1392 } 1393 1394 if (!request_region(data->sbase, SP_IOMEM_LEN, DRVNAME)) { 1395 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n", 1396 data->sbase, data->sbase + SP_IOMEM_LEN - 1); 1397 err = -EBUSY; 1398 goto exit_release_ebase; 1399 } 1400 1401 err = request_irq(data->irq, wbcir_irq_handler, 1402 IRQF_DISABLED, DRVNAME, device); 1403 if (err) { 1404 dev_err(dev, "Failed to claim IRQ %u\n", data->irq); 1405 err = -EBUSY; 1406 goto exit_release_sbase; 1407 } 1408 1409 led_trigger_register_simple("cir-tx", &data->txtrigger); 1410 if (!data->txtrigger) { 1411 err = -ENOMEM; 1412 goto exit_free_irq; 1413 } 1414 1415 led_trigger_register_simple("cir-rx", &data->rxtrigger); 1416 if (!data->rxtrigger) { 1417 err = -ENOMEM; 1418 goto exit_unregister_txtrigger; 1419 } 1420 1421 data->led.name = "cir::activity"; 1422 data->led.default_trigger = "cir-rx"; 1423 data->led.brightness_set = wbcir_led_brightness_set; 1424 data->led.brightness_get = wbcir_led_brightness_get; 1425 err = led_classdev_register(&device->dev, &data->led); 1426 if (err) 1427 goto exit_unregister_rxtrigger; 1428 1429 data->input_dev = input_allocate_device(); 1430 if (!data->input_dev) { 1431 err = -ENOMEM; 1432 goto exit_unregister_led; 1433 } 1434 1435 data->input_dev->evbit[0] = BIT(EV_KEY); 1436 data->input_dev->name = WBCIR_NAME; 1437 data->input_dev->phys = "wbcir/cir0"; 1438 data->input_dev->id.bustype = BUS_HOST; 1439 data->input_dev->id.vendor = PCI_VENDOR_ID_WINBOND; 1440 data->input_dev->id.product = WBCIR_ID_FAMILY; 1441 data->input_dev->id.version = WBCIR_ID_CHIP; 1442 data->input_dev->getkeycode = wbcir_getkeycode; 1443 data->input_dev->setkeycode = wbcir_setkeycode; 1444 input_set_capability(data->input_dev, EV_MSC, MSC_SCAN); 1445 input_set_drvdata(data->input_dev, data); 1446 1447 err = input_register_device(data->input_dev); 1448 if (err) 1449 goto exit_free_input; 1450 1451 data->last_scancode = INVALID_SCANCODE; 1452 INIT_LIST_HEAD(&data->keytable); 1453 setup_timer(&data->timer_keyup, wbcir_keyup, (unsigned long)data); 1454 1455 /* Load default keymaps */ 1456 if (protocol == IR_PROTOCOL_RC6) { 1457 int i; 1458 for (i = 0; i < ARRAY_SIZE(rc6_def_keymap); i++) { 1459 err = wbcir_setkeycode(data->input_dev, 1460 (int)rc6_def_keymap[i].scancode, 1461 (int)rc6_def_keymap[i].keycode); 1462 if (err) 1463 goto exit_unregister_keys; 1464 } 1465 } 1466 1467 device_init_wakeup(&device->dev, 1); 1468 1469 wbcir_init_hw(data); 1470 1471 return 0; 1472 1473exit_unregister_keys: 1474 if (!list_empty(&data->keytable)) { 1475 struct wbcir_keyentry *key; 1476 struct wbcir_keyentry *keytmp; 1477 1478 list_for_each_entry_safe(key, keytmp, &data->keytable, list) { 1479 list_del(&key->list); 1480 kfree(key); 1481 } 1482 } 1483 input_unregister_device(data->input_dev); 1484 /* Can't call input_free_device on an unregistered device */ 1485 data->input_dev = NULL; 1486exit_free_input: 1487 input_free_device(data->input_dev); 1488exit_unregister_led: 1489 led_classdev_unregister(&data->led); 1490exit_unregister_rxtrigger: 1491 led_trigger_unregister_simple(data->rxtrigger); 1492exit_unregister_txtrigger: 1493 led_trigger_unregister_simple(data->txtrigger); 1494exit_free_irq: 1495 free_irq(data->irq, device); 1496exit_release_sbase: 1497 release_region(data->sbase, SP_IOMEM_LEN); 1498exit_release_ebase: 1499 release_region(data->ebase, EHFUNC_IOMEM_LEN); 1500exit_release_wbase: 1501 release_region(data->wbase, WAKEUP_IOMEM_LEN); 1502exit_free_data: 1503 kfree(data); 1504 pnp_set_drvdata(device, NULL); 1505exit: 1506 return err; 1507} 1508 1509static void __devexit 1510wbcir_remove(struct pnp_dev *device) 1511{ 1512 struct wbcir_data *data = pnp_get_drvdata(device); 1513 struct wbcir_keyentry *key; 1514 struct wbcir_keyentry *keytmp; 1515 1516 /* Disable interrupts */ 1517 wbcir_select_bank(data, WBCIR_BANK_0); 1518 outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER); 1519 1520 del_timer_sync(&data->timer_keyup); 1521 1522 free_irq(data->irq, device); 1523 1524 /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */ 1525 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17); 1526 1527 /* Clear CEIR_EN */ 1528 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01); 1529 1530 /* Clear BUFF_EN, END_EN, MATCH_EN */ 1531 wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07); 1532 1533 /* This will generate a keyup event if necessary */ 1534 input_unregister_device(data->input_dev); 1535 1536 led_trigger_unregister_simple(data->rxtrigger); 1537 led_trigger_unregister_simple(data->txtrigger); 1538 led_classdev_unregister(&data->led); 1539 1540 /* This is ok since &data->led isn't actually used */ 1541 wbcir_led_brightness_set(&data->led, LED_OFF); 1542 1543 release_region(data->wbase, WAKEUP_IOMEM_LEN); 1544 release_region(data->ebase, EHFUNC_IOMEM_LEN); 1545 release_region(data->sbase, SP_IOMEM_LEN); 1546 1547 list_for_each_entry_safe(key, keytmp, &data->keytable, list) { 1548 list_del(&key->list); 1549 kfree(key); 1550 } 1551 1552 kfree(data); 1553 1554 pnp_set_drvdata(device, NULL); 1555} 1556 1557static const struct pnp_device_id wbcir_ids[] = { 1558 { "WEC1022", 0 }, 1559 { "", 0 } 1560}; 1561MODULE_DEVICE_TABLE(pnp, wbcir_ids); 1562 1563static struct pnp_driver wbcir_driver = { 1564 .name = WBCIR_NAME, 1565 .id_table = wbcir_ids, 1566 .probe = wbcir_probe, 1567 .remove = __devexit_p(wbcir_remove), 1568 .suspend = wbcir_suspend, 1569 .resume = wbcir_resume, 1570 .shutdown = wbcir_shutdown 1571}; 1572 1573static int __init 1574wbcir_init(void) 1575{ 1576 int ret; 1577 1578 switch (protocol) { 1579 case IR_PROTOCOL_RC5: 1580 case IR_PROTOCOL_NEC: 1581 case IR_PROTOCOL_RC6: 1582 break; 1583 default: 1584 printk(KERN_ERR DRVNAME ": Invalid protocol argument\n"); 1585 return -EINVAL; 1586 } 1587 1588 ret = pnp_register_driver(&wbcir_driver); 1589 if (ret) 1590 printk(KERN_ERR DRVNAME ": Unable to register driver\n"); 1591 1592 return ret; 1593} 1594 1595static void __exit 1596wbcir_exit(void) 1597{ 1598 pnp_unregister_driver(&wbcir_driver); 1599} 1600 1601MODULE_AUTHOR("David H�rdeman <david@hardeman.nu>"); 1602MODULE_DESCRIPTION("Winbond SuperI/O Consumer IR Driver"); 1603MODULE_LICENSE("GPL"); 1604 1605module_init(wbcir_init); 1606module_exit(wbcir_exit); 1607