kernel/drivers/staging/media/lirc/lirc_bt829.c

   1 /*
   2  * Remote control driver for the TV-card based on bt829
   3  *
   4  *  by Leonid Froenchenko <lfroen@galileo.co.il>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU 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  USA
  19 */
  20
  21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/threads.h>
  26 #include <linux/sched.h>
  27 #include <linux/ioport.h>
  28 #include <linux/pci.h>
  29 #include <linux/delay.h>
  30
  31 #include <media/lirc_dev.h>
  32
  33 static int poll_main(void);
  34 static int atir_init_start(void);
  35
  36 static void write_index(unsigned char index, unsigned int value);
  37 static unsigned int read_index(unsigned char index);
  38
  39 static void do_i2c_start(void);
  40 static void do_i2c_stop(void);
  41
  42 static void seems_wr_byte(unsigned char al);
  43 static unsigned char seems_rd_byte(void);
  44
  45 static unsigned int read_index(unsigned char al);
  46 static void write_index(unsigned char ah, unsigned int edx);
  47
  48 static void cycle_delay(int cycle);
  49
  50 static void do_set_bits(unsigned char bl);
  51 static unsigned char do_get_bits(void);
  52
  53 #define DATA_PCI_OFF 0x7FFC00
  54 #define WAIT_CYCLE   20
  55
  56 #define DRIVER_NAME "lirc_bt829"
  57
  58 static bool debug;
  59
  60 static int atir_minor;
  61 static phys_addr_t pci_addr_phys;
  62 static unsigned char __iomem *pci_addr_lin;
  63
  64 static struct lirc_driver atir_driver;
  65
  66 static struct pci_dev *do_pci_probe(void)
  67 {
  68         struct pci_dev *my_dev;
  69
  70         my_dev = pci_get_device(PCI_VENDOR_ID_ATI,
  71                                 PCI_DEVICE_ID_ATI_264VT, NULL);
  72         if (my_dev) {
  73                 pr_err("Using device: %s\n", pci_name(my_dev));
  74                 pci_addr_phys = 0;
  75                 if (my_dev->resource[0].flags & IORESOURCE_MEM) {
  76                         pci_addr_phys = my_dev->resource[0].start;
  77                         pr_info("memory at %pa\n", &pci_addr_phys);
  78                 }
  79                 if (pci_addr_phys == 0) {
  80                         pr_err("no memory resource ?\n");
  81                         pci_dev_put(my_dev);
  82                         return NULL;
  83                 }
  84         } else {
  85                 pr_err("pci_probe failed\n");
  86                 return NULL;
  87         }
  88         return my_dev;
  89 }
  90
  91 static int atir_add_to_buf(void *data, struct lirc_buffer *buf)
  92 {
  93         unsigned char key;
  94         int status;
  95
  96         status = poll_main();
  97         key = (status >> 8) & 0xFF;
  98         if (status & 0xFF) {
  99                 dev_dbg(atir_driver.dev, "reading key %02X\n", key);
 100                 lirc_buffer_write(buf, &key);
 101                 return 0;
 102         }
 103         return -ENODATA;
 104 }
 105
 106 static int atir_set_use_inc(void *data)
 107 {
 108         dev_dbg(atir_driver.dev, "driver is opened\n");
 109         return 0;
 110 }
 111
 112 static void atir_set_use_dec(void *data)
 113 {
 114         dev_dbg(atir_driver.dev, "driver is closed\n");
 115 }
 116
 117 int init_module(void)
 118 {
 119         struct pci_dev *pdev;
 120         int rc;
 121
 122         pdev = do_pci_probe();
 123         if (pdev == NULL)
 124                 return -ENODEV;
 125
 126         rc = pci_enable_device(pdev);
 127         if (rc)
 128                 goto err_put_dev;
 129
 130         if (!atir_init_start()) {
 131                 rc = -ENODEV;
 132                 goto err_disable;
 133         }
 134
 135         strcpy(atir_driver.name, "ATIR");
 136         atir_driver.minor       = -1;
 137         atir_driver.code_length = 8;
 138         atir_driver.sample_rate = 10;
 139         atir_driver.data        = NULL;
 140         atir_driver.add_to_buf  = atir_add_to_buf;
 141         atir_driver.set_use_inc = atir_set_use_inc;
 142         atir_driver.set_use_dec = atir_set_use_dec;
 143         atir_driver.dev         = &pdev->dev;
 144         atir_driver.owner       = THIS_MODULE;
 145
 146         atir_minor = lirc_register_driver(&atir_driver);
 147         if (atir_minor < 0) {
 148                 pr_err("failed to register driver!\n");
 149                 rc = atir_minor;
 150                 goto err_unmap;
 151         }
 152         dev_dbg(atir_driver.dev, "driver is registered on minor %d\n",
 153                                 atir_minor);
 154
 155         return 0;
 156
 157 err_unmap:
 158         iounmap(pci_addr_lin);
 159 err_disable:
 160         pci_disable_device(pdev);
 161 err_put_dev:
 162         pci_dev_put(pdev);
 163         return rc;
 164 }
 165
 166
 167 void cleanup_module(void)
 168 {
 169         struct pci_dev *pdev = to_pci_dev(atir_driver.dev);
 170
 171         lirc_unregister_driver(atir_minor);
 172         iounmap(pci_addr_lin);
 173         pci_disable_device(pdev);
 174         pci_dev_put(pdev);
 175 }
 176
 177
 178 static int atir_init_start(void)
 179 {
 180         pci_addr_lin = ioremap(pci_addr_phys + DATA_PCI_OFF, 0x400);
 181         if (!pci_addr_lin) {
 182                 pr_info("pci mem must be mapped\n");
 183                 return 0;
 184         }
 185         return 1;
 186 }
 187
 188 static void cycle_delay(int cycle)
 189 {
 190         udelay(WAIT_CYCLE*cycle);
 191 }
 192
 193
 194 static int poll_main(void)
 195 {
 196         unsigned char status_high, status_low;
 197
 198         do_i2c_start();
 199
 200         seems_wr_byte(0xAA);
 201         seems_wr_byte(0x01);
 202
 203         do_i2c_start();
 204
 205         seems_wr_byte(0xAB);
 206
 207         status_low = seems_rd_byte();
 208         status_high = seems_rd_byte();
 209
 210         do_i2c_stop();
 211
 212         return (status_high << 8) | status_low;
 213 }
 214
 215 static void do_i2c_start(void)
 216 {
 217         do_set_bits(3);
 218         cycle_delay(4);
 219
 220         do_set_bits(1);
 221         cycle_delay(7);
 222
 223         do_set_bits(0);
 224         cycle_delay(2);
 225 }
 226
 227 static void do_i2c_stop(void)
 228 {
 229         unsigned char bits;
 230
 231         bits =  do_get_bits() & 0xFD;
 232         do_set_bits(bits);
 233         cycle_delay(1);
 234
 235         bits |= 1;
 236         do_set_bits(bits);
 237         cycle_delay(2);
 238
 239         bits |= 2;
 240         do_set_bits(bits);
 241         bits = 3;
 242         do_set_bits(bits);
 243         cycle_delay(2);
 244 }
 245
 246 static void seems_wr_byte(unsigned char value)
 247 {
 248         int i;
 249         unsigned char reg;
 250
 251         reg = do_get_bits();
 252         for (i = 0; i < 8; i++) {
 253                 if (value & 0x80)
 254                         reg |= 0x02;
 255                 else
 256                         reg &= 0xFD;
 257
 258                 do_set_bits(reg);
 259                 cycle_delay(1);
 260
 261                 reg |= 1;
 262                 do_set_bits(reg);
 263                 cycle_delay(1);
 264
 265                 reg &= 0xFE;
 266                 do_set_bits(reg);
 267                 cycle_delay(1);
 268                 value <<= 1;
 269         }
 270         cycle_delay(2);
 271
 272         reg |= 2;
 273         do_set_bits(reg);
 274
 275         reg |= 1;
 276         do_set_bits(reg);
 277
 278         cycle_delay(1);
 279         do_get_bits();
 280
 281         reg &= 0xFE;
 282         do_set_bits(reg);
 283         cycle_delay(3);
 284 }
 285
 286 static unsigned char seems_rd_byte(void)
 287 {
 288         int i;
 289         int rd_byte;
 290         unsigned char bits_2, bits_1;
 291
 292         bits_1 = do_get_bits() | 2;
 293         do_set_bits(bits_1);
 294
 295         rd_byte = 0;
 296         for (i = 0; i < 8; i++) {
 297                 bits_1 &= 0xFE;
 298                 do_set_bits(bits_1);
 299                 cycle_delay(2);
 300
 301                 bits_1 |= 1;
 302                 do_set_bits(bits_1);
 303                 cycle_delay(1);
 304
 305                 bits_2 = do_get_bits();
 306                 if (bits_2 & 2)
 307                         rd_byte |= 1;
 308
 309                 rd_byte <<= 1;
 310         }
 311
 312         bits_1 = 0;
 313         if (bits_2 == 0)
 314                 bits_1 |= 2;
 315
 316         do_set_bits(bits_1);
 317         cycle_delay(2);
 318
 319         bits_1 |= 1;
 320         do_set_bits(bits_1);
 321         cycle_delay(3);
 322
 323         bits_1 &= 0xFE;
 324         do_set_bits(bits_1);
 325         cycle_delay(2);
 326
 327         rd_byte >>= 1;
 328         rd_byte &= 0xFF;
 329         return rd_byte;
 330 }
 331
 332 static void do_set_bits(unsigned char new_bits)
 333 {
 334         int reg_val;
 335
 336         reg_val = read_index(0x34);
 337         if (new_bits & 2) {
 338                 reg_val &= 0xFFFFFFDF;
 339                 reg_val |= 1;
 340         } else {
 341                 reg_val &= 0xFFFFFFFE;
 342                 reg_val |= 0x20;
 343         }
 344         reg_val |= 0x10;
 345         write_index(0x34, reg_val);
 346
 347         reg_val = read_index(0x31);
 348         if (new_bits & 1)
 349                 reg_val |= 0x1000000;
 350         else
 351                 reg_val &= 0xFEFFFFFF;
 352
 353         reg_val |= 0x8000000;
 354         write_index(0x31, reg_val);
 355 }
 356
 357 static unsigned char do_get_bits(void)
 358 {
 359         unsigned char bits;
 360         int reg_val;
 361
 362         reg_val = read_index(0x34);
 363         reg_val |= 0x10;
 364         reg_val &= 0xFFFFFFDF;
 365         write_index(0x34, reg_val);
 366
 367         reg_val = read_index(0x34);
 368         bits = 0;
 369         if (reg_val & 8)
 370                 bits |= 2;
 371         else
 372                 bits &= 0xFD;
 373
 374         reg_val = read_index(0x31);
 375         if (reg_val & 0x1000000)
 376                 bits |= 1;
 377         else
 378                 bits &= 0xFE;
 379
 380         return bits;
 381 }
 382
 383 static unsigned int read_index(unsigned char index)
 384 {
 385         unsigned char __iomem *addr;
 386         /*  addr = pci_addr_lin + DATA_PCI_OFF + ((index & 0xFF) << 2); */
 387         addr = pci_addr_lin + ((index & 0xFF) << 2);
 388         return readl(addr);
 389 }
 390
 391 static void write_index(unsigned char index, unsigned int reg_val)
 392 {
 393         unsigned char __iomem *addr;
 394
 395         addr = pci_addr_lin + ((index & 0xFF) << 2);
 396         writel(reg_val, addr);
 397 }
 398
 399 MODULE_AUTHOR("Froenchenko Leonid");
 400 MODULE_DESCRIPTION("IR remote driver for bt829 based TV cards");
 401 MODULE_LICENSE("GPL");
 402
 403 module_param(debug, bool, S_IRUGO | S_IWUSR);
 404 MODULE_PARM_DESC(debug, "Debug enabled or not");