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 #define dprintk(fmt, args...) \
60 do { \
61 if (debug) \
62 printk(KERN_DEBUG DRIVER_NAME ": "fmt, ## args); \
63 } while (0)
64
65 static int atir_minor;
66 static phys_addr_t pci_addr_phys;
67 static unsigned char __iomem *pci_addr_lin;
68
69 static struct lirc_driver atir_driver;
70
do_pci_probe(void)71 static struct pci_dev *do_pci_probe(void)
72 {
73 struct pci_dev *my_dev;
74
75 my_dev = pci_get_device(PCI_VENDOR_ID_ATI,
76 PCI_DEVICE_ID_ATI_264VT, NULL);
77 if (my_dev) {
78 pr_err("Using device: %s\n", pci_name(my_dev));
79 pci_addr_phys = 0;
80 if (my_dev->resource[0].flags & IORESOURCE_MEM) {
81 pci_addr_phys = my_dev->resource[0].start;
82 pr_info("memory at %pa\n", &pci_addr_phys);
83 }
84 if (pci_addr_phys == 0) {
85 pr_err("no memory resource ?\n");
86 pci_dev_put(my_dev);
87 return NULL;
88 }
89 } else {
90 pr_err("pci_probe failed\n");
91 return NULL;
92 }
93 return my_dev;
94 }
95
atir_add_to_buf(void * data,struct lirc_buffer * buf)96 static int atir_add_to_buf(void *data, struct lirc_buffer *buf)
97 {
98 unsigned char key;
99 int status;
100
101 status = poll_main();
102 key = (status >> 8) & 0xFF;
103 if (status & 0xFF) {
104 dprintk("reading key %02X\n", key);
105 lirc_buffer_write(buf, &key);
106 return 0;
107 }
108 return -ENODATA;
109 }
110
atir_set_use_inc(void * data)111 static int atir_set_use_inc(void *data)
112 {
113 dprintk("driver is opened\n");
114 return 0;
115 }
116
atir_set_use_dec(void * data)117 static void atir_set_use_dec(void *data)
118 {
119 dprintk("driver is closed\n");
120 }
121
init_module(void)122 int init_module(void)
123 {
124 struct pci_dev *pdev;
125 int rc;
126
127 pdev = do_pci_probe();
128 if (pdev == NULL)
129 return -ENODEV;
130
131 rc = pci_enable_device(pdev);
132 if (rc)
133 goto err_put_dev;
134
135 if (!atir_init_start()) {
136 rc = -ENODEV;
137 goto err_disable;
138 }
139
140 strcpy(atir_driver.name, "ATIR");
141 atir_driver.minor = -1;
142 atir_driver.code_length = 8;
143 atir_driver.sample_rate = 10;
144 atir_driver.data = NULL;
145 atir_driver.add_to_buf = atir_add_to_buf;
146 atir_driver.set_use_inc = atir_set_use_inc;
147 atir_driver.set_use_dec = atir_set_use_dec;
148 atir_driver.dev = &pdev->dev;
149 atir_driver.owner = THIS_MODULE;
150
151 atir_minor = lirc_register_driver(&atir_driver);
152 if (atir_minor < 0) {
153 pr_err("failed to register driver!\n");
154 rc = atir_minor;
155 goto err_unmap;
156 }
157 dprintk("driver is registered on minor %d\n", atir_minor);
158
159 return 0;
160
161 err_unmap:
162 iounmap(pci_addr_lin);
163 err_disable:
164 pci_disable_device(pdev);
165 err_put_dev:
166 pci_dev_put(pdev);
167 return rc;
168 }
169
170
cleanup_module(void)171 void cleanup_module(void)
172 {
173 struct pci_dev *pdev = to_pci_dev(atir_driver.dev);
174
175 lirc_unregister_driver(atir_minor);
176 iounmap(pci_addr_lin);
177 pci_disable_device(pdev);
178 pci_dev_put(pdev);
179 }
180
181
atir_init_start(void)182 static int atir_init_start(void)
183 {
184 pci_addr_lin = ioremap(pci_addr_phys + DATA_PCI_OFF, 0x400);
185 if (!pci_addr_lin) {
186 pr_info("pci mem must be mapped\n");
187 return 0;
188 }
189 return 1;
190 }
191
cycle_delay(int cycle)192 static void cycle_delay(int cycle)
193 {
194 udelay(WAIT_CYCLE*cycle);
195 }
196
197
poll_main(void)198 static int poll_main(void)
199 {
200 unsigned char status_high, status_low;
201
202 do_i2c_start();
203
204 seems_wr_byte(0xAA);
205 seems_wr_byte(0x01);
206
207 do_i2c_start();
208
209 seems_wr_byte(0xAB);
210
211 status_low = seems_rd_byte();
212 status_high = seems_rd_byte();
213
214 do_i2c_stop();
215
216 return (status_high << 8) | status_low;
217 }
218
do_i2c_start(void)219 static void do_i2c_start(void)
220 {
221 do_set_bits(3);
222 cycle_delay(4);
223
224 do_set_bits(1);
225 cycle_delay(7);
226
227 do_set_bits(0);
228 cycle_delay(2);
229 }
230
do_i2c_stop(void)231 static void do_i2c_stop(void)
232 {
233 unsigned char bits;
234
235 bits = do_get_bits() & 0xFD;
236 do_set_bits(bits);
237 cycle_delay(1);
238
239 bits |= 1;
240 do_set_bits(bits);
241 cycle_delay(2);
242
243 bits |= 2;
244 do_set_bits(bits);
245 bits = 3;
246 do_set_bits(bits);
247 cycle_delay(2);
248 }
249
seems_wr_byte(unsigned char value)250 static void seems_wr_byte(unsigned char value)
251 {
252 int i;
253 unsigned char reg;
254
255 reg = do_get_bits();
256 for (i = 0; i < 8; i++) {
257 if (value & 0x80)
258 reg |= 0x02;
259 else
260 reg &= 0xFD;
261
262 do_set_bits(reg);
263 cycle_delay(1);
264
265 reg |= 1;
266 do_set_bits(reg);
267 cycle_delay(1);
268
269 reg &= 0xFE;
270 do_set_bits(reg);
271 cycle_delay(1);
272 value <<= 1;
273 }
274 cycle_delay(2);
275
276 reg |= 2;
277 do_set_bits(reg);
278
279 reg |= 1;
280 do_set_bits(reg);
281
282 cycle_delay(1);
283 do_get_bits();
284
285 reg &= 0xFE;
286 do_set_bits(reg);
287 cycle_delay(3);
288 }
289
seems_rd_byte(void)290 static unsigned char seems_rd_byte(void)
291 {
292 int i;
293 int rd_byte;
294 unsigned char bits_2, bits_1;
295
296 bits_1 = do_get_bits() | 2;
297 do_set_bits(bits_1);
298
299 rd_byte = 0;
300 for (i = 0; i < 8; i++) {
301 bits_1 &= 0xFE;
302 do_set_bits(bits_1);
303 cycle_delay(2);
304
305 bits_1 |= 1;
306 do_set_bits(bits_1);
307 cycle_delay(1);
308
309 bits_2 = do_get_bits();
310 if (bits_2 & 2)
311 rd_byte |= 1;
312
313 rd_byte <<= 1;
314 }
315
316 bits_1 = 0;
317 if (bits_2 == 0)
318 bits_1 |= 2;
319
320 do_set_bits(bits_1);
321 cycle_delay(2);
322
323 bits_1 |= 1;
324 do_set_bits(bits_1);
325 cycle_delay(3);
326
327 bits_1 &= 0xFE;
328 do_set_bits(bits_1);
329 cycle_delay(2);
330
331 rd_byte >>= 1;
332 rd_byte &= 0xFF;
333 return rd_byte;
334 }
335
do_set_bits(unsigned char new_bits)336 static void do_set_bits(unsigned char new_bits)
337 {
338 int reg_val;
339
340 reg_val = read_index(0x34);
341 if (new_bits & 2) {
342 reg_val &= 0xFFFFFFDF;
343 reg_val |= 1;
344 } else {
345 reg_val &= 0xFFFFFFFE;
346 reg_val |= 0x20;
347 }
348 reg_val |= 0x10;
349 write_index(0x34, reg_val);
350
351 reg_val = read_index(0x31);
352 if (new_bits & 1)
353 reg_val |= 0x1000000;
354 else
355 reg_val &= 0xFEFFFFFF;
356
357 reg_val |= 0x8000000;
358 write_index(0x31, reg_val);
359 }
360
do_get_bits(void)361 static unsigned char do_get_bits(void)
362 {
363 unsigned char bits;
364 int reg_val;
365
366 reg_val = read_index(0x34);
367 reg_val |= 0x10;
368 reg_val &= 0xFFFFFFDF;
369 write_index(0x34, reg_val);
370
371 reg_val = read_index(0x34);
372 bits = 0;
373 if (reg_val & 8)
374 bits |= 2;
375 else
376 bits &= 0xFD;
377
378 reg_val = read_index(0x31);
379 if (reg_val & 0x1000000)
380 bits |= 1;
381 else
382 bits &= 0xFE;
383
384 return bits;
385 }
386
read_index(unsigned char index)387 static unsigned int read_index(unsigned char index)
388 {
389 unsigned char __iomem *addr;
390 /* addr = pci_addr_lin + DATA_PCI_OFF + ((index & 0xFF) << 2); */
391 addr = pci_addr_lin + ((index & 0xFF) << 2);
392 return readl(addr);
393 }
394
write_index(unsigned char index,unsigned int reg_val)395 static void write_index(unsigned char index, unsigned int reg_val)
396 {
397 unsigned char __iomem *addr;
398
399 addr = pci_addr_lin + ((index & 0xFF) << 2);
400 writel(reg_val, addr);
401 }
402
403 MODULE_AUTHOR("Froenchenko Leonid");
404 MODULE_DESCRIPTION("IR remote driver for bt829 based TV cards");
405 MODULE_LICENSE("GPL");
406
407 module_param(debug, bool, S_IRUGO | S_IWUSR);
408 MODULE_PARM_DESC(debug, "Debug enabled or not");
409