]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/media/dvb/pt1/pt1.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iwlwifi: don't include iwl-dev.h from iwl-devtrace.h
[mirror_ubuntu-hirsute-kernel.git] / drivers / media / dvb / pt1 / pt1.c
CommitLineData
3d17fb1b
MCC		 1/*
2 * driver for Earthsoft PT1
3 *
4 * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
5 *
6 * based on pt1dvr - http://pt1dvr.sourceforge.jp/
7 * by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
2a20b05f 26#include <linux/vmalloc.h>
3d17fb1b
MCC		 27#include <linux/pci.h>
28#include <linux/kthread.h>
29#include <linux/freezer.h>
30
31#include "dvbdev.h"
32#include "dvb_demux.h"
33#include "dmxdev.h"
34#include "dvb_net.h"
35#include "dvb_frontend.h"
36
37#include "va1j5jf8007t.h"
38#include "va1j5jf8007s.h"
39
40#define DRIVER_NAME "earth-pt1"
41
42#define PT1_PAGE_SHIFT 12
43#define PT1_PAGE_SIZE (1 << PT1_PAGE_SHIFT)
44#define PT1_NR_UPACKETS 1024
45#define PT1_NR_BUFS 511
46
47struct pt1_buffer_page {
48 __le32 upackets[PT1_NR_UPACKETS];
49};
50
51struct pt1_table_page {
52 __le32 next_pfn;
53 __le32 buf_pfns[PT1_NR_BUFS];
54};
55
56struct pt1_buffer {
57 struct pt1_buffer_page *page;
58 dma_addr_t addr;
59};
60
61struct pt1_table {
62 struct pt1_table_page *page;
63 dma_addr_t addr;
64 struct pt1_buffer bufs[PT1_NR_BUFS];
65};
66
67#define PT1_NR_ADAPS 4
68
69struct pt1_adapter;
70
71struct pt1 {
72 struct pci_dev *pdev;
73 void __iomem *regs;
74 struct i2c_adapter i2c_adap;
75 int i2c_running;
76 struct pt1_adapter *adaps[PT1_NR_ADAPS];
77 struct pt1_table *tables;
78 struct task_struct *kthread;
79};
80
81struct pt1_adapter {
82 struct pt1 *pt1;
83 int index;
84
85 u8 *buf;
86 int upacket_count;
87 int packet_count;
88
89 struct dvb_adapter adap;
90 struct dvb_demux demux;
91 int users;
92 struct dmxdev dmxdev;
93 struct dvb_net net;
94 struct dvb_frontend *fe;
95 int (*orig_set_voltage)(struct dvb_frontend *fe,
96 fe_sec_voltage_t voltage);
97};
98
99#define pt1_printk(level, pt1, format, arg...) \
100 dev_printk(level, &(pt1)->pdev->dev, format, ##arg)
101
102static void pt1_write_reg(struct pt1 *pt1, int reg, u32 data)
103{
104 writel(data, pt1->regs + reg * 4);
105}
106
107static u32 pt1_read_reg(struct pt1 *pt1, int reg)
108{
109 return readl(pt1->regs + reg * 4);
110}
111
112static int pt1_nr_tables = 64;
113module_param_named(nr_tables, pt1_nr_tables, int, 0);
114
115static void pt1_increment_table_count(struct pt1 *pt1)
116{
117 pt1_write_reg(pt1, 0, 0x00000020);
118}
119
120static void pt1_init_table_count(struct pt1 *pt1)
121{
122 pt1_write_reg(pt1, 0, 0x00000010);
123}
124
125static void pt1_register_tables(struct pt1 *pt1, u32 first_pfn)
126{
127 pt1_write_reg(pt1, 5, first_pfn);
128 pt1_write_reg(pt1, 0, 0x0c000040);
129}
130
131static void pt1_unregister_tables(struct pt1 *pt1)
132{
133 pt1_write_reg(pt1, 0, 0x08080000);
134}
135
136static int pt1_sync(struct pt1 *pt1)
137{
138 int i;
139 for (i = 0; i < 57; i++) {
140 if (pt1_read_reg(pt1, 0) & 0x20000000)
141 return 0;
142 pt1_write_reg(pt1, 0, 0x00000008);
143 }
144 pt1_printk(KERN_ERR, pt1, "could not sync\n");
145 return -EIO;
146}
147
148static u64 pt1_identify(struct pt1 *pt1)
149{
150 int i;
151 u64 id;
152 id = 0;
153 for (i = 0; i < 57; i++) {
154 id |= (u64)(pt1_read_reg(pt1, 0) >> 30 & 1) << i;
155 pt1_write_reg(pt1, 0, 0x00000008);
156 }
157 return id;
158}
159
160static int pt1_unlock(struct pt1 *pt1)
161{
162 int i;
163 pt1_write_reg(pt1, 0, 0x00000008);
164 for (i = 0; i < 3; i++) {
165 if (pt1_read_reg(pt1, 0) & 0x80000000)
166 return 0;
167 schedule_timeout_uninterruptible((HZ + 999) / 1000);
168 }
169 pt1_printk(KERN_ERR, pt1, "could not unlock\n");
170 return -EIO;
171}
172
173static int pt1_reset_pci(struct pt1 *pt1)
174{
175 int i;
176 pt1_write_reg(pt1, 0, 0x01010000);
177 pt1_write_reg(pt1, 0, 0x01000000);
178 for (i = 0; i < 10; i++) {
179 if (pt1_read_reg(pt1, 0) & 0x00000001)
180 return 0;
181 schedule_timeout_uninterruptible((HZ + 999) / 1000);
182 }
183 pt1_printk(KERN_ERR, pt1, "could not reset PCI\n");
184 return -EIO;
185}
186
187static int pt1_reset_ram(struct pt1 *pt1)
188{
189 int i;
190 pt1_write_reg(pt1, 0, 0x02020000);
191 pt1_write_reg(pt1, 0, 0x02000000);
192 for (i = 0; i < 10; i++) {
193 if (pt1_read_reg(pt1, 0) & 0x00000002)
194 return 0;
195 schedule_timeout_uninterruptible((HZ + 999) / 1000);
196 }
197 pt1_printk(KERN_ERR, pt1, "could not reset RAM\n");
198 return -EIO;
199}
200
201static int pt1_do_enable_ram(struct pt1 *pt1)
202{
203 int i, j;
204 u32 status;
205 status = pt1_read_reg(pt1, 0) & 0x00000004;
206 pt1_write_reg(pt1, 0, 0x00000002);
207 for (i = 0; i < 10; i++) {
208 for (j = 0; j < 1024; j++) {
209 if ((pt1_read_reg(pt1, 0) & 0x00000004) != status)
210 return 0;
211 }
212 schedule_timeout_uninterruptible((HZ + 999) / 1000);
213 }
214 pt1_printk(KERN_ERR, pt1, "could not enable RAM\n");
215 return -EIO;
216}
217
218static int pt1_enable_ram(struct pt1 *pt1)
219{
220 int i, ret;
221 schedule_timeout_uninterruptible((HZ + 999) / 1000);
222 for (i = 0; i < 10; i++) {
223 ret = pt1_do_enable_ram(pt1);
224 if (ret < 0)
225 return ret;
226 }
227 return 0;
228}
229
230static void pt1_disable_ram(struct pt1 *pt1)
231{
232 pt1_write_reg(pt1, 0, 0x0b0b0000);
233}
234
235static void pt1_set_stream(struct pt1 *pt1, int index, int enabled)
236{
237 pt1_write_reg(pt1, 2, 1 << (index + 8) | enabled << index);
238}
239
240static void pt1_init_streams(struct pt1 *pt1)
241{
242 int i;
243 for (i = 0; i < PT1_NR_ADAPS; i++)
244 pt1_set_stream(pt1, i, 0);
245}
246
247static int pt1_filter(struct pt1 *pt1, struct pt1_buffer_page *page)
248{
249 u32 upacket;
250 int i;
251 int index;
252 struct pt1_adapter *adap;
253 int offset;
254 u8 *buf;
255
256 if (!page->upackets[PT1_NR_UPACKETS - 1])
257 return 0;
258
259 for (i = 0; i < PT1_NR_UPACKETS; i++) {
260 upacket = le32_to_cpu(page->upackets[i]);
261 index = (upacket >> 29) - 1;
262 if (index < 0 || index >= PT1_NR_ADAPS)
263 continue;
264
265 adap = pt1->adaps[index];
266 if (upacket >> 25 & 1)
267 adap->upacket_count = 0;
268 else if (!adap->upacket_count)
269 continue;
270
271 buf = adap->buf;
272 offset = adap->packet_count * 188 + adap->upacket_count * 3;
273 buf[offset] = upacket >> 16;
274 buf[offset + 1] = upacket >> 8;
275 if (adap->upacket_count != 62)
276 buf[offset + 2] = upacket;
277
278 if (++adap->upacket_count >= 63) {
279 adap->upacket_count = 0;
280 if (++adap->packet_count >= 21) {
281 dvb_dmx_swfilter_packets(&adap->demux, buf, 21);
282 adap->packet_count = 0;
283 }
284 }
285 }
286
287 page->upackets[PT1_NR_UPACKETS - 1] = 0;
288 return 1;
289}
290
291static int pt1_thread(void *data)
292{
293 struct pt1 *pt1;
294 int table_index;
295 int buf_index;
296 struct pt1_buffer_page *page;
297
298 pt1 = data;
299 set_freezable();
300
301 table_index = 0;
302 buf_index = 0;
303
304 while (!kthread_should_stop()) {
305 try_to_freeze();
306
307 page = pt1->tables[table_index].bufs[buf_index].page;
308 if (!pt1_filter(pt1, page)) {
309 schedule_timeout_interruptible((HZ + 999) / 1000);
310 continue;
311 }
312
313 if (++buf_index >= PT1_NR_BUFS) {
314 pt1_increment_table_count(pt1);
315 buf_index = 0;
316 if (++table_index >= pt1_nr_tables)
317 table_index = 0;
318 }
319 }
320
321 return 0;
322}
323
324static void pt1_free_page(struct pt1 *pt1, void *page, dma_addr_t addr)
325{
326 dma_free_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, page, addr);
327}
328
329static void *pt1_alloc_page(struct pt1 *pt1, dma_addr_t *addrp, u32 *pfnp)
330{
331 void *page;
332 dma_addr_t addr;
333
334 page = dma_alloc_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, &addr,
335 GFP_KERNEL);
336 if (page == NULL)
337 return NULL;
338
339 BUG_ON(addr & (PT1_PAGE_SIZE - 1));
340 BUG_ON(addr >> PT1_PAGE_SHIFT >> 31 >> 1);
341
342 *addrp = addr;
343 *pfnp = addr >> PT1_PAGE_SHIFT;
344 return page;
345}
346
347static void pt1_cleanup_buffer(struct pt1 *pt1, struct pt1_buffer *buf)
348{
349 pt1_free_page(pt1, buf->page, buf->addr);
350}
351
352static int
353pt1_init_buffer(struct pt1 *pt1, struct pt1_buffer *buf, u32 *pfnp)
354{
355 struct pt1_buffer_page *page;
356 dma_addr_t addr;
357
358 page = pt1_alloc_page(pt1, &addr, pfnp);
359 if (page == NULL)
360 return -ENOMEM;
361
362 page->upackets[PT1_NR_UPACKETS - 1] = 0;
363
364 buf->page = page;
365 buf->addr = addr;
366 return 0;
367}
368
369static void pt1_cleanup_table(struct pt1 *pt1, struct pt1_table *table)
370{
371 int i;
372
373 for (i = 0; i < PT1_NR_BUFS; i++)
374 pt1_cleanup_buffer(pt1, &table->bufs[i]);
375
376 pt1_free_page(pt1, table->page, table->addr);
377}
378
379static int
380pt1_init_table(struct pt1 *pt1, struct pt1_table *table, u32 *pfnp)
381{
382 struct pt1_table_page *page;
383 dma_addr_t addr;
384 int i, ret;
385 u32 buf_pfn;
386
387 page = pt1_alloc_page(pt1, &addr, pfnp);
388 if (page == NULL)
389 return -ENOMEM;
390
391 for (i = 0; i < PT1_NR_BUFS; i++) {
392 ret = pt1_init_buffer(pt1, &table->bufs[i], &buf_pfn);
393 if (ret < 0)
394 goto err;
395
396 page->buf_pfns[i] = cpu_to_le32(buf_pfn);
397 }
398
399 pt1_increment_table_count(pt1);
400 table->page = page;
401 table->addr = addr;
402 return 0;
403
404err:
405 while (i--)
406 pt1_cleanup_buffer(pt1, &table->bufs[i]);
407
408 pt1_free_page(pt1, page, addr);
409 return ret;
410}
411
412static void pt1_cleanup_tables(struct pt1 *pt1)
413{
414 struct pt1_table *tables;
415 int i;
416
417 tables = pt1->tables;
418 pt1_unregister_tables(pt1);
419
420 for (i = 0; i < pt1_nr_tables; i++)
421 pt1_cleanup_table(pt1, &tables[i]);
422
423 vfree(tables);
424}
425
426static int pt1_init_tables(struct pt1 *pt1)
427{
428 struct pt1_table *tables;
429 int i, ret;
430 u32 first_pfn, pfn;
431
432 tables = vmalloc(sizeof(struct pt1_table) * pt1_nr_tables);
433 if (tables == NULL)
434 return -ENOMEM;
435
436 pt1_init_table_count(pt1);
437
438 i = 0;
439 if (pt1_nr_tables) {
440 ret = pt1_init_table(pt1, &tables[0], &first_pfn);
441 if (ret)
442 goto err;
443 i++;
444 }
445
446 while (i < pt1_nr_tables) {
447 ret = pt1_init_table(pt1, &tables[i], &pfn);
448 if (ret)
449 goto err;
450 tables[i - 1].page->next_pfn = cpu_to_le32(pfn);
451 i++;
452 }
453
454 tables[pt1_nr_tables - 1].page->next_pfn = cpu_to_le32(first_pfn);
455
456 pt1_register_tables(pt1, first_pfn);
457 pt1->tables = tables;
458 return 0;
459
460err:
461 while (i--)
462 pt1_cleanup_table(pt1, &tables[i]);
463
464 vfree(tables);
465 return ret;
466}
467
468static int pt1_start_feed(struct dvb_demux_feed *feed)
469{
470 struct pt1_adapter *adap;
471 adap = container_of(feed->demux, struct pt1_adapter, demux);
472 if (!adap->users++)
473 pt1_set_stream(adap->pt1, adap->index, 1);
474 return 0;
475}
476
477static int pt1_stop_feed(struct dvb_demux_feed *feed)
478{
479 struct pt1_adapter *adap;
480 adap = container_of(feed->demux, struct pt1_adapter, demux);
481 if (!--adap->users)
482 pt1_set_stream(adap->pt1, adap->index, 0);
483 return 0;
484}
485
486static void
487pt1_set_power(struct pt1 *pt1, int power, int lnb, int reset)
488{
489 pt1_write_reg(pt1, 1, power | lnb << 1 | !reset << 3);
490}
491
492static int pt1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
493{
494 struct pt1_adapter *adap;
495 int lnb;
496
497 adap = container_of(fe->dvb, struct pt1_adapter, adap);
498
499 switch (voltage) {
500 case SEC_VOLTAGE_13: /* actually 11V */
501 lnb = 2;
502 break;
503 case SEC_VOLTAGE_18: /* actually 15V */
504 lnb = 3;
505 break;
506 case SEC_VOLTAGE_OFF:
507 lnb = 0;
508 break;
509 default:
510 return -EINVAL;
511 }
512
513 pt1_set_power(adap->pt1, 1, lnb, 0);
514
515 if (adap->orig_set_voltage)
516 return adap->orig_set_voltage(fe, voltage);
517 else
518 return 0;
519}
520
521static void pt1_free_adapter(struct pt1_adapter *adap)
522{
523 dvb_unregister_frontend(adap->fe);
524 dvb_net_release(&adap->net);
525 adap->demux.dmx.close(&adap->demux.dmx);
526 dvb_dmxdev_release(&adap->dmxdev);
527 dvb_dmx_release(&adap->demux);
528 dvb_unregister_adapter(&adap->adap);
529 free_page((unsigned long)adap->buf);
530 kfree(adap);
531}
532
533DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
534
535static struct pt1_adapter *
536pt1_alloc_adapter(struct pt1 *pt1, struct dvb_frontend *fe)
537{
538 struct pt1_adapter *adap;
539 void *buf;
540 struct dvb_adapter *dvb_adap;
541 struct dvb_demux *demux;
542 struct dmxdev *dmxdev;
543 int ret;
544
545 adap = kzalloc(sizeof(struct pt1_adapter), GFP_KERNEL);
546 if (!adap) {
547 ret = -ENOMEM;
548 goto err;
549 }
550
551 adap->pt1 = pt1;
552
553 adap->orig_set_voltage = fe->ops.set_voltage;
554 fe->ops.set_voltage = pt1_set_voltage;
555
556 buf = (u8 *)__get_free_page(GFP_KERNEL);
557 if (!buf) {
558 ret = -ENOMEM;
559 goto err_kfree;
560 }
561
562 adap->buf = buf;
563 adap->upacket_count = 0;
564 adap->packet_count = 0;
565
566 dvb_adap = &adap->adap;
567 dvb_adap->priv = adap;
568 ret = dvb_register_adapter(dvb_adap, DRIVER_NAME, THIS_MODULE,
569 &pt1->pdev->dev, adapter_nr);
570 if (ret < 0)
571 goto err_free_page;
572
573 demux = &adap->demux;
574 demux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
575 demux->priv = adap;
576 demux->feednum = 256;
577 demux->filternum = 256;
578 demux->start_feed = pt1_start_feed;
579 demux->stop_feed = pt1_stop_feed;
580 demux->write_to_decoder = NULL;
581 ret = dvb_dmx_init(demux);
582 if (ret < 0)
583 goto err_unregister_adapter;
584
585 dmxdev = &adap->dmxdev;
586 dmxdev->filternum = 256;
587 dmxdev->demux = &demux->dmx;
588 dmxdev->capabilities = 0;
589 ret = dvb_dmxdev_init(dmxdev, dvb_adap);
590 if (ret < 0)
591 goto err_dmx_release;
592
593 dvb_net_init(dvb_adap, &adap->net, &demux->dmx);
594
595 ret = dvb_register_frontend(dvb_adap, fe);
596 if (ret < 0)
597 goto err_net_release;
598 adap->fe = fe;
599
600 return adap;
601
602err_net_release:
603 dvb_net_release(&adap->net);
604 adap->demux.dmx.close(&adap->demux.dmx);
605 dvb_dmxdev_release(&adap->dmxdev);
606err_dmx_release:
607 dvb_dmx_release(demux);
608err_unregister_adapter:
609 dvb_unregister_adapter(dvb_adap);
610err_free_page:
611 free_page((unsigned long)buf);
612err_kfree:
613 kfree(adap);
614err:
615 return ERR_PTR(ret);
616}
617
618static void pt1_cleanup_adapters(struct pt1 *pt1)
619{
620 int i;
621 for (i = 0; i < PT1_NR_ADAPS; i++)
622 pt1_free_adapter(pt1->adaps[i]);
623}
624
625struct pt1_config {
626 struct va1j5jf8007s_config va1j5jf8007s_config;
627 struct va1j5jf8007t_config va1j5jf8007t_config;
628};
629
630static const struct pt1_config pt1_configs[2] = {
631 {
632 { .demod_address = 0x1b },
633 { .demod_address = 0x1a },
634 }, {
635 { .demod_address = 0x19 },
636 { .demod_address = 0x18 },
637 },
638};
639
640static int pt1_init_adapters(struct pt1 *pt1)
641{
642 int i, j;
643 struct i2c_adapter *i2c_adap;
644 const struct pt1_config *config;
645 struct dvb_frontend *fe[4];
646 struct pt1_adapter *adap;
647 int ret;
648
649 i = 0;
650 j = 0;
651
652 i2c_adap = &pt1->i2c_adap;
653 do {
654 config = &pt1_configs[i / 2];
655
656 fe[i] = va1j5jf8007s_attach(&config->va1j5jf8007s_config,
657 i2c_adap);
658 if (!fe[i]) {
659 ret = -ENODEV; /* This does not sound nice... */
660 goto err;
661 }
662 i++;
663
664 fe[i] = va1j5jf8007t_attach(&config->va1j5jf8007t_config,
665 i2c_adap);
666 if (!fe[i]) {
667 ret = -ENODEV;
668 goto err;
669 }
670 i++;
671
672 ret = va1j5jf8007s_prepare(fe[i - 2]);
673 if (ret < 0)
674 goto err;
675
676 ret = va1j5jf8007t_prepare(fe[i - 1]);
677 if (ret < 0)
678 goto err;
679
680 } while (i < 4);
681
682 do {
683 adap = pt1_alloc_adapter(pt1, fe[j]);
684 if (IS_ERR(adap))
685 goto err;
686 adap->index = j;
687 pt1->adaps[j] = adap;
688 } while (++j < 4);
689
690 return 0;
691
692err:
693 while (i-- > j)
694 fe[i]->ops.release(fe[i]);
695
696 while (j--)
697 pt1_free_adapter(pt1->adaps[j]);
698
699 return ret;
700}
701
702static void pt1_i2c_emit(struct pt1 *pt1, int addr, int busy, int read_enable,
703 int clock, int data, int next_addr)
704{
705 pt1_write_reg(pt1, 4, addr << 18 | busy << 13 | read_enable << 12 |
706 !clock << 11 | !data << 10 | next_addr);
707}
708
709static void pt1_i2c_write_bit(struct pt1 *pt1, int addr, int *addrp, int data)
710{
711 pt1_i2c_emit(pt1, addr, 1, 0, 0, data, addr + 1);
712 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, data, addr + 2);
713 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, data, addr + 3);
714 *addrp = addr + 3;
715}
716
717static void pt1_i2c_read_bit(struct pt1 *pt1, int addr, int *addrp)
718{
719 pt1_i2c_emit(pt1, addr, 1, 0, 0, 1, addr + 1);
720 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 1, addr + 2);
721 pt1_i2c_emit(pt1, addr + 2, 1, 1, 1, 1, addr + 3);
722 pt1_i2c_emit(pt1, addr + 3, 1, 0, 0, 1, addr + 4);
723 *addrp = addr + 4;
724}
725
726static void pt1_i2c_write_byte(struct pt1 *pt1, int addr, int *addrp, int data)
727{
728 int i;
729 for (i = 0; i < 8; i++)
730 pt1_i2c_write_bit(pt1, addr, &addr, data >> (7 - i) & 1);
731 pt1_i2c_write_bit(pt1, addr, &addr, 1);
732 *addrp = addr;
733}
734
735static void pt1_i2c_read_byte(struct pt1 *pt1, int addr, int *addrp, int last)
736{
737 int i;
738 for (i = 0; i < 8; i++)
739 pt1_i2c_read_bit(pt1, addr, &addr);
740 pt1_i2c_write_bit(pt1, addr, &addr, last);
741 *addrp = addr;
742}
743
744static void pt1_i2c_prepare(struct pt1 *pt1, int addr, int *addrp)
745{
746 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
747 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
748 pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, 0, addr + 3);
749 *addrp = addr + 3;
750}
751
752static void
753pt1_i2c_write_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
754{
755 int i;
756 pt1_i2c_prepare(pt1, addr, &addr);
757 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1);
758 for (i = 0; i < msg->len; i++)
759 pt1_i2c_write_byte(pt1, addr, &addr, msg->buf[i]);
760 *addrp = addr;
761}
762
763static void
764pt1_i2c_read_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
765{
766 int i;
767 pt1_i2c_prepare(pt1, addr, &addr);
768 pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1 | 1);
769 for (i = 0; i < msg->len; i++)
770 pt1_i2c_read_byte(pt1, addr, &addr, i == msg->len - 1);
771 *addrp = addr;
772}
773
774static int pt1_i2c_end(struct pt1 *pt1, int addr)
775{
776 pt1_i2c_emit(pt1, addr, 1, 0, 0, 0, addr + 1);
777 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
778 pt1_i2c_emit(pt1, addr + 2, 1, 0, 1, 1, 0);
779
780 pt1_write_reg(pt1, 0, 0x00000004);
781 do {
782 if (signal_pending(current))
783 return -EINTR;
784 schedule_timeout_interruptible((HZ + 999) / 1000);
785 } while (pt1_read_reg(pt1, 0) & 0x00000080);
786 return 0;
787}
788
789static void pt1_i2c_begin(struct pt1 *pt1, int *addrp)
790{
791 int addr;
792 addr = 0;
793
794 pt1_i2c_emit(pt1, addr, 0, 0, 1, 1, addr /* itself */);
795 addr = addr + 1;
796
797 if (!pt1->i2c_running) {
798 pt1_i2c_emit(pt1, addr, 1, 0, 1, 1, addr + 1);
799 pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
800 addr = addr + 2;
801 pt1->i2c_running = 1;
802 }
803 *addrp = addr;
804}
805
806static int pt1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
807{
808 struct pt1 *pt1;
809 int i;
810 struct i2c_msg *msg, *next_msg;
811 int addr, ret;
812 u16 len;
813 u32 word;
814
815 pt1 = i2c_get_adapdata(adap);
816
817 for (i = 0; i < num; i++) {
818 msg = &msgs[i];
819 if (msg->flags & I2C_M_RD)
820 return -ENOTSUPP;
821
822 if (i + 1 < num)
823 next_msg = &msgs[i + 1];
824 else
825 next_msg = NULL;
826
827 if (next_msg && next_msg->flags & I2C_M_RD) {
828 i++;
829
830 len = next_msg->len;
831 if (len > 4)
832 return -ENOTSUPP;
833
834 pt1_i2c_begin(pt1, &addr);
835 pt1_i2c_write_msg(pt1, addr, &addr, msg);
836 pt1_i2c_read_msg(pt1, addr, &addr, next_msg);
837 ret = pt1_i2c_end(pt1, addr);
838 if (ret < 0)
839 return ret;
840
841 word = pt1_read_reg(pt1, 2);
842 while (len--) {
843 next_msg->buf[len] = word;
844 word >>= 8;
845 }
846 } else {
847 pt1_i2c_begin(pt1, &addr);
848 pt1_i2c_write_msg(pt1, addr, &addr, msg);
849 ret = pt1_i2c_end(pt1, addr);
850 if (ret < 0)
851 return ret;
852 }
853 }
854
855 return num;
856}
857
858static u32 pt1_i2c_func(struct i2c_adapter *adap)
859{
860 return I2C_FUNC_I2C;
861}
862
863static const struct i2c_algorithm pt1_i2c_algo = {
864 .master_xfer = pt1_i2c_xfer,
865 .functionality = pt1_i2c_func,
866};
867
868static void pt1_i2c_wait(struct pt1 *pt1)
869{
870 int i;
871 for (i = 0; i < 128; i++)
872 pt1_i2c_emit(pt1, 0, 0, 0, 1, 1, 0);
873}
874
875static void pt1_i2c_init(struct pt1 *pt1)
876{
877 int i;
878 for (i = 0; i < 1024; i++)
879 pt1_i2c_emit(pt1, i, 0, 0, 1, 1, 0);
880}
881
882static void __devexit pt1_remove(struct pci_dev *pdev)
883{
884 struct pt1 *pt1;
885 void __iomem *regs;
886
887 pt1 = pci_get_drvdata(pdev);
888 regs = pt1->regs;
889
890 kthread_stop(pt1->kthread);
891 pt1_cleanup_tables(pt1);
892 pt1_cleanup_adapters(pt1);
893 pt1_disable_ram(pt1);
894 pt1_set_power(pt1, 0, 0, 1);
895 i2c_del_adapter(&pt1->i2c_adap);
896 pci_set_drvdata(pdev, NULL);
897 kfree(pt1);
898 pci_iounmap(pdev, regs);
899 pci_release_regions(pdev);
900 pci_disable_device(pdev);
901}
902
903static int __devinit
904pt1_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
905{
906 int ret;
907 void __iomem *regs;
908 struct pt1 *pt1;
909 struct i2c_adapter *i2c_adap;
910 struct task_struct *kthread;
911
912 ret = pci_enable_device(pdev);
913 if (ret < 0)
914 goto err;
915
84d6ae43 916 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
3d17fb1b
MCC		 917 if (ret < 0)
918 goto err_pci_disable_device;
919
920 pci_set_master(pdev);
921
922 ret = pci_request_regions(pdev, DRIVER_NAME);
923 if (ret < 0)
924 goto err_pci_disable_device;
925
926 regs = pci_iomap(pdev, 0, 0);
927 if (!regs) {
928 ret = -EIO;
929 goto err_pci_release_regions;
930 }
931
932 pt1 = kzalloc(sizeof(struct pt1), GFP_KERNEL);
933 if (!pt1) {
934 ret = -ENOMEM;
935 goto err_pci_iounmap;
936 }
937
938 pt1->pdev = pdev;
939 pt1->regs = regs;
940 pci_set_drvdata(pdev, pt1);
941
942 i2c_adap = &pt1->i2c_adap;
943 i2c_adap->class = I2C_CLASS_TV_DIGITAL;
944 i2c_adap->algo = &pt1_i2c_algo;
945 i2c_adap->algo_data = NULL;
946 i2c_adap->dev.parent = &pdev->dev;
947 i2c_set_adapdata(i2c_adap, pt1);
948 ret = i2c_add_adapter(i2c_adap);
949 if (ret < 0)
950 goto err_kfree;
951
952 pt1_set_power(pt1, 0, 0, 1);
953
954 pt1_i2c_init(pt1);
955 pt1_i2c_wait(pt1);
956
957 ret = pt1_sync(pt1);
958 if (ret < 0)
959 goto err_i2c_del_adapter;
960
961 pt1_identify(pt1);
962
963 ret = pt1_unlock(pt1);
964 if (ret < 0)
965 goto err_i2c_del_adapter;
966
967 ret = pt1_reset_pci(pt1);
968 if (ret < 0)
969 goto err_i2c_del_adapter;
970
971 ret = pt1_reset_ram(pt1);
972 if (ret < 0)
973 goto err_i2c_del_adapter;
974
975 ret = pt1_enable_ram(pt1);
976 if (ret < 0)
977 goto err_i2c_del_adapter;
978
979 pt1_init_streams(pt1);
980
981 pt1_set_power(pt1, 1, 0, 1);
982 schedule_timeout_uninterruptible((HZ + 49) / 50);
983
984 pt1_set_power(pt1, 1, 0, 0);
985 schedule_timeout_uninterruptible((HZ + 999) / 1000);
986
987 ret = pt1_init_adapters(pt1);
988 if (ret < 0)
989 goto err_pt1_disable_ram;
990
991 ret = pt1_init_tables(pt1);
992 if (ret < 0)
993 goto err_pt1_cleanup_adapters;
994
995 kthread = kthread_run(pt1_thread, pt1, "pt1");
996 if (IS_ERR(kthread)) {
997 ret = PTR_ERR(kthread);
998 goto err_pt1_cleanup_tables;
999 }
1000
1001 pt1->kthread = kthread;
1002 return 0;
1003
1004err_pt1_cleanup_tables:
1005 pt1_cleanup_tables(pt1);
1006err_pt1_cleanup_adapters:
1007 pt1_cleanup_adapters(pt1);
1008err_pt1_disable_ram:
1009 pt1_disable_ram(pt1);
1010 pt1_set_power(pt1, 0, 0, 1);
1011err_i2c_del_adapter:
1012 i2c_del_adapter(i2c_adap);
1013err_kfree:
1014 pci_set_drvdata(pdev, NULL);
1015 kfree(pt1);
1016err_pci_iounmap:
1017 pci_iounmap(pdev, regs);
1018err_pci_release_regions:
1019 pci_release_regions(pdev);
1020err_pci_disable_device:
1021 pci_disable_device(pdev);
1022err:
1023 return ret;
1024
1025}
1026
1027static struct pci_device_id pt1_id_table[] = {
1028 { PCI_DEVICE(0x10ee, 0x211a) },
1029 { },
1030};
1031MODULE_DEVICE_TABLE(pci, pt1_id_table);
1032
1033static struct pci_driver pt1_driver = {
1034 .name = DRIVER_NAME,
1035 .probe = pt1_probe,
1036 .remove = __devexit_p(pt1_remove),
1037 .id_table = pt1_id_table,
1038};
1039
1040
1041static int __init pt1_init(void)
1042{
1043 return pci_register_driver(&pt1_driver);
1044}
1045
1046
1047static void __exit pt1_cleanup(void)
1048{
1049 pci_unregister_driver(&pt1_driver);
1050}
1051
1052module_init(pt1_init);
1053module_exit(pt1_cleanup);
1054
1055MODULE_AUTHOR("Takahito HIRANO <hiranotaka@zng.info>");
1056MODULE_DESCRIPTION("Earthsoft PT1 Driver");
1057MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror