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
do_pci_probe(void)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
atir_add_to_buf(void * data,struct lirc_buffer * buf)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
atir_set_use_inc(void * data)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
atir_set_use_dec(void * data)112 static void atir_set_use_dec(void *data)
113 {
114 dev_dbg(atir_driver.dev, "driver is closed\n");
115 }
116
init_module(void)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
cleanup_module(void)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
atir_init_start(void)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
cycle_delay(int cycle)188 static void cycle_delay(int cycle)
189 {
190 udelay(WAIT_CYCLE*cycle);
191 }
192
193
poll_main(void)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
do_i2c_start(void)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
do_i2c_stop(void)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
seems_wr_byte(unsigned char value)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
seems_rd_byte(void)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
do_set_bits(unsigned char new_bits)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
do_get_bits(void)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
read_index(unsigned char index)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
write_index(unsigned char index,unsigned int reg_val)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");
405