1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * SMI PCIe driver for DVBSky cards.
5 * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
11 #include "m88rs6000t.h"
15 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
17 static int smi_hw_init(struct smi_dev *dev)
19 u32 port_mux, port_ctrl, int_stat;
22 port_mux = smi_read(MUX_MODE_CTRL);
23 port_mux &= ~(rbPaMSMask);
24 port_mux |= rbPaMSDtvNoGpio;
25 port_mux &= ~(rbPbMSMask);
26 port_mux |= rbPbMSDtvNoGpio;
27 port_mux &= ~(0x0f0000);
29 smi_write(MUX_MODE_CTRL, port_mux);
31 /* set DTV register.*/
33 port_ctrl = smi_read(VIDEO_CTRL_STATUS_A);
35 smi_write(VIDEO_CTRL_STATUS_A, port_ctrl);
36 port_ctrl = smi_read(MPEG2_CTRL_A);
39 smi_write(MPEG2_CTRL_A, port_ctrl);
41 port_ctrl = smi_read(VIDEO_CTRL_STATUS_B);
43 smi_write(VIDEO_CTRL_STATUS_B, port_ctrl);
44 port_ctrl = smi_read(MPEG2_CTRL_B);
47 smi_write(MPEG2_CTRL_B, port_ctrl);
49 /* disable and clear interrupt.*/
50 smi_write(MSI_INT_ENA_CLR, ALL_INT);
51 int_stat = smi_read(MSI_INT_STATUS);
52 smi_write(MSI_INT_STATUS_CLR, int_stat);
55 smi_clear(PERIPHERAL_CTRL, 0x0303);
57 smi_set(PERIPHERAL_CTRL, 0x0101);
62 static void smi_i2c_cfg(struct smi_dev *dev, u32 sw_ctl)
66 dwCtrl = smi_read(sw_ctl);
67 dwCtrl &= ~0x18; /* disable output.*/
68 dwCtrl |= 0x21; /* reset and software mode.*/
71 smi_write(sw_ctl, dwCtrl);
73 dwCtrl = smi_read(sw_ctl);
75 smi_write(sw_ctl, dwCtrl);
78 static void smi_i2c_setsda(struct smi_dev *dev, int state, u32 sw_ctl)
82 smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
84 smi_clear(sw_ctl, SW_I2C_MSK_DAT_OUT);
86 smi_set(sw_ctl, SW_I2C_MSK_DAT_EN);
90 static void smi_i2c_setscl(void *data, int state, u32 sw_ctl)
92 struct smi_dev *dev = data;
96 smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
98 smi_clear(sw_ctl, SW_I2C_MSK_CLK_OUT);
100 smi_set(sw_ctl, SW_I2C_MSK_CLK_EN);
104 static int smi_i2c_getsda(void *data, u32 sw_ctl)
106 struct smi_dev *dev = data;
108 smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
110 return (smi_read(sw_ctl) & SW_I2C_MSK_DAT_IN) ? 1 : 0;
113 static int smi_i2c_getscl(void *data, u32 sw_ctl)
115 struct smi_dev *dev = data;
117 smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
119 return (smi_read(sw_ctl) & SW_I2C_MSK_CLK_IN) ? 1 : 0;
122 static void smi_i2c0_setsda(void *data, int state)
124 struct smi_dev *dev = data;
126 smi_i2c_setsda(dev, state, I2C_A_SW_CTL);
129 static void smi_i2c0_setscl(void *data, int state)
131 struct smi_dev *dev = data;
133 smi_i2c_setscl(dev, state, I2C_A_SW_CTL);
136 static int smi_i2c0_getsda(void *data)
138 struct smi_dev *dev = data;
140 return smi_i2c_getsda(dev, I2C_A_SW_CTL);
143 static int smi_i2c0_getscl(void *data)
145 struct smi_dev *dev = data;
147 return smi_i2c_getscl(dev, I2C_A_SW_CTL);
150 static void smi_i2c1_setsda(void *data, int state)
152 struct smi_dev *dev = data;
154 smi_i2c_setsda(dev, state, I2C_B_SW_CTL);
157 static void smi_i2c1_setscl(void *data, int state)
159 struct smi_dev *dev = data;
161 smi_i2c_setscl(dev, state, I2C_B_SW_CTL);
164 static int smi_i2c1_getsda(void *data)
166 struct smi_dev *dev = data;
168 return smi_i2c_getsda(dev, I2C_B_SW_CTL);
171 static int smi_i2c1_getscl(void *data)
173 struct smi_dev *dev = data;
175 return smi_i2c_getscl(dev, I2C_B_SW_CTL);
178 static int smi_i2c_init(struct smi_dev *dev)
183 smi_i2c_cfg(dev, I2C_A_SW_CTL);
184 i2c_set_adapdata(&dev->i2c_bus[0], dev);
185 strscpy(dev->i2c_bus[0].name, "SMI-I2C0", sizeof(dev->i2c_bus[0].name));
186 dev->i2c_bus[0].owner = THIS_MODULE;
187 dev->i2c_bus[0].dev.parent = &dev->pci_dev->dev;
188 dev->i2c_bus[0].algo_data = &dev->i2c_bit[0];
189 dev->i2c_bit[0].data = dev;
190 dev->i2c_bit[0].setsda = smi_i2c0_setsda;
191 dev->i2c_bit[0].setscl = smi_i2c0_setscl;
192 dev->i2c_bit[0].getsda = smi_i2c0_getsda;
193 dev->i2c_bit[0].getscl = smi_i2c0_getscl;
194 dev->i2c_bit[0].udelay = 12;
195 dev->i2c_bit[0].timeout = 10;
196 /* Raise SCL and SDA */
197 smi_i2c0_setsda(dev, 1);
198 smi_i2c0_setscl(dev, 1);
200 ret = i2c_bit_add_bus(&dev->i2c_bus[0]);
205 smi_i2c_cfg(dev, I2C_B_SW_CTL);
206 i2c_set_adapdata(&dev->i2c_bus[1], dev);
207 strscpy(dev->i2c_bus[1].name, "SMI-I2C1", sizeof(dev->i2c_bus[1].name));
208 dev->i2c_bus[1].owner = THIS_MODULE;
209 dev->i2c_bus[1].dev.parent = &dev->pci_dev->dev;
210 dev->i2c_bus[1].algo_data = &dev->i2c_bit[1];
211 dev->i2c_bit[1].data = dev;
212 dev->i2c_bit[1].setsda = smi_i2c1_setsda;
213 dev->i2c_bit[1].setscl = smi_i2c1_setscl;
214 dev->i2c_bit[1].getsda = smi_i2c1_getsda;
215 dev->i2c_bit[1].getscl = smi_i2c1_getscl;
216 dev->i2c_bit[1].udelay = 12;
217 dev->i2c_bit[1].timeout = 10;
218 /* Raise SCL and SDA */
219 smi_i2c1_setsda(dev, 1);
220 smi_i2c1_setscl(dev, 1);
222 ret = i2c_bit_add_bus(&dev->i2c_bus[1]);
224 i2c_del_adapter(&dev->i2c_bus[0]);
229 static void smi_i2c_exit(struct smi_dev *dev)
231 i2c_del_adapter(&dev->i2c_bus[0]);
232 i2c_del_adapter(&dev->i2c_bus[1]);
235 static int smi_read_eeprom(struct i2c_adapter *i2c, u16 reg, u8 *data, u16 size)
238 u8 b0[2] = { (reg >> 8) & 0xff, reg & 0xff };
240 struct i2c_msg msg[] = {
241 { .addr = 0x50, .flags = 0,
242 .buf = b0, .len = 2 },
243 { .addr = 0x50, .flags = I2C_M_RD,
244 .buf = data, .len = size }
247 ret = i2c_transfer(i2c, msg, 2);
250 dev_err(&i2c->dev, "%s: reg=0x%x (error=%d)\n",
257 /* ts port interrupt operations */
258 static void smi_port_disableInterrupt(struct smi_port *port)
260 struct smi_dev *dev = port->dev;
262 smi_write(MSI_INT_ENA_CLR,
263 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
266 static void smi_port_enableInterrupt(struct smi_port *port)
268 struct smi_dev *dev = port->dev;
270 smi_write(MSI_INT_ENA_SET,
271 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
274 static void smi_port_clearInterrupt(struct smi_port *port)
276 struct smi_dev *dev = port->dev;
278 smi_write(MSI_INT_STATUS_CLR,
279 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
282 /* tasklet handler: DMA data to dmx.*/
283 static void smi_dma_xfer(struct tasklet_struct *t)
285 struct smi_port *port = from_tasklet(port, t, tasklet);
286 struct smi_dev *dev = port->dev;
287 u32 intr_status, finishedData, dmaManagement;
288 u8 dmaChan0State, dmaChan1State;
290 intr_status = port->_int_status;
291 dmaManagement = smi_read(port->DMA_MANAGEMENT);
292 dmaChan0State = (u8)((dmaManagement & 0x00000030) >> 4);
293 dmaChan1State = (u8)((dmaManagement & 0x00300000) >> 20);
295 /* CH-0 DMA interrupt.*/
296 if ((intr_status & port->_dmaInterruptCH0) && (dmaChan0State == 0x01)) {
297 dev_dbg(&dev->pci_dev->dev,
298 "Port[%d]-DMA CH0 engine complete successful !\n",
300 finishedData = smi_read(port->DMA_CHAN0_TRANS_STATE);
301 finishedData &= 0x003FFFFF;
302 /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
303 * indicate dma total transfer length and
304 * zero of [21:0] indicate dma total transfer length
305 * equal to 0x400000 (4MB)*/
306 if (finishedData == 0)
307 finishedData = 0x00400000;
308 if (finishedData != SMI_TS_DMA_BUF_SIZE) {
309 dev_dbg(&dev->pci_dev->dev,
310 "DMA CH0 engine complete length mismatched, finish data=%d !\n",
313 dvb_dmx_swfilter_packets(&port->demux,
314 port->cpu_addr[0], (finishedData / 188));
315 /*dvb_dmx_swfilter(&port->demux,
316 port->cpu_addr[0], finishedData);*/
318 /* CH-1 DMA interrupt.*/
319 if ((intr_status & port->_dmaInterruptCH1) && (dmaChan1State == 0x01)) {
320 dev_dbg(&dev->pci_dev->dev,
321 "Port[%d]-DMA CH1 engine complete successful !\n",
323 finishedData = smi_read(port->DMA_CHAN1_TRANS_STATE);
324 finishedData &= 0x003FFFFF;
325 /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
326 * indicate dma total transfer length and
327 * zero of [21:0] indicate dma total transfer length
328 * equal to 0x400000 (4MB)*/
329 if (finishedData == 0)
330 finishedData = 0x00400000;
331 if (finishedData != SMI_TS_DMA_BUF_SIZE) {
332 dev_dbg(&dev->pci_dev->dev,
333 "DMA CH1 engine complete length mismatched, finish data=%d !\n",
336 dvb_dmx_swfilter_packets(&port->demux,
337 port->cpu_addr[1], (finishedData / 188));
338 /*dvb_dmx_swfilter(&port->demux,
339 port->cpu_addr[1], finishedData);*/
342 if (intr_status & port->_dmaInterruptCH0)
343 dmaManagement |= 0x00000002;
344 if (intr_status & port->_dmaInterruptCH1)
345 dmaManagement |= 0x00020000;
346 smi_write(port->DMA_MANAGEMENT, dmaManagement);
347 /* Re-enable interrupts */
348 smi_port_enableInterrupt(port);
351 static void smi_port_dma_free(struct smi_port *port)
353 if (port->cpu_addr[0]) {
354 pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
355 port->cpu_addr[0], port->dma_addr[0]);
356 port->cpu_addr[0] = NULL;
358 if (port->cpu_addr[1]) {
359 pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
360 port->cpu_addr[1], port->dma_addr[1]);
361 port->cpu_addr[1] = NULL;
365 static int smi_port_init(struct smi_port *port, int dmaChanUsed)
367 dev_dbg(&port->dev->pci_dev->dev,
368 "%s, port %d, dmaused %d\n", __func__, port->idx, dmaChanUsed);
370 if (port->idx == 0) {
372 port->_dmaInterruptCH0 = dmaChanUsed & 0x01;
373 port->_dmaInterruptCH1 = dmaChanUsed & 0x02;
375 port->DMA_CHAN0_ADDR_LOW = DMA_PORTA_CHAN0_ADDR_LOW;
376 port->DMA_CHAN0_ADDR_HI = DMA_PORTA_CHAN0_ADDR_HI;
377 port->DMA_CHAN0_TRANS_STATE = DMA_PORTA_CHAN0_TRANS_STATE;
378 port->DMA_CHAN0_CONTROL = DMA_PORTA_CHAN0_CONTROL;
379 port->DMA_CHAN1_ADDR_LOW = DMA_PORTA_CHAN1_ADDR_LOW;
380 port->DMA_CHAN1_ADDR_HI = DMA_PORTA_CHAN1_ADDR_HI;
381 port->DMA_CHAN1_TRANS_STATE = DMA_PORTA_CHAN1_TRANS_STATE;
382 port->DMA_CHAN1_CONTROL = DMA_PORTA_CHAN1_CONTROL;
383 port->DMA_MANAGEMENT = DMA_PORTA_MANAGEMENT;
386 port->_dmaInterruptCH0 = (dmaChanUsed << 2) & 0x04;
387 port->_dmaInterruptCH1 = (dmaChanUsed << 2) & 0x08;
389 port->DMA_CHAN0_ADDR_LOW = DMA_PORTB_CHAN0_ADDR_LOW;
390 port->DMA_CHAN0_ADDR_HI = DMA_PORTB_CHAN0_ADDR_HI;
391 port->DMA_CHAN0_TRANS_STATE = DMA_PORTB_CHAN0_TRANS_STATE;
392 port->DMA_CHAN0_CONTROL = DMA_PORTB_CHAN0_CONTROL;
393 port->DMA_CHAN1_ADDR_LOW = DMA_PORTB_CHAN1_ADDR_LOW;
394 port->DMA_CHAN1_ADDR_HI = DMA_PORTB_CHAN1_ADDR_HI;
395 port->DMA_CHAN1_TRANS_STATE = DMA_PORTB_CHAN1_TRANS_STATE;
396 port->DMA_CHAN1_CONTROL = DMA_PORTB_CHAN1_CONTROL;
397 port->DMA_MANAGEMENT = DMA_PORTB_MANAGEMENT;
400 if (port->_dmaInterruptCH0) {
401 port->cpu_addr[0] = pci_alloc_consistent(port->dev->pci_dev,
404 if (!port->cpu_addr[0]) {
405 dev_err(&port->dev->pci_dev->dev,
406 "Port[%d] DMA CH0 memory allocation failed!\n",
412 if (port->_dmaInterruptCH1) {
413 port->cpu_addr[1] = pci_alloc_consistent(port->dev->pci_dev,
416 if (!port->cpu_addr[1]) {
417 dev_err(&port->dev->pci_dev->dev,
418 "Port[%d] DMA CH1 memory allocation failed!\n",
424 smi_port_disableInterrupt(port);
425 tasklet_setup(&port->tasklet, smi_dma_xfer);
426 tasklet_disable(&port->tasklet);
430 smi_port_dma_free(port);
434 static void smi_port_exit(struct smi_port *port)
436 smi_port_disableInterrupt(port);
437 tasklet_kill(&port->tasklet);
438 smi_port_dma_free(port);
442 static int smi_port_irq(struct smi_port *port, u32 int_status)
444 u32 port_req_irq = port->_dmaInterruptCH0 | port->_dmaInterruptCH1;
447 if (int_status & port_req_irq) {
448 smi_port_disableInterrupt(port);
449 port->_int_status = int_status;
450 smi_port_clearInterrupt(port);
451 tasklet_schedule(&port->tasklet);
457 static irqreturn_t smi_irq_handler(int irq, void *dev_id)
459 struct smi_dev *dev = dev_id;
460 struct smi_port *port0 = &dev->ts_port[0];
461 struct smi_port *port1 = &dev->ts_port[1];
462 struct smi_rc *ir = &dev->ir;
465 u32 intr_status = smi_read(MSI_INT_STATUS);
469 handled += smi_port_irq(port0, intr_status);
473 handled += smi_port_irq(port1, intr_status);
476 handled += smi_ir_irq(ir, intr_status);
478 return IRQ_RETVAL(handled);
481 static struct i2c_client *smi_add_i2c_client(struct i2c_adapter *adapter,
482 struct i2c_board_info *info)
484 struct i2c_client *client;
486 request_module(info->type);
487 client = i2c_new_client_device(adapter, info);
488 if (!i2c_client_has_driver(client))
489 goto err_add_i2c_client;
491 if (!try_module_get(client->dev.driver->owner)) {
492 i2c_unregister_device(client);
493 goto err_add_i2c_client;
502 static void smi_del_i2c_client(struct i2c_client *client)
504 module_put(client->dev.driver->owner);
505 i2c_unregister_device(client);
508 static const struct m88ds3103_config smi_dvbsky_m88ds3103_cfg = {
513 .ts_mode = M88DS3103_TS_PARALLEL,
521 static int smi_dvbsky_m88ds3103_fe_attach(struct smi_port *port)
524 struct smi_dev *dev = port->dev;
525 struct i2c_adapter *i2c;
526 /* tuner I2C module */
527 struct i2c_adapter *tuner_i2c_adapter;
528 struct i2c_client *tuner_client;
529 struct i2c_board_info tuner_info;
530 struct ts2020_config ts2020_config = {};
531 memset(&tuner_info, 0, sizeof(struct i2c_board_info));
532 i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
535 port->fe = dvb_attach(m88ds3103_attach,
536 &smi_dvbsky_m88ds3103_cfg, i2c, &tuner_i2c_adapter);
542 ts2020_config.fe = port->fe;
543 strscpy(tuner_info.type, "ts2020", I2C_NAME_SIZE);
544 tuner_info.addr = 0x60;
545 tuner_info.platform_data = &ts2020_config;
546 tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
549 goto err_tuner_i2c_device;
552 /* delegate signal strength measurement to tuner */
553 port->fe->ops.read_signal_strength =
554 port->fe->ops.tuner_ops.get_rf_strength;
556 port->i2c_client_tuner = tuner_client;
559 err_tuner_i2c_device:
560 dvb_frontend_detach(port->fe);
564 static const struct m88ds3103_config smi_dvbsky_m88rs6000_cfg = {
568 .ts_mode = M88DS3103_TS_PARALLEL,
576 static int smi_dvbsky_m88rs6000_fe_attach(struct smi_port *port)
579 struct smi_dev *dev = port->dev;
580 struct i2c_adapter *i2c;
581 /* tuner I2C module */
582 struct i2c_adapter *tuner_i2c_adapter;
583 struct i2c_client *tuner_client;
584 struct i2c_board_info tuner_info;
585 struct m88rs6000t_config m88rs6000t_config;
587 memset(&tuner_info, 0, sizeof(struct i2c_board_info));
588 i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
591 port->fe = dvb_attach(m88ds3103_attach,
592 &smi_dvbsky_m88rs6000_cfg, i2c, &tuner_i2c_adapter);
598 m88rs6000t_config.fe = port->fe;
599 strscpy(tuner_info.type, "m88rs6000t", I2C_NAME_SIZE);
600 tuner_info.addr = 0x21;
601 tuner_info.platform_data = &m88rs6000t_config;
602 tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
605 goto err_tuner_i2c_device;
608 /* delegate signal strength measurement to tuner */
609 port->fe->ops.read_signal_strength =
610 port->fe->ops.tuner_ops.get_rf_strength;
612 port->i2c_client_tuner = tuner_client;
615 err_tuner_i2c_device:
616 dvb_frontend_detach(port->fe);
620 static int smi_dvbsky_sit2_fe_attach(struct smi_port *port)
623 struct smi_dev *dev = port->dev;
624 struct i2c_adapter *i2c;
625 struct i2c_adapter *tuner_i2c_adapter;
626 struct i2c_client *client_tuner, *client_demod;
627 struct i2c_board_info client_info;
628 struct si2168_config si2168_config;
629 struct si2157_config si2157_config;
632 i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
635 memset(&si2168_config, 0, sizeof(si2168_config));
636 si2168_config.i2c_adapter = &tuner_i2c_adapter;
637 si2168_config.fe = &port->fe;
638 si2168_config.ts_mode = SI2168_TS_PARALLEL;
640 memset(&client_info, 0, sizeof(struct i2c_board_info));
641 strscpy(client_info.type, "si2168", I2C_NAME_SIZE);
642 client_info.addr = 0x64;
643 client_info.platform_data = &si2168_config;
645 client_demod = smi_add_i2c_client(i2c, &client_info);
650 port->i2c_client_demod = client_demod;
653 memset(&si2157_config, 0, sizeof(si2157_config));
654 si2157_config.fe = port->fe;
655 si2157_config.if_port = 1;
657 memset(&client_info, 0, sizeof(struct i2c_board_info));
658 strscpy(client_info.type, "si2157", I2C_NAME_SIZE);
659 client_info.addr = 0x60;
660 client_info.platform_data = &si2157_config;
662 client_tuner = smi_add_i2c_client(tuner_i2c_adapter, &client_info);
664 smi_del_i2c_client(port->i2c_client_demod);
665 port->i2c_client_demod = NULL;
669 port->i2c_client_tuner = client_tuner;
673 static int smi_fe_init(struct smi_port *port)
676 struct smi_dev *dev = port->dev;
677 struct dvb_adapter *adap = &port->dvb_adapter;
680 dev_dbg(&port->dev->pci_dev->dev,
681 "%s: port %d, fe_type = %d\n",
682 __func__, port->idx, port->fe_type);
683 switch (port->fe_type) {
684 case DVBSKY_FE_M88DS3103:
685 ret = smi_dvbsky_m88ds3103_fe_attach(port);
687 case DVBSKY_FE_M88RS6000:
688 ret = smi_dvbsky_m88rs6000_fe_attach(port);
691 ret = smi_dvbsky_sit2_fe_attach(port);
697 /* register dvb frontend */
698 ret = dvb_register_frontend(adap, port->fe);
700 if (port->i2c_client_tuner)
701 smi_del_i2c_client(port->i2c_client_tuner);
702 if (port->i2c_client_demod)
703 smi_del_i2c_client(port->i2c_client_demod);
704 dvb_frontend_detach(port->fe);
708 ret = smi_read_eeprom(&dev->i2c_bus[0], 0xc0, mac_ee, 16);
709 dev_info(&port->dev->pci_dev->dev,
710 "%s port %d MAC: %pM\n", dev->info->name,
711 port->idx, mac_ee + (port->idx)*8);
712 memcpy(adap->proposed_mac, mac_ee + (port->idx)*8, 6);
716 static void smi_fe_exit(struct smi_port *port)
718 dvb_unregister_frontend(port->fe);
719 /* remove I2C demod and tuner */
720 if (port->i2c_client_tuner)
721 smi_del_i2c_client(port->i2c_client_tuner);
722 if (port->i2c_client_demod)
723 smi_del_i2c_client(port->i2c_client_demod);
724 dvb_frontend_detach(port->fe);
727 static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
728 int (*start_feed)(struct dvb_demux_feed *),
729 int (*stop_feed)(struct dvb_demux_feed *),
732 dvbdemux->priv = priv;
734 dvbdemux->filternum = 256;
735 dvbdemux->feednum = 256;
736 dvbdemux->start_feed = start_feed;
737 dvbdemux->stop_feed = stop_feed;
738 dvbdemux->write_to_decoder = NULL;
739 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |
740 DMX_SECTION_FILTERING |
741 DMX_MEMORY_BASED_FILTERING);
742 return dvb_dmx_init(dvbdemux);
745 static int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
746 struct dvb_demux *dvbdemux,
747 struct dmx_frontend *hw_frontend,
748 struct dmx_frontend *mem_frontend,
749 struct dvb_adapter *dvb_adapter)
753 dmxdev->filternum = 256;
754 dmxdev->demux = &dvbdemux->dmx;
755 dmxdev->capabilities = 0;
756 ret = dvb_dmxdev_init(dmxdev, dvb_adapter);
760 hw_frontend->source = DMX_FRONTEND_0;
761 dvbdemux->dmx.add_frontend(&dvbdemux->dmx, hw_frontend);
762 mem_frontend->source = DMX_MEMORY_FE;
763 dvbdemux->dmx.add_frontend(&dvbdemux->dmx, mem_frontend);
764 return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
767 static u32 smi_config_DMA(struct smi_port *port)
769 struct smi_dev *dev = port->dev;
770 u32 totalLength = 0, dmaMemPtrLow, dmaMemPtrHi, dmaCtlReg;
771 u8 chanLatencyTimer = 0, dmaChanEnable = 1, dmaTransStart = 1;
772 u32 dmaManagement = 0, tlpTransUnit = DMA_TRANS_UNIT_188;
773 u8 tlpTc = 0, tlpTd = 1, tlpEp = 0, tlpAttr = 0;
776 dmaManagement = smi_read(port->DMA_MANAGEMENT);
777 /* Setup Channel-0 */
778 if (port->_dmaInterruptCH0) {
779 totalLength = SMI_TS_DMA_BUF_SIZE;
780 mem = port->dma_addr[0];
781 dmaMemPtrLow = mem & 0xffffffff;
782 dmaMemPtrHi = mem >> 32;
783 dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
784 | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
785 dmaManagement |= dmaChanEnable | (dmaTransStart << 1)
786 | (chanLatencyTimer << 8);
787 /* write DMA register, start DMA engine */
788 smi_write(port->DMA_CHAN0_ADDR_LOW, dmaMemPtrLow);
789 smi_write(port->DMA_CHAN0_ADDR_HI, dmaMemPtrHi);
790 smi_write(port->DMA_CHAN0_CONTROL, dmaCtlReg);
792 /* Setup Channel-1 */
793 if (port->_dmaInterruptCH1) {
794 totalLength = SMI_TS_DMA_BUF_SIZE;
795 mem = port->dma_addr[1];
796 dmaMemPtrLow = mem & 0xffffffff;
797 dmaMemPtrHi = mem >> 32;
798 dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
799 | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
800 dmaManagement |= (dmaChanEnable << 16) | (dmaTransStart << 17)
801 | (chanLatencyTimer << 24);
802 /* write DMA register, start DMA engine */
803 smi_write(port->DMA_CHAN1_ADDR_LOW, dmaMemPtrLow);
804 smi_write(port->DMA_CHAN1_ADDR_HI, dmaMemPtrHi);
805 smi_write(port->DMA_CHAN1_CONTROL, dmaCtlReg);
807 return dmaManagement;
810 static int smi_start_feed(struct dvb_demux_feed *dvbdmxfeed)
812 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
813 struct smi_port *port = dvbdmx->priv;
814 struct smi_dev *dev = port->dev;
817 if (port->users++ == 0) {
818 dmaManagement = smi_config_DMA(port);
819 smi_port_clearInterrupt(port);
820 smi_port_enableInterrupt(port);
821 smi_write(port->DMA_MANAGEMENT, dmaManagement);
822 tasklet_enable(&port->tasklet);
827 static int smi_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
829 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
830 struct smi_port *port = dvbdmx->priv;
831 struct smi_dev *dev = port->dev;
836 tasklet_disable(&port->tasklet);
837 smi_port_disableInterrupt(port);
838 smi_clear(port->DMA_MANAGEMENT, 0x30003);
842 static int smi_dvb_init(struct smi_port *port)
845 struct dvb_adapter *adap = &port->dvb_adapter;
846 struct dvb_demux *dvbdemux = &port->demux;
848 dev_dbg(&port->dev->pci_dev->dev,
849 "%s, port %d\n", __func__, port->idx);
851 ret = dvb_register_adapter(adap, "SMI_DVB", THIS_MODULE,
852 &port->dev->pci_dev->dev,
855 dev_err(&port->dev->pci_dev->dev, "Fail to register DVB adapter.\n");
858 ret = my_dvb_dmx_ts_card_init(dvbdemux, "SW demux",
860 smi_stop_feed, port);
862 goto err_del_dvb_register_adapter;
864 ret = my_dvb_dmxdev_ts_card_init(&port->dmxdev, &port->demux,
866 &port->mem_frontend, adap);
868 goto err_del_dvb_dmx;
870 ret = dvb_net_init(adap, &port->dvbnet, port->dmxdev.demux);
872 goto err_del_dvb_dmxdev;
875 dvbdemux->dmx.close(&dvbdemux->dmx);
876 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
877 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
878 dvb_dmxdev_release(&port->dmxdev);
880 dvb_dmx_release(&port->demux);
881 err_del_dvb_register_adapter:
882 dvb_unregister_adapter(&port->dvb_adapter);
886 static void smi_dvb_exit(struct smi_port *port)
888 struct dvb_demux *dvbdemux = &port->demux;
890 dvb_net_release(&port->dvbnet);
892 dvbdemux->dmx.close(&dvbdemux->dmx);
893 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
894 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
895 dvb_dmxdev_release(&port->dmxdev);
896 dvb_dmx_release(&port->demux);
898 dvb_unregister_adapter(&port->dvb_adapter);
901 static int smi_port_attach(struct smi_dev *dev,
902 struct smi_port *port, int index)
908 port->fe_type = (index == 0) ? dev->info->fe_0 : dev->info->fe_1;
909 dmachs = (index == 0) ? dev->info->ts_0 : dev->info->ts_1;
911 ret = smi_port_init(port, dmachs);
915 ret = smi_dvb_init(port);
917 goto err_del_port_init;
919 ret = smi_fe_init(port);
921 goto err_del_dvb_init;
930 static void smi_port_detach(struct smi_port *port)
937 static int smi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
942 if (pci_enable_device(pdev) < 0)
945 dev = kzalloc(sizeof(struct smi_dev), GFP_KERNEL);
948 goto err_pci_disable_device;
952 pci_set_drvdata(pdev, dev);
953 dev->info = (struct smi_cfg_info *) id->driver_data;
954 dev_info(&dev->pci_dev->dev,
955 "card detected: %s\n", dev->info->name);
957 dev->nr = dev->info->type;
958 dev->lmmio = ioremap(pci_resource_start(dev->pci_dev, 0),
959 pci_resource_len(dev->pci_dev, 0));
965 /* should we set to 32bit DMA? */
966 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
968 goto err_pci_iounmap;
970 pci_set_master(pdev);
972 ret = smi_hw_init(dev);
974 goto err_pci_iounmap;
976 ret = smi_i2c_init(dev);
978 goto err_pci_iounmap;
980 if (dev->info->ts_0) {
981 ret = smi_port_attach(dev, &dev->ts_port[0], 0);
983 goto err_del_i2c_adaptor;
986 if (dev->info->ts_1) {
987 ret = smi_port_attach(dev, &dev->ts_port[1], 1);
989 goto err_del_port0_attach;
992 ret = smi_ir_init(dev);
994 goto err_del_port1_attach;
996 #ifdef CONFIG_PCI_MSI /* to do msi interrupt.???*/
997 if (pci_msi_enabled())
998 ret = pci_enable_msi(dev->pci_dev);
1000 dev_info(&dev->pci_dev->dev, "MSI not available.\n");
1003 ret = request_irq(dev->pci_dev->irq, smi_irq_handler,
1004 IRQF_SHARED, "SMI_PCIE", dev);
1008 smi_ir_start(&dev->ir);
1013 err_del_port1_attach:
1014 if (dev->info->ts_1)
1015 smi_port_detach(&dev->ts_port[1]);
1016 err_del_port0_attach:
1017 if (dev->info->ts_0)
1018 smi_port_detach(&dev->ts_port[0]);
1019 err_del_i2c_adaptor:
1022 iounmap(dev->lmmio);
1024 pci_set_drvdata(pdev, NULL);
1026 err_pci_disable_device:
1027 pci_disable_device(pdev);
1031 static void smi_remove(struct pci_dev *pdev)
1033 struct smi_dev *dev = pci_get_drvdata(pdev);
1035 smi_write(MSI_INT_ENA_CLR, ALL_INT);
1036 free_irq(dev->pci_dev->irq, dev);
1037 #ifdef CONFIG_PCI_MSI
1038 pci_disable_msi(dev->pci_dev);
1040 if (dev->info->ts_1)
1041 smi_port_detach(&dev->ts_port[1]);
1042 if (dev->info->ts_0)
1043 smi_port_detach(&dev->ts_port[0]);
1047 iounmap(dev->lmmio);
1048 pci_set_drvdata(pdev, NULL);
1049 pci_disable_device(pdev);
1054 static const struct smi_cfg_info dvbsky_s950_cfg = {
1055 .type = SMI_DVBSKY_S950,
1056 .name = "DVBSky S950 V3",
1057 .ts_0 = SMI_TS_NULL,
1058 .ts_1 = SMI_TS_DMA_BOTH,
1059 .fe_0 = DVBSKY_FE_NULL,
1060 .fe_1 = DVBSKY_FE_M88DS3103,
1061 .rc_map = RC_MAP_DVBSKY,
1064 static const struct smi_cfg_info dvbsky_s952_cfg = {
1065 .type = SMI_DVBSKY_S952,
1066 .name = "DVBSky S952 V3",
1067 .ts_0 = SMI_TS_DMA_BOTH,
1068 .ts_1 = SMI_TS_DMA_BOTH,
1069 .fe_0 = DVBSKY_FE_M88RS6000,
1070 .fe_1 = DVBSKY_FE_M88RS6000,
1071 .rc_map = RC_MAP_DVBSKY,
1074 static const struct smi_cfg_info dvbsky_t9580_cfg = {
1075 .type = SMI_DVBSKY_T9580,
1076 .name = "DVBSky T9580 V3",
1077 .ts_0 = SMI_TS_DMA_BOTH,
1078 .ts_1 = SMI_TS_DMA_BOTH,
1079 .fe_0 = DVBSKY_FE_SIT2,
1080 .fe_1 = DVBSKY_FE_M88DS3103,
1081 .rc_map = RC_MAP_DVBSKY,
1084 static const struct smi_cfg_info technotrend_s2_4200_cfg = {
1085 .type = SMI_TECHNOTREND_S2_4200,
1086 .name = "TechnoTrend TT-budget S2-4200 Twin",
1087 .ts_0 = SMI_TS_DMA_BOTH,
1088 .ts_1 = SMI_TS_DMA_BOTH,
1089 .fe_0 = DVBSKY_FE_M88RS6000,
1090 .fe_1 = DVBSKY_FE_M88RS6000,
1091 .rc_map = RC_MAP_TT_1500,
1095 #define SMI_ID(_subvend, _subdev, _driverdata) { \
1096 .vendor = SMI_VID, .device = SMI_PID, \
1097 .subvendor = _subvend, .subdevice = _subdev, \
1098 .driver_data = (unsigned long)&_driverdata }
1100 static const struct pci_device_id smi_id_table[] = {
1101 SMI_ID(0x4254, 0x0550, dvbsky_s950_cfg),
1102 SMI_ID(0x4254, 0x0552, dvbsky_s952_cfg),
1103 SMI_ID(0x4254, 0x5580, dvbsky_t9580_cfg),
1104 SMI_ID(0x13c2, 0x3016, technotrend_s2_4200_cfg),
1107 MODULE_DEVICE_TABLE(pci, smi_id_table);
1109 static struct pci_driver smipcie_driver = {
1110 .name = "SMI PCIe driver",
1111 .id_table = smi_id_table,
1113 .remove = smi_remove,
1116 module_pci_driver(smipcie_driver);
1118 MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
1119 MODULE_DESCRIPTION("SMI PCIe driver");
1120 MODULE_LICENSE("GPL");