1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * dm1105.c - driver for DVB cards based on SDMC DM1105 PCI chip
5 * Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by>
9 #include <linux/i2c-algo-bit.h>
10 #include <linux/init.h>
11 #include <linux/interrupt.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/proc_fs.h>
15 #include <linux/pci.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/slab.h>
18 #include <media/rc-core.h>
20 #include <media/demux.h>
21 #include <media/dmxdev.h>
22 #include <media/dvb_demux.h>
23 #include <media/dvb_frontend.h>
24 #include <media/dvb_net.h>
25 #include <media/dvbdev.h>
37 #define MODULE_NAME "dm1105"
41 #define DM1105_BOARD_NOAUTO UNSET
42 #define DM1105_BOARD_UNKNOWN 0
43 #define DM1105_BOARD_DVBWORLD_2002 1
44 #define DM1105_BOARD_DVBWORLD_2004 2
45 #define DM1105_BOARD_AXESS_DM05 3
46 #define DM1105_BOARD_UNBRANDED_I2C_ON_GPIO 4
48 /* ----------------------------------------------- */
52 #ifndef PCI_VENDOR_ID_TRIGEM
53 #define PCI_VENDOR_ID_TRIGEM 0x109f
55 #ifndef PCI_VENDOR_ID_AXESS
56 #define PCI_VENDOR_ID_AXESS 0x195d
58 #ifndef PCI_DEVICE_ID_DM1105
59 #define PCI_DEVICE_ID_DM1105 0x036f
61 #ifndef PCI_DEVICE_ID_DW2002
62 #define PCI_DEVICE_ID_DW2002 0x2002
64 #ifndef PCI_DEVICE_ID_DW2004
65 #define PCI_DEVICE_ID_DW2004 0x2004
67 #ifndef PCI_DEVICE_ID_DM05
68 #define PCI_DEVICE_ID_DM05 0x1105
70 /* ----------------------------------------------- */
71 /* sdmc dm1105 registers */
74 #define DM1105_TSCTR 0x00
75 #define DM1105_DTALENTH 0x04
78 #define DM1105_GPIOVAL 0x08
79 #define DM1105_GPIOCTR 0x0c
81 /* PID serial number */
82 #define DM1105_PIDN 0x10
84 /* Odd-even secret key select */
85 #define DM1105_CWSEL 0x14
87 /* Host Command Interface */
88 #define DM1105_HOST_CTR 0x18
89 #define DM1105_HOST_AD 0x1c
92 #define DM1105_CR 0x30
93 #define DM1105_RST 0x34
94 #define DM1105_STADR 0x38
95 #define DM1105_RLEN 0x3c
96 #define DM1105_WRP 0x40
97 #define DM1105_INTCNT 0x44
98 #define DM1105_INTMAK 0x48
99 #define DM1105_INTSTS 0x4c
102 #define DM1105_ODD 0x50
103 #define DM1105_EVEN 0x58
106 #define DM1105_PID 0x60
109 #define DM1105_IRCTR 0x64
110 #define DM1105_IRMODE 0x68
111 #define DM1105_SYSTEMCODE 0x6c
112 #define DM1105_IRCODE 0x70
115 #define DM1105_ENCRYPT 0x74
116 #define DM1105_VER 0x7c
119 #define DM1105_I2CCTR 0x80
120 #define DM1105_I2CSTS 0x81
121 #define DM1105_I2CDAT 0x82
122 #define DM1105_I2C_RA 0x83
123 /* ----------------------------------------------- */
124 /* Interrupt Mask Bits */
126 #define INTMAK_TSIRQM 0x01
127 #define INTMAK_HIRQM 0x04
128 #define INTMAK_IRM 0x08
129 #define INTMAK_ALLMASK (INTMAK_TSIRQM | \
132 #define INTMAK_NONEMASK 0x00
134 /* Interrupt Status Bits */
135 #define INTSTS_TSIRQ 0x01
136 #define INTSTS_HIRQ 0x04
137 #define INTSTS_IR 0x08
139 /* IR Control Bits */
140 #define DM1105_IR_EN 0x01
141 #define DM1105_SYS_CHK 0x02
142 #define DM1105_REP_FLG 0x08
145 #define IIC_24C01_addr 0xa0
146 /* Max board count */
147 #define DM1105_MAX 0x04
149 #define DRIVER_NAME "dm1105"
150 #define DM1105_I2C_GPIO_NAME "dm1105-gpio"
152 #define DM1105_DMA_PACKETS 47
153 #define DM1105_DMA_PACKET_LENGTH (128*4)
154 #define DM1105_DMA_BYTES (128 * 4 * DM1105_DMA_PACKETS)
157 #define GPIO08 (1 << 8)
158 #define GPIO13 (1 << 13)
159 #define GPIO14 (1 << 14)
160 #define GPIO15 (1 << 15)
161 #define GPIO16 (1 << 16)
162 #define GPIO17 (1 << 17)
163 #define GPIO_ALL 0x03ffff
165 /* GPIO's for LNB power control */
166 #define DM1105_LNB_MASK (GPIO_ALL & ~(GPIO14 | GPIO13))
167 #define DM1105_LNB_OFF GPIO17
168 #define DM1105_LNB_13V (GPIO16 | GPIO08)
169 #define DM1105_LNB_18V GPIO08
171 /* GPIO's for LNB power control for Axess DM05 */
172 #define DM05_LNB_MASK (GPIO_ALL & ~(GPIO14 | GPIO13))
173 #define DM05_LNB_OFF GPIO17/* actually 13v */
174 #define DM05_LNB_13V GPIO17
175 #define DM05_LNB_18V (GPIO17 | GPIO16)
177 /* GPIO's for LNB power control for unbranded with I2C on GPIO */
178 #define UNBR_LNB_MASK (GPIO17 | GPIO16)
179 #define UNBR_LNB_OFF 0
180 #define UNBR_LNB_13V GPIO17
181 #define UNBR_LNB_18V (GPIO17 | GPIO16)
183 static unsigned int card
[] = {[0 ... 3] = UNSET
};
184 module_param_array(card
, int, NULL
, 0444);
185 MODULE_PARM_DESC(card
, "card type");
188 module_param(ir_debug
, int, 0644);
189 MODULE_PARM_DESC(ir_debug
, "enable debugging information for IR decoding");
191 static unsigned int dm1105_devcount
;
193 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
195 struct dm1105_board
{
198 u32 mask
, off
, v13
, v18
;
200 u32 gpio_scl
, gpio_sda
;
203 struct dm1105_subid
{
209 static const struct dm1105_board dm1105_boards
[] = {
210 [DM1105_BOARD_UNKNOWN
] = {
211 .name
= "UNKNOWN/GENERIC",
213 .mask
= DM1105_LNB_MASK
,
214 .off
= DM1105_LNB_OFF
,
215 .v13
= DM1105_LNB_13V
,
216 .v18
= DM1105_LNB_18V
,
219 [DM1105_BOARD_DVBWORLD_2002
] = {
220 .name
= "DVBWorld PCI 2002",
222 .mask
= DM1105_LNB_MASK
,
223 .off
= DM1105_LNB_OFF
,
224 .v13
= DM1105_LNB_13V
,
225 .v18
= DM1105_LNB_18V
,
228 [DM1105_BOARD_DVBWORLD_2004
] = {
229 .name
= "DVBWorld PCI 2004",
231 .mask
= DM1105_LNB_MASK
,
232 .off
= DM1105_LNB_OFF
,
233 .v13
= DM1105_LNB_13V
,
234 .v18
= DM1105_LNB_18V
,
237 [DM1105_BOARD_AXESS_DM05
] = {
238 .name
= "Axess/EasyTv DM05",
240 .mask
= DM05_LNB_MASK
,
246 [DM1105_BOARD_UNBRANDED_I2C_ON_GPIO
] = {
247 .name
= "Unbranded DM1105 with i2c on GPIOs",
249 .mask
= UNBR_LNB_MASK
,
259 static const struct dm1105_subid dm1105_subids
[] = {
263 .card
= DM1105_BOARD_DVBWORLD_2002
,
267 .card
= DM1105_BOARD_DVBWORLD_2002
,
271 .card
= DM1105_BOARD_DVBWORLD_2004
,
275 .card
= DM1105_BOARD_DVBWORLD_2004
,
279 .card
= DM1105_BOARD_AXESS_DM05
,
283 static void dm1105_card_list(struct pci_dev
*pci
)
287 if (0 == pci
->subsystem_vendor
&&
288 0 == pci
->subsystem_device
) {
290 "dm1105: Your board has no valid PCI Subsystem ID\n"
291 "dm1105: and thus can't be autodetected\n"
292 "dm1105: Please pass card=<n> insmod option to\n"
293 "dm1105: workaround that. Redirect complaints to\n"
294 "dm1105: the vendor of the TV card. Best regards,\n"
298 "dm1105: Your board isn't known (yet) to the driver.\n"
299 "dm1105: You can try to pick one of the existing\n"
300 "dm1105: card configs via card=<n> insmod option.\n"
301 "dm1105: Updating to the latest version might help\n"
302 "dm1105: as well.\n");
304 printk(KERN_ERR
"Here is a list of valid choices for the card=<n> insmod option:\n");
305 for (i
= 0; i
< ARRAY_SIZE(dm1105_boards
); i
++)
306 printk(KERN_ERR
"dm1105: card=%d -> %s\n",
307 i
, dm1105_boards
[i
].name
);
310 /* infrared remote control */
314 struct work_struct work
;
320 struct pci_dev
*pdev
;
327 struct dmx_frontend hw_frontend
;
328 struct dmx_frontend mem_frontend
;
329 struct dmxdev dmxdev
;
330 struct dvb_adapter dvb_adapter
;
331 struct dvb_demux demux
;
332 struct dvb_frontend
*fe
;
333 struct dvb_net dvbnet
;
334 unsigned int full_ts_users
;
335 unsigned int boardnr
;
339 struct i2c_adapter i2c_adap
;
340 struct i2c_adapter i2c_bb_adap
;
341 struct i2c_algo_bit_data i2c_bit
;
344 struct work_struct work
;
345 struct workqueue_struct
*wq
;
350 unsigned char *ts_buf
;
354 unsigned int PacketErrorCount
;
359 #define dm_io_mem(reg) ((unsigned long)(&dev->io_mem[reg]))
361 #define dm_readb(reg) inb(dm_io_mem(reg))
362 #define dm_writeb(reg, value) outb((value), (dm_io_mem(reg)))
364 #define dm_readw(reg) inw(dm_io_mem(reg))
365 #define dm_writew(reg, value) outw((value), (dm_io_mem(reg)))
367 #define dm_readl(reg) inl(dm_io_mem(reg))
368 #define dm_writel(reg, value) outl((value), (dm_io_mem(reg)))
370 #define dm_andorl(reg, mask, value) \
371 outl((inl(dm_io_mem(reg)) & ~(mask)) |\
372 ((value) & (mask)), (dm_io_mem(reg)))
374 #define dm_setl(reg, bit) dm_andorl((reg), (bit), (bit))
375 #define dm_clearl(reg, bit) dm_andorl((reg), (bit), 0)
377 /* The chip has 18 GPIOs. In HOST mode GPIO's used as 15 bit address lines,
378 so we can use only 3 GPIO's from GPIO15 to GPIO17.
379 Here I don't check whether HOST is enebled as it is not implemented yet.
381 static void dm1105_gpio_set(struct dm1105_dev
*dev
, u32 mask
)
383 if (mask
& 0xfffc0000)
384 printk(KERN_ERR
"%s: Only 18 GPIO's are allowed\n", __func__
);
386 if (mask
& 0x0003ffff)
387 dm_setl(DM1105_GPIOVAL
, mask
& 0x0003ffff);
391 static void dm1105_gpio_clear(struct dm1105_dev
*dev
, u32 mask
)
393 if (mask
& 0xfffc0000)
394 printk(KERN_ERR
"%s: Only 18 GPIO's are allowed\n", __func__
);
396 if (mask
& 0x0003ffff)
397 dm_clearl(DM1105_GPIOVAL
, mask
& 0x0003ffff);
401 static void dm1105_gpio_andor(struct dm1105_dev
*dev
, u32 mask
, u32 val
)
403 if (mask
& 0xfffc0000)
404 printk(KERN_ERR
"%s: Only 18 GPIO's are allowed\n", __func__
);
406 if (mask
& 0x0003ffff)
407 dm_andorl(DM1105_GPIOVAL
, mask
& 0x0003ffff, val
);
411 static u32
dm1105_gpio_get(struct dm1105_dev
*dev
, u32 mask
)
413 if (mask
& 0xfffc0000)
414 printk(KERN_ERR
"%s: Only 18 GPIO's are allowed\n", __func__
);
416 if (mask
& 0x0003ffff)
417 return dm_readl(DM1105_GPIOVAL
) & mask
& 0x0003ffff;
422 static void dm1105_gpio_enable(struct dm1105_dev
*dev
, u32 mask
, int asoutput
)
424 if (mask
& 0xfffc0000)
425 printk(KERN_ERR
"%s: Only 18 GPIO's are allowed\n", __func__
);
427 if ((mask
& 0x0003ffff) && asoutput
)
428 dm_clearl(DM1105_GPIOCTR
, mask
& 0x0003ffff);
429 else if ((mask
& 0x0003ffff) && !asoutput
)
430 dm_setl(DM1105_GPIOCTR
, mask
& 0x0003ffff);
434 static void dm1105_setline(struct dm1105_dev
*dev
, u32 line
, int state
)
437 dm1105_gpio_enable(dev
, line
, 0);
439 dm1105_gpio_enable(dev
, line
, 1);
440 dm1105_gpio_clear(dev
, line
);
444 static void dm1105_setsda(void *data
, int state
)
446 struct dm1105_dev
*dev
= data
;
448 dm1105_setline(dev
, dm1105_boards
[dev
->boardnr
].gpio_sda
, state
);
451 static void dm1105_setscl(void *data
, int state
)
453 struct dm1105_dev
*dev
= data
;
455 dm1105_setline(dev
, dm1105_boards
[dev
->boardnr
].gpio_scl
, state
);
458 static int dm1105_getsda(void *data
)
460 struct dm1105_dev
*dev
= data
;
462 return dm1105_gpio_get(dev
, dm1105_boards
[dev
->boardnr
].gpio_sda
)
466 static int dm1105_getscl(void *data
)
468 struct dm1105_dev
*dev
= data
;
470 return dm1105_gpio_get(dev
, dm1105_boards
[dev
->boardnr
].gpio_scl
)
474 static int dm1105_i2c_xfer(struct i2c_adapter
*i2c_adap
,
475 struct i2c_msg
*msgs
, int num
)
477 struct dm1105_dev
*dev
;
479 int addr
, rc
, i
, j
, k
, len
, byte
, data
;
482 dev
= i2c_adap
->algo_data
;
483 for (i
= 0; i
< num
; i
++) {
484 dm_writeb(DM1105_I2CCTR
, 0x00);
485 if (msgs
[i
].flags
& I2C_M_RD
) {
487 addr
= msgs
[i
].addr
<< 1;
489 dm_writeb(DM1105_I2CDAT
, addr
);
490 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
491 dm_writeb(DM1105_I2CDAT
+ byte
+ 1, 0);
493 dm_writeb(DM1105_I2CCTR
, 0x81 + msgs
[i
].len
);
494 for (j
= 0; j
< 55; j
++) {
496 status
= dm_readb(DM1105_I2CSTS
);
497 if ((status
& 0xc0) == 0x40)
503 for (byte
= 0; byte
< msgs
[i
].len
; byte
++) {
504 rc
= dm_readb(DM1105_I2CDAT
+ byte
+ 1);
507 msgs
[i
].buf
[byte
] = rc
;
509 } else if ((msgs
[i
].buf
[0] == 0xf7) && (msgs
[i
].addr
== 0x55)) {
510 /* prepared for cx24116 firmware */
511 /* Write in small blocks */
512 len
= msgs
[i
].len
- 1;
515 dm_writeb(DM1105_I2CDAT
, msgs
[i
].addr
<< 1);
516 dm_writeb(DM1105_I2CDAT
+ 1, 0xf7);
517 for (byte
= 0; byte
< (len
> 48 ? 48 : len
); byte
++) {
518 data
= msgs
[i
].buf
[k
+ byte
];
519 dm_writeb(DM1105_I2CDAT
+ byte
+ 2, data
);
521 dm_writeb(DM1105_I2CCTR
, 0x82 + (len
> 48 ? 48 : len
));
522 for (j
= 0; j
< 25; j
++) {
524 status
= dm_readb(DM1105_I2CSTS
);
525 if ((status
& 0xc0) == 0x40)
537 dm_writeb(DM1105_I2CDAT
, msgs
[i
].addr
<< 1);
538 for (byte
= 0; byte
< msgs
[i
].len
; byte
++) {
539 data
= msgs
[i
].buf
[byte
];
540 dm_writeb(DM1105_I2CDAT
+ byte
+ 1, data
);
542 dm_writeb(DM1105_I2CCTR
, 0x81 + msgs
[i
].len
);
543 for (j
= 0; j
< 25; j
++) {
545 status
= dm_readb(DM1105_I2CSTS
);
546 if ((status
& 0xc0) == 0x40)
559 static u32
functionality(struct i2c_adapter
*adap
)
564 static const struct i2c_algorithm dm1105_algo
= {
565 .master_xfer
= dm1105_i2c_xfer
,
566 .functionality
= functionality
,
569 static inline struct dm1105_dev
*feed_to_dm1105_dev(struct dvb_demux_feed
*feed
)
571 return container_of(feed
->demux
, struct dm1105_dev
, demux
);
574 static inline struct dm1105_dev
*frontend_to_dm1105_dev(struct dvb_frontend
*fe
)
576 return container_of(fe
->dvb
, struct dm1105_dev
, dvb_adapter
);
579 static int dm1105_set_voltage(struct dvb_frontend
*fe
,
580 enum fe_sec_voltage voltage
)
582 struct dm1105_dev
*dev
= frontend_to_dm1105_dev(fe
);
584 dm1105_gpio_enable(dev
, dm1105_boards
[dev
->boardnr
].lnb
.mask
, 1);
585 if (voltage
== SEC_VOLTAGE_18
)
586 dm1105_gpio_andor(dev
,
587 dm1105_boards
[dev
->boardnr
].lnb
.mask
,
588 dm1105_boards
[dev
->boardnr
].lnb
.v18
);
589 else if (voltage
== SEC_VOLTAGE_13
)
590 dm1105_gpio_andor(dev
,
591 dm1105_boards
[dev
->boardnr
].lnb
.mask
,
592 dm1105_boards
[dev
->boardnr
].lnb
.v13
);
594 dm1105_gpio_andor(dev
,
595 dm1105_boards
[dev
->boardnr
].lnb
.mask
,
596 dm1105_boards
[dev
->boardnr
].lnb
.off
);
601 static void dm1105_set_dma_addr(struct dm1105_dev
*dev
)
603 dm_writel(DM1105_STADR
, (__force u32
)cpu_to_le32(dev
->dma_addr
));
606 static int dm1105_dma_map(struct dm1105_dev
*dev
)
608 dev
->ts_buf
= pci_alloc_consistent(dev
->pdev
,
609 6 * DM1105_DMA_BYTES
,
615 static void dm1105_dma_unmap(struct dm1105_dev
*dev
)
617 pci_free_consistent(dev
->pdev
,
618 6 * DM1105_DMA_BYTES
,
623 static void dm1105_enable_irqs(struct dm1105_dev
*dev
)
625 dm_writeb(DM1105_INTMAK
, INTMAK_ALLMASK
);
626 dm_writeb(DM1105_CR
, 1);
629 static void dm1105_disable_irqs(struct dm1105_dev
*dev
)
631 dm_writeb(DM1105_INTMAK
, INTMAK_IRM
);
632 dm_writeb(DM1105_CR
, 0);
635 static int dm1105_start_feed(struct dvb_demux_feed
*f
)
637 struct dm1105_dev
*dev
= feed_to_dm1105_dev(f
);
639 if (dev
->full_ts_users
++ == 0)
640 dm1105_enable_irqs(dev
);
645 static int dm1105_stop_feed(struct dvb_demux_feed
*f
)
647 struct dm1105_dev
*dev
= feed_to_dm1105_dev(f
);
649 if (--dev
->full_ts_users
== 0)
650 dm1105_disable_irqs(dev
);
655 /* ir work handler */
656 static void dm1105_emit_key(struct work_struct
*work
)
658 struct infrared
*ir
= container_of(work
, struct infrared
, work
);
659 u32 ircom
= ir
->ir_command
;
663 printk(KERN_INFO
"%s: received byte 0x%04x\n", __func__
, ircom
);
665 data
= (ircom
>> 8) & 0x7f;
667 /* FIXME: UNKNOWN because we don't generate a full NEC scancode (yet?) */
668 rc_keydown(ir
->dev
, RC_PROTO_UNKNOWN
, data
, 0);
672 static void dm1105_dmx_buffer(struct work_struct
*work
)
674 struct dm1105_dev
*dev
= container_of(work
, struct dm1105_dev
, work
);
675 unsigned int nbpackets
;
676 u32 oldwrp
= dev
->wrp
;
677 u32 nextwrp
= dev
->nextwrp
;
679 if (!((dev
->ts_buf
[oldwrp
] == 0x47) &&
680 (dev
->ts_buf
[oldwrp
+ 188] == 0x47) &&
681 (dev
->ts_buf
[oldwrp
+ 188 * 2] == 0x47))) {
682 dev
->PacketErrorCount
++;
683 /* bad packet found */
684 if ((dev
->PacketErrorCount
>= 2) &&
685 (dev
->dmarst
== 0)) {
686 dm_writeb(DM1105_RST
, 1);
688 dev
->PacketErrorCount
= 0;
694 if (nextwrp
< oldwrp
) {
695 memcpy(dev
->ts_buf
+ dev
->buffer_size
, dev
->ts_buf
, nextwrp
);
696 nbpackets
= ((dev
->buffer_size
- oldwrp
) + nextwrp
) / 188;
698 nbpackets
= (nextwrp
- oldwrp
) / 188;
701 dvb_dmx_swfilter_packets(&dev
->demux
, &dev
->ts_buf
[oldwrp
], nbpackets
);
704 static irqreturn_t
dm1105_irq(int irq
, void *dev_id
)
706 struct dm1105_dev
*dev
= dev_id
;
708 /* Read-Write INSTS Ack's Interrupt for DM1105 chip 16.03.2008 */
709 unsigned int intsts
= dm_readb(DM1105_INTSTS
);
710 dm_writeb(DM1105_INTSTS
, intsts
);
714 case (INTSTS_TSIRQ
| INTSTS_IR
):
715 dev
->nextwrp
= dm_readl(DM1105_WRP
) - dm_readl(DM1105_STADR
);
716 queue_work(dev
->wq
, &dev
->work
);
719 dev
->ir
.ir_command
= dm_readl(DM1105_IRCODE
);
720 schedule_work(&dev
->ir
.work
);
727 static int dm1105_ir_init(struct dm1105_dev
*dm1105
)
732 dev
= rc_allocate_device(RC_DRIVER_SCANCODE
);
736 snprintf(dm1105
->ir
.input_phys
, sizeof(dm1105
->ir
.input_phys
),
737 "pci-%s/ir0", pci_name(dm1105
->pdev
));
739 dev
->driver_name
= MODULE_NAME
;
740 dev
->map_name
= RC_MAP_DM1105_NEC
;
741 dev
->device_name
= "DVB on-card IR receiver";
742 dev
->input_phys
= dm1105
->ir
.input_phys
;
743 dev
->input_id
.bustype
= BUS_PCI
;
744 dev
->input_id
.version
= 1;
745 if (dm1105
->pdev
->subsystem_vendor
) {
746 dev
->input_id
.vendor
= dm1105
->pdev
->subsystem_vendor
;
747 dev
->input_id
.product
= dm1105
->pdev
->subsystem_device
;
749 dev
->input_id
.vendor
= dm1105
->pdev
->vendor
;
750 dev
->input_id
.product
= dm1105
->pdev
->device
;
752 dev
->dev
.parent
= &dm1105
->pdev
->dev
;
754 INIT_WORK(&dm1105
->ir
.work
, dm1105_emit_key
);
756 err
= rc_register_device(dev
);
762 dm1105
->ir
.dev
= dev
;
766 static void dm1105_ir_exit(struct dm1105_dev
*dm1105
)
768 rc_unregister_device(dm1105
->ir
.dev
);
771 static int dm1105_hw_init(struct dm1105_dev
*dev
)
773 dm1105_disable_irqs(dev
);
775 dm_writeb(DM1105_HOST_CTR
, 0);
778 dm_writeb(DM1105_DTALENTH
, 188);
779 /*TS_STRT TS_VALP MSBFIRST TS_MODE ALPAS TSPES*/
780 dm_writew(DM1105_TSCTR
, 0xc10a);
782 /* map DMA and set address */
784 dm1105_set_dma_addr(dev
);
786 dm_writel(DM1105_RLEN
, 5 * DM1105_DMA_BYTES
);
787 dm_writeb(DM1105_INTCNT
, 47);
789 /* IR NEC mode enable */
790 dm_writeb(DM1105_IRCTR
, (DM1105_IR_EN
| DM1105_SYS_CHK
));
791 dm_writeb(DM1105_IRMODE
, 0);
792 dm_writew(DM1105_SYSTEMCODE
, 0);
797 static void dm1105_hw_exit(struct dm1105_dev
*dev
)
799 dm1105_disable_irqs(dev
);
802 dm_writeb(DM1105_IRCTR
, 0);
803 dm_writeb(DM1105_INTMAK
, INTMAK_NONEMASK
);
805 dm1105_dma_unmap(dev
);
808 static const struct stv0299_config sharp_z0194a_config
= {
809 .demod_address
= 0x68,
810 .inittab
= sharp_z0194a_inittab
,
814 .lock_output
= STV0299_LOCKOUTPUT_1
,
815 .volt13_op0_op1
= STV0299_VOLT13_OP1
,
817 .set_symbol_rate
= sharp_z0194a_set_symbol_rate
,
820 static struct stv0288_config earda_config
= {
821 .demod_address
= 0x68,
825 static struct si21xx_config serit_config
= {
826 .demod_address
= 0x68,
831 static struct cx24116_config serit_sp2633_config
= {
832 .demod_address
= 0x55,
835 static struct ds3000_config dvbworld_ds3000_config
= {
836 .demod_address
= 0x68,
839 static struct ts2020_config dvbworld_ts2020_config
= {
840 .tuner_address
= 0x60,
844 static int frontend_init(struct dm1105_dev
*dev
)
848 switch (dev
->boardnr
) {
849 case DM1105_BOARD_UNBRANDED_I2C_ON_GPIO
:
850 dm1105_gpio_enable(dev
, GPIO15
, 1);
851 dm1105_gpio_clear(dev
, GPIO15
);
853 dm1105_gpio_set(dev
, GPIO15
);
855 dev
->fe
= dvb_attach(
856 stv0299_attach
, &sharp_z0194a_config
,
859 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
860 dvb_attach(dvb_pll_attach
, dev
->fe
, 0x60,
861 &dev
->i2c_bb_adap
, DVB_PLL_OPERA1
);
865 dev
->fe
= dvb_attach(
866 stv0288_attach
, &earda_config
,
869 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
870 dvb_attach(stb6000_attach
, dev
->fe
, 0x61,
875 dev
->fe
= dvb_attach(
876 si21xx_attach
, &serit_config
,
879 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
881 case DM1105_BOARD_DVBWORLD_2004
:
882 dev
->fe
= dvb_attach(
883 cx24116_attach
, &serit_sp2633_config
,
886 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
890 dev
->fe
= dvb_attach(
891 ds3000_attach
, &dvbworld_ds3000_config
,
894 dvb_attach(ts2020_attach
, dev
->fe
,
895 &dvbworld_ts2020_config
, &dev
->i2c_adap
);
896 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
900 case DM1105_BOARD_DVBWORLD_2002
:
901 case DM1105_BOARD_AXESS_DM05
:
903 dev
->fe
= dvb_attach(
904 stv0299_attach
, &sharp_z0194a_config
,
907 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
908 dvb_attach(dvb_pll_attach
, dev
->fe
, 0x60,
909 &dev
->i2c_adap
, DVB_PLL_OPERA1
);
913 dev
->fe
= dvb_attach(
914 stv0288_attach
, &earda_config
,
917 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
918 dvb_attach(stb6000_attach
, dev
->fe
, 0x61,
923 dev
->fe
= dvb_attach(
924 si21xx_attach
, &serit_config
,
927 dev
->fe
->ops
.set_voltage
= dm1105_set_voltage
;
932 dev_err(&dev
->pdev
->dev
, "could not attach frontend\n");
936 ret
= dvb_register_frontend(&dev
->dvb_adapter
, dev
->fe
);
938 if (dev
->fe
->ops
.release
)
939 dev
->fe
->ops
.release(dev
->fe
);
947 static void dm1105_read_mac(struct dm1105_dev
*dev
, u8
*mac
)
949 static u8 command
[1] = { 0x28 };
951 struct i2c_msg msg
[] = {
953 .addr
= IIC_24C01_addr
>> 1,
958 .addr
= IIC_24C01_addr
>> 1,
965 dm1105_i2c_xfer(&dev
->i2c_adap
, msg
, 2);
966 dev_info(&dev
->pdev
->dev
, "MAC %pM\n", mac
);
969 static int dm1105_probe(struct pci_dev
*pdev
,
970 const struct pci_device_id
*ent
)
972 struct dm1105_dev
*dev
;
973 struct dvb_adapter
*dvb_adapter
;
974 struct dvb_demux
*dvbdemux
;
975 struct dmx_demux
*dmx
;
979 if (dm1105_devcount
>= ARRAY_SIZE(card
))
982 dev
= kzalloc(sizeof(struct dm1105_dev
), GFP_KERNEL
);
987 dev
->nr
= dm1105_devcount
;
988 dev
->boardnr
= UNSET
;
989 if (card
[dev
->nr
] < ARRAY_SIZE(dm1105_boards
))
990 dev
->boardnr
= card
[dev
->nr
];
991 for (i
= 0; UNSET
== dev
->boardnr
&&
992 i
< ARRAY_SIZE(dm1105_subids
); i
++)
993 if (pdev
->subsystem_vendor
==
994 dm1105_subids
[i
].subvendor
&&
995 pdev
->subsystem_device
==
996 dm1105_subids
[i
].subdevice
)
997 dev
->boardnr
= dm1105_subids
[i
].card
;
999 if (UNSET
== dev
->boardnr
) {
1000 dev
->boardnr
= DM1105_BOARD_UNKNOWN
;
1001 dm1105_card_list(pdev
);
1006 dev
->buffer_size
= 5 * DM1105_DMA_BYTES
;
1007 dev
->PacketErrorCount
= 0;
1010 ret
= pci_enable_device(pdev
);
1014 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
1016 goto err_pci_disable_device
;
1018 pci_set_master(pdev
);
1020 ret
= pci_request_regions(pdev
, DRIVER_NAME
);
1022 goto err_pci_disable_device
;
1024 dev
->io_mem
= pci_iomap(pdev
, 0, pci_resource_len(pdev
, 0));
1027 goto err_pci_release_regions
;
1030 spin_lock_init(&dev
->lock
);
1031 pci_set_drvdata(pdev
, dev
);
1033 ret
= dm1105_hw_init(dev
);
1035 goto err_pci_iounmap
;
1038 i2c_set_adapdata(&dev
->i2c_adap
, dev
);
1039 strscpy(dev
->i2c_adap
.name
, DRIVER_NAME
, sizeof(dev
->i2c_adap
.name
));
1040 dev
->i2c_adap
.owner
= THIS_MODULE
;
1041 dev
->i2c_adap
.dev
.parent
= &pdev
->dev
;
1042 dev
->i2c_adap
.algo
= &dm1105_algo
;
1043 dev
->i2c_adap
.algo_data
= dev
;
1044 ret
= i2c_add_adapter(&dev
->i2c_adap
);
1047 goto err_dm1105_hw_exit
;
1049 i2c_set_adapdata(&dev
->i2c_bb_adap
, dev
);
1050 strscpy(dev
->i2c_bb_adap
.name
, DM1105_I2C_GPIO_NAME
,
1051 sizeof(dev
->i2c_bb_adap
.name
));
1052 dev
->i2c_bb_adap
.owner
= THIS_MODULE
;
1053 dev
->i2c_bb_adap
.dev
.parent
= &pdev
->dev
;
1054 dev
->i2c_bb_adap
.algo_data
= &dev
->i2c_bit
;
1055 dev
->i2c_bit
.data
= dev
;
1056 dev
->i2c_bit
.setsda
= dm1105_setsda
;
1057 dev
->i2c_bit
.setscl
= dm1105_setscl
;
1058 dev
->i2c_bit
.getsda
= dm1105_getsda
;
1059 dev
->i2c_bit
.getscl
= dm1105_getscl
;
1060 dev
->i2c_bit
.udelay
= 10;
1061 dev
->i2c_bit
.timeout
= 10;
1063 /* Raise SCL and SDA */
1064 dm1105_setsda(dev
, 1);
1065 dm1105_setscl(dev
, 1);
1067 ret
= i2c_bit_add_bus(&dev
->i2c_bb_adap
);
1069 goto err_i2c_del_adapter
;
1072 ret
= dvb_register_adapter(&dev
->dvb_adapter
, DRIVER_NAME
,
1073 THIS_MODULE
, &pdev
->dev
, adapter_nr
);
1075 goto err_i2c_del_adapters
;
1077 dvb_adapter
= &dev
->dvb_adapter
;
1079 dm1105_read_mac(dev
, dvb_adapter
->proposed_mac
);
1081 dvbdemux
= &dev
->demux
;
1082 dvbdemux
->filternum
= 256;
1083 dvbdemux
->feednum
= 256;
1084 dvbdemux
->start_feed
= dm1105_start_feed
;
1085 dvbdemux
->stop_feed
= dm1105_stop_feed
;
1086 dvbdemux
->dmx
.capabilities
= (DMX_TS_FILTERING
|
1087 DMX_SECTION_FILTERING
| DMX_MEMORY_BASED_FILTERING
);
1088 ret
= dvb_dmx_init(dvbdemux
);
1090 goto err_dvb_unregister_adapter
;
1092 dmx
= &dvbdemux
->dmx
;
1093 dev
->dmxdev
.filternum
= 256;
1094 dev
->dmxdev
.demux
= dmx
;
1095 dev
->dmxdev
.capabilities
= 0;
1097 ret
= dvb_dmxdev_init(&dev
->dmxdev
, dvb_adapter
);
1099 goto err_dvb_dmx_release
;
1101 dev
->hw_frontend
.source
= DMX_FRONTEND_0
;
1103 ret
= dmx
->add_frontend(dmx
, &dev
->hw_frontend
);
1105 goto err_dvb_dmxdev_release
;
1107 dev
->mem_frontend
.source
= DMX_MEMORY_FE
;
1109 ret
= dmx
->add_frontend(dmx
, &dev
->mem_frontend
);
1111 goto err_remove_hw_frontend
;
1113 ret
= dmx
->connect_frontend(dmx
, &dev
->hw_frontend
);
1115 goto err_remove_mem_frontend
;
1117 ret
= dvb_net_init(dvb_adapter
, &dev
->dvbnet
, dmx
);
1119 goto err_disconnect_frontend
;
1121 ret
= frontend_init(dev
);
1125 dm1105_ir_init(dev
);
1127 INIT_WORK(&dev
->work
, dm1105_dmx_buffer
);
1128 sprintf(dev
->wqn
, "%s/%d", dvb_adapter
->name
, dvb_adapter
->num
);
1129 dev
->wq
= create_singlethread_workqueue(dev
->wqn
);
1135 ret
= request_irq(pdev
->irq
, dm1105_irq
, IRQF_SHARED
,
1143 destroy_workqueue(dev
->wq
);
1145 dvb_net_release(&dev
->dvbnet
);
1146 err_disconnect_frontend
:
1147 dmx
->disconnect_frontend(dmx
);
1148 err_remove_mem_frontend
:
1149 dmx
->remove_frontend(dmx
, &dev
->mem_frontend
);
1150 err_remove_hw_frontend
:
1151 dmx
->remove_frontend(dmx
, &dev
->hw_frontend
);
1152 err_dvb_dmxdev_release
:
1153 dvb_dmxdev_release(&dev
->dmxdev
);
1154 err_dvb_dmx_release
:
1155 dvb_dmx_release(dvbdemux
);
1156 err_dvb_unregister_adapter
:
1157 dvb_unregister_adapter(dvb_adapter
);
1158 err_i2c_del_adapters
:
1159 i2c_del_adapter(&dev
->i2c_bb_adap
);
1160 err_i2c_del_adapter
:
1161 i2c_del_adapter(&dev
->i2c_adap
);
1163 dm1105_hw_exit(dev
);
1165 pci_iounmap(pdev
, dev
->io_mem
);
1166 err_pci_release_regions
:
1167 pci_release_regions(pdev
);
1168 err_pci_disable_device
:
1169 pci_disable_device(pdev
);
1175 static void dm1105_remove(struct pci_dev
*pdev
)
1177 struct dm1105_dev
*dev
= pci_get_drvdata(pdev
);
1178 struct dvb_adapter
*dvb_adapter
= &dev
->dvb_adapter
;
1179 struct dvb_demux
*dvbdemux
= &dev
->demux
;
1180 struct dmx_demux
*dmx
= &dvbdemux
->dmx
;
1182 dm1105_ir_exit(dev
);
1184 dvb_net_release(&dev
->dvbnet
);
1186 dvb_unregister_frontend(dev
->fe
);
1188 dmx
->disconnect_frontend(dmx
);
1189 dmx
->remove_frontend(dmx
, &dev
->mem_frontend
);
1190 dmx
->remove_frontend(dmx
, &dev
->hw_frontend
);
1191 dvb_dmxdev_release(&dev
->dmxdev
);
1192 dvb_dmx_release(dvbdemux
);
1193 dvb_unregister_adapter(dvb_adapter
);
1194 i2c_del_adapter(&dev
->i2c_adap
);
1196 dm1105_hw_exit(dev
);
1197 free_irq(pdev
->irq
, dev
);
1198 pci_iounmap(pdev
, dev
->io_mem
);
1199 pci_release_regions(pdev
);
1200 pci_disable_device(pdev
);
1205 static const struct pci_device_id dm1105_id_table
[] = {
1207 .vendor
= PCI_VENDOR_ID_TRIGEM
,
1208 .device
= PCI_DEVICE_ID_DM1105
,
1209 .subvendor
= PCI_ANY_ID
,
1210 .subdevice
= PCI_ANY_ID
,
1212 .vendor
= PCI_VENDOR_ID_AXESS
,
1213 .device
= PCI_DEVICE_ID_DM05
,
1214 .subvendor
= PCI_ANY_ID
,
1215 .subdevice
= PCI_ANY_ID
,
1221 MODULE_DEVICE_TABLE(pci
, dm1105_id_table
);
1223 static struct pci_driver dm1105_driver
= {
1224 .name
= DRIVER_NAME
,
1225 .id_table
= dm1105_id_table
,
1226 .probe
= dm1105_probe
,
1227 .remove
= dm1105_remove
,
1230 module_pci_driver(dm1105_driver
);
1232 MODULE_AUTHOR("Igor M. Liplianin <liplianin@me.by>");
1233 MODULE_DESCRIPTION("SDMC DM1105 DVB driver");
1234 MODULE_LICENSE("GPL");