drivers/media/rc/fintek-cir.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Driver for Feature Integration Technology Inc. (aka Fintek) LPC CIR
   4  *
   5  * Copyright (C) 2011 Jarod Wilson <jarod@redhat.com>
   6  *
   7  * Special thanks to Fintek for providing hardware and spec sheets.
   8  * This driver is based upon the nuvoton, ite and ene drivers for
   9  * similar hardware.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/pnp.h>
  17 #include <linux/io.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/sched.h>
  20 #include <linux/slab.h>
  21 #include <media/rc-core.h>
  22
  23 #include "fintek-cir.h"
  24
  25 /* write val to config reg */
  26 static inline void fintek_cr_write(struct fintek_dev *fintek, u8 val, u8 reg)
  27 {
  28         fit_dbg("%s: reg 0x%02x, val 0x%02x  (ip/dp: %02x/%02x)",
  29                 __func__, reg, val, fintek->cr_ip, fintek->cr_dp);
  30         outb(reg, fintek->cr_ip);
  31         outb(val, fintek->cr_dp);
  32 }
  33
  34 /* read val from config reg */
  35 static inline u8 fintek_cr_read(struct fintek_dev *fintek, u8 reg)
  36 {
  37         u8 val;
  38
  39         outb(reg, fintek->cr_ip);
  40         val = inb(fintek->cr_dp);
  41
  42         fit_dbg("%s: reg 0x%02x, val 0x%02x  (ip/dp: %02x/%02x)",
  43                 __func__, reg, val, fintek->cr_ip, fintek->cr_dp);
  44         return val;
  45 }
  46
  47 /* update config register bit without changing other bits */
  48 static inline void fintek_set_reg_bit(struct fintek_dev *fintek, u8 val, u8 reg)
  49 {
  50         u8 tmp = fintek_cr_read(fintek, reg) | val;
  51         fintek_cr_write(fintek, tmp, reg);
  52 }
  53
  54 /* enter config mode */
  55 static inline void fintek_config_mode_enable(struct fintek_dev *fintek)
  56 {
  57         /* Enabling Config Mode explicitly requires writing 2x */
  58         outb(CONFIG_REG_ENABLE, fintek->cr_ip);
  59         outb(CONFIG_REG_ENABLE, fintek->cr_ip);
  60 }
  61
  62 /* exit config mode */
  63 static inline void fintek_config_mode_disable(struct fintek_dev *fintek)
  64 {
  65         outb(CONFIG_REG_DISABLE, fintek->cr_ip);
  66 }
  67
  68 /*
  69  * When you want to address a specific logical device, write its logical
  70  * device number to GCR_LOGICAL_DEV_NO
  71  */
  72 static inline void fintek_select_logical_dev(struct fintek_dev *fintek, u8 ldev)
  73 {
  74         fintek_cr_write(fintek, ldev, GCR_LOGICAL_DEV_NO);
  75 }
  76
  77 /* write val to cir config register */
  78 static inline void fintek_cir_reg_write(struct fintek_dev *fintek, u8 val, u8 offset)
  79 {
  80         outb(val, fintek->cir_addr + offset);
  81 }
  82
  83 /* read val from cir config register */
  84 static u8 fintek_cir_reg_read(struct fintek_dev *fintek, u8 offset)
  85 {
  86         return inb(fintek->cir_addr + offset);
  87 }
  88
  89 /* dump current cir register contents */
  90 static void cir_dump_regs(struct fintek_dev *fintek)
  91 {
  92         fintek_config_mode_enable(fintek);
  93         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
  94
  95         pr_info("%s: Dump CIR logical device registers:\n", FINTEK_DRIVER_NAME);
  96         pr_info(" * CR CIR BASE ADDR: 0x%x\n",
  97                 (fintek_cr_read(fintek, CIR_CR_BASE_ADDR_HI) << 8) |
  98                 fintek_cr_read(fintek, CIR_CR_BASE_ADDR_LO));
  99         pr_info(" * CR CIR IRQ NUM:   0x%x\n",
 100                 fintek_cr_read(fintek, CIR_CR_IRQ_SEL));
 101
 102         fintek_config_mode_disable(fintek);
 103
 104         pr_info("%s: Dump CIR registers:\n", FINTEK_DRIVER_NAME);
 105         pr_info(" * STATUS:     0x%x\n",
 106                 fintek_cir_reg_read(fintek, CIR_STATUS));
 107         pr_info(" * CONTROL:    0x%x\n",
 108                 fintek_cir_reg_read(fintek, CIR_CONTROL));
 109         pr_info(" * RX_DATA:    0x%x\n",
 110                 fintek_cir_reg_read(fintek, CIR_RX_DATA));
 111         pr_info(" * TX_CONTROL: 0x%x\n",
 112                 fintek_cir_reg_read(fintek, CIR_TX_CONTROL));
 113         pr_info(" * TX_DATA:    0x%x\n",
 114                 fintek_cir_reg_read(fintek, CIR_TX_DATA));
 115 }
 116
 117 /* detect hardware features */
 118 static int fintek_hw_detect(struct fintek_dev *fintek)
 119 {
 120         unsigned long flags;
 121         u8 chip_major, chip_minor;
 122         u8 vendor_major, vendor_minor;
 123         u8 portsel, ir_class;
 124         u16 vendor, chip;
 125
 126         fintek_config_mode_enable(fintek);
 127
 128         /* Check if we're using config port 0x4e or 0x2e */
 129         portsel = fintek_cr_read(fintek, GCR_CONFIG_PORT_SEL);
 130         if (portsel == 0xff) {
 131                 fit_pr(KERN_INFO, "first portsel read was bunk, trying alt");
 132                 fintek_config_mode_disable(fintek);
 133                 fintek->cr_ip = CR_INDEX_PORT2;
 134                 fintek->cr_dp = CR_DATA_PORT2;
 135                 fintek_config_mode_enable(fintek);
 136                 portsel = fintek_cr_read(fintek, GCR_CONFIG_PORT_SEL);
 137         }
 138         fit_dbg("portsel reg: 0x%02x", portsel);
 139
 140         ir_class = fintek_cir_reg_read(fintek, CIR_CR_CLASS);
 141         fit_dbg("ir_class reg: 0x%02x", ir_class);
 142
 143         switch (ir_class) {
 144         case CLASS_RX_2TX:
 145         case CLASS_RX_1TX:
 146                 fintek->hw_tx_capable = true;
 147                 break;
 148         case CLASS_RX_ONLY:
 149         default:
 150                 fintek->hw_tx_capable = false;
 151                 break;
 152         }
 153
 154         chip_major = fintek_cr_read(fintek, GCR_CHIP_ID_HI);
 155         chip_minor = fintek_cr_read(fintek, GCR_CHIP_ID_LO);
 156         chip  = chip_major << 8 | chip_minor;
 157
 158         vendor_major = fintek_cr_read(fintek, GCR_VENDOR_ID_HI);
 159         vendor_minor = fintek_cr_read(fintek, GCR_VENDOR_ID_LO);
 160         vendor = vendor_major << 8 | vendor_minor;
 161
 162         if (vendor != VENDOR_ID_FINTEK)
 163                 fit_pr(KERN_WARNING, "Unknown vendor ID: 0x%04x", vendor);
 164         else
 165                 fit_dbg("Read Fintek vendor ID from chip");
 166
 167         fintek_config_mode_disable(fintek);
 168
 169         spin_lock_irqsave(&fintek->fintek_lock, flags);
 170         fintek->chip_major  = chip_major;
 171         fintek->chip_minor  = chip_minor;
 172         fintek->chip_vendor = vendor;
 173
 174         /*
 175          * Newer reviews of this chipset uses port 8 instead of 5
 176          */
 177         if ((chip != 0x0408) && (chip != 0x0804))
 178                 fintek->logical_dev_cir = LOGICAL_DEV_CIR_REV2;
 179         else
 180                 fintek->logical_dev_cir = LOGICAL_DEV_CIR_REV1;
 181
 182         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 183
 184         return 0;
 185 }
 186
 187 static void fintek_cir_ldev_init(struct fintek_dev *fintek)
 188 {
 189         /* Select CIR logical device and enable */
 190         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 191         fintek_cr_write(fintek, LOGICAL_DEV_ENABLE, CIR_CR_DEV_EN);
 192
 193         /* Write allocated CIR address and IRQ information to hardware */
 194         fintek_cr_write(fintek, fintek->cir_addr >> 8, CIR_CR_BASE_ADDR_HI);
 195         fintek_cr_write(fintek, fintek->cir_addr & 0xff, CIR_CR_BASE_ADDR_LO);
 196
 197         fintek_cr_write(fintek, fintek->cir_irq, CIR_CR_IRQ_SEL);
 198
 199         fit_dbg("CIR initialized, base io address: 0x%lx, irq: %d (len: %d)",
 200                 fintek->cir_addr, fintek->cir_irq, fintek->cir_port_len);
 201 }
 202
 203 /* enable CIR interrupts */
 204 static void fintek_enable_cir_irq(struct fintek_dev *fintek)
 205 {
 206         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_EN, CIR_STATUS);
 207 }
 208
 209 static void fintek_cir_regs_init(struct fintek_dev *fintek)
 210 {
 211         /* clear any and all stray interrupts */
 212         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 213
 214         /* and finally, enable interrupts */
 215         fintek_enable_cir_irq(fintek);
 216 }
 217
 218 static void fintek_enable_wake(struct fintek_dev *fintek)
 219 {
 220         fintek_config_mode_enable(fintek);
 221         fintek_select_logical_dev(fintek, LOGICAL_DEV_ACPI);
 222
 223         /* Allow CIR PME's to wake system */
 224         fintek_set_reg_bit(fintek, ACPI_WAKE_EN_CIR_BIT, LDEV_ACPI_WAKE_EN_REG);
 225         /* Enable CIR PME's */
 226         fintek_set_reg_bit(fintek, ACPI_PME_CIR_BIT, LDEV_ACPI_PME_EN_REG);
 227         /* Clear CIR PME status register */
 228         fintek_set_reg_bit(fintek, ACPI_PME_CIR_BIT, LDEV_ACPI_PME_CLR_REG);
 229         /* Save state */
 230         fintek_set_reg_bit(fintek, ACPI_STATE_CIR_BIT, LDEV_ACPI_STATE_REG);
 231
 232         fintek_config_mode_disable(fintek);
 233 }
 234
 235 static int fintek_cmdsize(u8 cmd, u8 subcmd)
 236 {
 237         int datasize = 0;
 238
 239         switch (cmd) {
 240         case BUF_COMMAND_NULL:
 241                 if (subcmd == BUF_HW_CMD_HEADER)
 242                         datasize = 1;
 243                 break;
 244         case BUF_HW_CMD_HEADER:
 245                 if (subcmd == BUF_CMD_G_REVISION)
 246                         datasize = 2;
 247                 break;
 248         case BUF_COMMAND_HEADER:
 249                 switch (subcmd) {
 250                 case BUF_CMD_S_CARRIER:
 251                 case BUF_CMD_S_TIMEOUT:
 252                 case BUF_RSP_PULSE_COUNT:
 253                         datasize = 2;
 254                         break;
 255                 case BUF_CMD_SIG_END:
 256                 case BUF_CMD_S_TXMASK:
 257                 case BUF_CMD_S_RXSENSOR:
 258                         datasize = 1;
 259                         break;
 260                 }
 261         }
 262
 263         return datasize;
 264 }
 265
 266 /* process ir data stored in driver buffer */
 267 static void fintek_process_rx_ir_data(struct fintek_dev *fintek)
 268 {
 269         struct ir_raw_event rawir = {};
 270         u8 sample;
 271         bool event = false;
 272         int i;
 273
 274         for (i = 0; i < fintek->pkts; i++) {
 275                 sample = fintek->buf[i];
 276                 switch (fintek->parser_state) {
 277                 case CMD_HEADER:
 278                         fintek->cmd = sample;
 279                         if ((fintek->cmd == BUF_COMMAND_HEADER) ||
 280                             ((fintek->cmd & BUF_COMMAND_MASK) !=
 281                              BUF_PULSE_BIT)) {
 282                                 fintek->parser_state = SUBCMD;
 283                                 continue;
 284                         }
 285                         fintek->rem = (fintek->cmd & BUF_LEN_MASK);
 286                         fit_dbg("%s: rem: 0x%02x", __func__, fintek->rem);
 287                         if (fintek->rem)
 288                                 fintek->parser_state = PARSE_IRDATA;
 289                         else
 290                                 ir_raw_event_overflow(fintek->rdev);
 291                         break;
 292                 case SUBCMD:
 293                         fintek->rem = fintek_cmdsize(fintek->cmd, sample);
 294                         fintek->parser_state = CMD_DATA;
 295                         break;
 296                 case CMD_DATA:
 297                         fintek->rem--;
 298                         break;
 299                 case PARSE_IRDATA:
 300                         fintek->rem--;
 301                         rawir.pulse = ((sample & BUF_PULSE_BIT) != 0);
 302                         rawir.duration = (sample & BUF_SAMPLE_MASK)
 303                                           * CIR_SAMPLE_PERIOD;
 304
 305                         fit_dbg("Storing %s with duration %d",
 306                                 rawir.pulse ? "pulse" : "space",
 307                                 rawir.duration);
 308                         if (ir_raw_event_store_with_filter(fintek->rdev,
 309                                                                         &rawir))
 310                                 event = true;
 311                         break;
 312                 }
 313
 314                 if ((fintek->parser_state != CMD_HEADER) && !fintek->rem)
 315                         fintek->parser_state = CMD_HEADER;
 316         }
 317
 318         fintek->pkts = 0;
 319
 320         if (event) {
 321                 fit_dbg("Calling ir_raw_event_handle");
 322                 ir_raw_event_handle(fintek->rdev);
 323         }
 324 }
 325
 326 /* copy data from hardware rx register into driver buffer */
 327 static void fintek_get_rx_ir_data(struct fintek_dev *fintek, u8 rx_irqs)
 328 {
 329         unsigned long flags;
 330         u8 sample, status;
 331
 332         spin_lock_irqsave(&fintek->fintek_lock, flags);
 333
 334         /*
 335          * We must read data from CIR_RX_DATA until the hardware IR buffer
 336          * is empty and clears the RX_TIMEOUT and/or RX_RECEIVE flags in
 337          * the CIR_STATUS register
 338          */
 339         do {
 340                 sample = fintek_cir_reg_read(fintek, CIR_RX_DATA);
 341                 fit_dbg("%s: sample: 0x%02x", __func__, sample);
 342
 343                 fintek->buf[fintek->pkts] = sample;
 344                 fintek->pkts++;
 345
 346                 status = fintek_cir_reg_read(fintek, CIR_STATUS);
 347                 if (!(status & CIR_STATUS_IRQ_EN))
 348                         break;
 349         } while (status & rx_irqs);
 350
 351         fintek_process_rx_ir_data(fintek);
 352
 353         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 354 }
 355
 356 static void fintek_cir_log_irqs(u8 status)
 357 {
 358         fit_pr(KERN_INFO, "IRQ 0x%02x:%s%s%s%s%s", status,
 359                 status & CIR_STATUS_IRQ_EN      ? " IRQEN"      : "",
 360                 status & CIR_STATUS_TX_FINISH   ? " TXF"        : "",
 361                 status & CIR_STATUS_TX_UNDERRUN ? " TXU"        : "",
 362                 status & CIR_STATUS_RX_TIMEOUT  ? " RXTO"       : "",
 363                 status & CIR_STATUS_RX_RECEIVE  ? " RXOK"       : "");
 364 }
 365
 366 /* interrupt service routine for incoming and outgoing CIR data */
 367 static irqreturn_t fintek_cir_isr(int irq, void *data)
 368 {
 369         struct fintek_dev *fintek = data;
 370         u8 status, rx_irqs;
 371
 372         fit_dbg_verbose("%s firing", __func__);
 373
 374         fintek_config_mode_enable(fintek);
 375         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 376         fintek_config_mode_disable(fintek);
 377
 378         /*
 379          * Get IR Status register contents. Write 1 to ack/clear
 380          *
 381          * bit: reg name    - description
 382          *   3: TX_FINISH   - TX is finished
 383          *   2: TX_UNDERRUN - TX underrun
 384          *   1: RX_TIMEOUT  - RX data timeout
 385          *   0: RX_RECEIVE  - RX data received
 386          */
 387         status = fintek_cir_reg_read(fintek, CIR_STATUS);
 388         if (!(status & CIR_STATUS_IRQ_MASK) || status == 0xff) {
 389                 fit_dbg_verbose("%s exiting, IRSTS 0x%02x", __func__, status);
 390                 fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 391                 return IRQ_RETVAL(IRQ_NONE);
 392         }
 393
 394         if (debug)
 395                 fintek_cir_log_irqs(status);
 396
 397         rx_irqs = status & (CIR_STATUS_RX_RECEIVE | CIR_STATUS_RX_TIMEOUT);
 398         if (rx_irqs)
 399                 fintek_get_rx_ir_data(fintek, rx_irqs);
 400
 401         /* ack/clear all irq flags we've got */
 402         fintek_cir_reg_write(fintek, status, CIR_STATUS);
 403
 404         fit_dbg_verbose("%s done", __func__);
 405         return IRQ_RETVAL(IRQ_HANDLED);
 406 }
 407
 408 static void fintek_enable_cir(struct fintek_dev *fintek)
 409 {
 410         /* set IRQ enabled */
 411         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_EN, CIR_STATUS);
 412
 413         fintek_config_mode_enable(fintek);
 414
 415         /* enable the CIR logical device */
 416         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 417         fintek_cr_write(fintek, LOGICAL_DEV_ENABLE, CIR_CR_DEV_EN);
 418
 419         fintek_config_mode_disable(fintek);
 420
 421         /* clear all pending interrupts */
 422         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 423
 424         /* enable interrupts */
 425         fintek_enable_cir_irq(fintek);
 426 }
 427
 428 static void fintek_disable_cir(struct fintek_dev *fintek)
 429 {
 430         fintek_config_mode_enable(fintek);
 431
 432         /* disable the CIR logical device */
 433         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 434         fintek_cr_write(fintek, LOGICAL_DEV_DISABLE, CIR_CR_DEV_EN);
 435
 436         fintek_config_mode_disable(fintek);
 437 }
 438
 439 static int fintek_open(struct rc_dev *dev)
 440 {
 441         struct fintek_dev *fintek = dev->priv;
 442         unsigned long flags;
 443
 444         spin_lock_irqsave(&fintek->fintek_lock, flags);
 445         fintek_enable_cir(fintek);
 446         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 447
 448         return 0;
 449 }
 450
 451 static void fintek_close(struct rc_dev *dev)
 452 {
 453         struct fintek_dev *fintek = dev->priv;
 454         unsigned long flags;
 455
 456         spin_lock_irqsave(&fintek->fintek_lock, flags);
 457         fintek_disable_cir(fintek);
 458         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 459 }
 460
 461 /* Allocate memory, probe hardware, and initialize everything */
 462 static int fintek_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
 463 {
 464         struct fintek_dev *fintek;
 465         struct rc_dev *rdev;
 466         int ret = -ENOMEM;
 467
 468         fintek = kzalloc(sizeof(struct fintek_dev), GFP_KERNEL);
 469         if (!fintek)
 470                 return ret;
 471
 472         /* input device for IR remote (and tx) */
 473         rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
 474         if (!rdev)
 475                 goto exit_free_dev_rdev;
 476
 477         ret = -ENODEV;
 478         /* validate pnp resources */
 479         if (!pnp_port_valid(pdev, 0)) {
 480                 dev_err(&pdev->dev, "IR PNP Port not valid!\n");
 481                 goto exit_free_dev_rdev;
 482         }
 483
 484         if (!pnp_irq_valid(pdev, 0)) {
 485                 dev_err(&pdev->dev, "IR PNP IRQ not valid!\n");
 486                 goto exit_free_dev_rdev;
 487         }
 488
 489         fintek->cir_addr = pnp_port_start(pdev, 0);
 490         fintek->cir_irq  = pnp_irq(pdev, 0);
 491         fintek->cir_port_len = pnp_port_len(pdev, 0);
 492
 493         fintek->cr_ip = CR_INDEX_PORT;
 494         fintek->cr_dp = CR_DATA_PORT;
 495
 496         spin_lock_init(&fintek->fintek_lock);
 497
 498         pnp_set_drvdata(pdev, fintek);
 499         fintek->pdev = pdev;
 500
 501         ret = fintek_hw_detect(fintek);
 502         if (ret)
 503                 goto exit_free_dev_rdev;
 504
 505         /* Initialize CIR & CIR Wake Logical Devices */
 506         fintek_config_mode_enable(fintek);
 507         fintek_cir_ldev_init(fintek);
 508         fintek_config_mode_disable(fintek);
 509
 510         /* Initialize CIR & CIR Wake Config Registers */
 511         fintek_cir_regs_init(fintek);
 512
 513         /* Set up the rc device */
 514         rdev->priv = fintek;
 515         rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
 516         rdev->open = fintek_open;
 517         rdev->close = fintek_close;
 518         rdev->device_name = FINTEK_DESCRIPTION;
 519         rdev->input_phys = "fintek/cir0";
 520         rdev->input_id.bustype = BUS_HOST;
 521         rdev->input_id.vendor = VENDOR_ID_FINTEK;
 522         rdev->input_id.product = fintek->chip_major;
 523         rdev->input_id.version = fintek->chip_minor;
 524         rdev->dev.parent = &pdev->dev;
 525         rdev->driver_name = FINTEK_DRIVER_NAME;
 526         rdev->map_name = RC_MAP_RC6_MCE;
 527         rdev->timeout = 1000;
 528         /* rx resolution is hardwired to 50us atm, 1, 25, 100 also possible */
 529         rdev->rx_resolution = CIR_SAMPLE_PERIOD;
 530
 531         fintek->rdev = rdev;
 532
 533         ret = -EBUSY;
 534         /* now claim resources */
 535         if (!request_region(fintek->cir_addr,
 536                             fintek->cir_port_len, FINTEK_DRIVER_NAME))
 537                 goto exit_free_dev_rdev;
 538
 539         if (request_irq(fintek->cir_irq, fintek_cir_isr, IRQF_SHARED,
 540                         FINTEK_DRIVER_NAME, (void *)fintek))
 541                 goto exit_free_cir_addr;
 542
 543         ret = rc_register_device(rdev);
 544         if (ret)
 545                 goto exit_free_irq;
 546
 547         device_init_wakeup(&pdev->dev, true);
 548
 549         fit_pr(KERN_NOTICE, "driver has been successfully loaded\n");
 550         if (debug)
 551                 cir_dump_regs(fintek);
 552
 553         return 0;
 554
 555 exit_free_irq:
 556         free_irq(fintek->cir_irq, fintek);
 557 exit_free_cir_addr:
 558         release_region(fintek->cir_addr, fintek->cir_port_len);
 559 exit_free_dev_rdev:
 560         rc_free_device(rdev);
 561         kfree(fintek);
 562
 563         return ret;
 564 }
 565
 566 static void fintek_remove(struct pnp_dev *pdev)
 567 {
 568         struct fintek_dev *fintek = pnp_get_drvdata(pdev);
 569         unsigned long flags;
 570
 571         spin_lock_irqsave(&fintek->fintek_lock, flags);
 572         /* disable CIR */
 573         fintek_disable_cir(fintek);
 574         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 575         /* enable CIR Wake (for IR power-on) */
 576         fintek_enable_wake(fintek);
 577         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 578
 579         /* free resources */
 580         free_irq(fintek->cir_irq, fintek);
 581         release_region(fintek->cir_addr, fintek->cir_port_len);
 582
 583         rc_unregister_device(fintek->rdev);
 584
 585         kfree(fintek);
 586 }
 587
 588 static int fintek_suspend(struct pnp_dev *pdev, pm_message_t state)
 589 {
 590         struct fintek_dev *fintek = pnp_get_drvdata(pdev);
 591         unsigned long flags;
 592
 593         fit_dbg("%s called", __func__);
 594
 595         spin_lock_irqsave(&fintek->fintek_lock, flags);
 596
 597         /* disable all CIR interrupts */
 598         fintek_cir_reg_write(fintek, CIR_STATUS_IRQ_MASK, CIR_STATUS);
 599
 600         spin_unlock_irqrestore(&fintek->fintek_lock, flags);
 601
 602         fintek_config_mode_enable(fintek);
 603
 604         /* disable cir logical dev */
 605         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 606         fintek_cr_write(fintek, LOGICAL_DEV_DISABLE, CIR_CR_DEV_EN);
 607
 608         fintek_config_mode_disable(fintek);
 609
 610         /* make sure wake is enabled */
 611         fintek_enable_wake(fintek);
 612
 613         return 0;
 614 }
 615
 616 static int fintek_resume(struct pnp_dev *pdev)
 617 {
 618         struct fintek_dev *fintek = pnp_get_drvdata(pdev);
 619
 620         fit_dbg("%s called", __func__);
 621
 622         /* open interrupt */
 623         fintek_enable_cir_irq(fintek);
 624
 625         /* Enable CIR logical device */
 626         fintek_config_mode_enable(fintek);
 627         fintek_select_logical_dev(fintek, fintek->logical_dev_cir);
 628         fintek_cr_write(fintek, LOGICAL_DEV_ENABLE, CIR_CR_DEV_EN);
 629
 630         fintek_config_mode_disable(fintek);
 631
 632         fintek_cir_regs_init(fintek);
 633
 634         return 0;
 635 }
 636
 637 static void fintek_shutdown(struct pnp_dev *pdev)
 638 {
 639         struct fintek_dev *fintek = pnp_get_drvdata(pdev);
 640         fintek_enable_wake(fintek);
 641 }
 642
 643 static const struct pnp_device_id fintek_ids[] = {
 644         { "FIT0002", 0 },   /* CIR */
 645         { "", 0 },
 646 };
 647
 648 static struct pnp_driver fintek_driver = {
 649         .name           = FINTEK_DRIVER_NAME,
 650         .id_table       = fintek_ids,
 651         .flags          = PNP_DRIVER_RES_DO_NOT_CHANGE,
 652         .probe          = fintek_probe,
 653         .remove         = fintek_remove,
 654         .suspend        = fintek_suspend,
 655         .resume         = fintek_resume,
 656         .shutdown       = fintek_shutdown,
 657 };
 658
 659 module_param(debug, int, S_IRUGO | S_IWUSR);
 660 MODULE_PARM_DESC(debug, "Enable debugging output");
 661
 662 MODULE_DEVICE_TABLE(pnp, fintek_ids);
 663 MODULE_DESCRIPTION(FINTEK_DESCRIPTION " driver");
 664
 665 MODULE_AUTHOR("Jarod Wilson <jarod@redhat.com>");
 666 MODULE_LICENSE("GPL");
 667
 668 module_pnp_driver(fintek_driver);