2 * ddbridge.c: Digital Devices PCIe bridge driver
4 * Copyright (C) 2010-2011 Digital Devices GmbH
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 only, as published by the Free Software Foundation.
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.
16 * To obtain the license, point your browser to
17 * http://www.gnu.org/copyleft/gpl.html
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
26 #include <linux/slab.h>
27 #include <linux/poll.h>
29 #include <linux/pci.h>
30 #include <linux/pci_ids.h>
31 #include <linux/timer.h>
32 #include <linux/i2c.h>
33 #include <linux/swab.h>
34 #include <linux/vmalloc.h>
37 #include "ddbridge-regs.h"
39 #include "tda18271c2dd.h"
45 #include "stv0367_priv.h"
46 #include "cxd2841er.h"
49 static int xo2_speed = 2;
50 module_param(xo2_speed, int, 0444);
51 MODULE_PARM_DESC(xo2_speed, "default transfer speed for xo2 based duoflex, 0=55,1=75,2=90,3=104 MBit/s, default=2, use attribute to change for individual cards");
53 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
55 /* MSI had problems with lost interrupts, fixed but needs testing */
58 /******************************************************************************/
60 static int i2c_io(struct i2c_adapter *adapter, u8 adr,
61 u8 *wbuf, u32 wlen, u8 *rbuf, u32 rlen)
63 struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
64 .buf = wbuf, .len = wlen },
65 {.addr = adr, .flags = I2C_M_RD,
66 .buf = rbuf, .len = rlen } };
67 return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
70 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
72 struct i2c_msg msg = {.addr = adr, .flags = 0,
73 .buf = data, .len = len};
75 return (i2c_transfer(adap, &msg, 1) == 1) ? 0 : -1;
78 static int i2c_read(struct i2c_adapter *adapter, u8 adr, u8 *val)
80 struct i2c_msg msgs[1] = {{.addr = adr, .flags = I2C_M_RD,
81 .buf = val, .len = 1 } };
82 return (i2c_transfer(adapter, msgs, 1) == 1) ? 0 : -1;
85 static int i2c_read_regs(struct i2c_adapter *adapter,
86 u8 adr, u8 reg, u8 *val, u8 len)
88 struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
89 .buf = ®, .len = 1 },
90 {.addr = adr, .flags = I2C_M_RD,
91 .buf = val, .len = len } };
92 return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
95 static int i2c_read_reg(struct i2c_adapter *adapter, u8 adr, u8 reg, u8 *val)
97 return i2c_read_regs(adapter, adr, reg, val, 1);
100 static int i2c_read_reg16(struct i2c_adapter *adapter, u8 adr,
103 u8 msg[2] = {reg>>8, reg&0xff};
104 struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
105 .buf = msg, .len = 2},
106 {.addr = adr, .flags = I2C_M_RD,
107 .buf = val, .len = 1} };
108 return (i2c_transfer(adapter, msgs, 2) == 2) ? 0 : -1;
111 static int i2c_write_reg(struct i2c_adapter *adap, u8 adr,
114 u8 msg[2] = {reg, val};
116 return i2c_write(adap, adr, msg, 2);
119 static inline u32 safe_ddbreadl(struct ddb *dev, u32 adr)
121 u32 val = ddbreadl(adr);
123 /* (ddb)readl returns (uint)-1 (all bits set) on failure, catch that */
125 dev_err(&dev->pdev->dev, "ddbreadl failure, adr=%08x\n", adr);
132 static int ddb_i2c_cmd(struct ddb_i2c *i2c, u32 adr, u32 cmd)
134 struct ddb *dev = i2c->dev;
139 ddbwritel((adr << 9) | cmd, i2c->regs + I2C_COMMAND);
140 stat = wait_event_timeout(i2c->wq, i2c->done == 1, HZ);
142 dev_err(&dev->pdev->dev, "I2C timeout\n");
144 u32 istat = ddbreadl(INTERRUPT_STATUS);
145 dev_err(&dev->pdev->dev, "IRS %08x\n", istat);
146 ddbwritel(istat, INTERRUPT_ACK);
150 val = ddbreadl(i2c->regs+I2C_COMMAND);
156 static int ddb_i2c_master_xfer(struct i2c_adapter *adapter,
157 struct i2c_msg msg[], int num)
159 struct ddb_i2c *i2c = (struct ddb_i2c *)i2c_get_adapdata(adapter);
160 struct ddb *dev = i2c->dev;
166 if (num == 2 && msg[1].flags & I2C_M_RD &&
167 !(msg[0].flags & I2C_M_RD)) {
168 memcpy_toio(dev->regs + I2C_TASKMEM_BASE + i2c->wbuf,
169 msg[0].buf, msg[0].len);
170 ddbwritel(msg[0].len|(msg[1].len << 16),
171 i2c->regs+I2C_TASKLENGTH);
172 if (!ddb_i2c_cmd(i2c, addr, 1)) {
173 memcpy_fromio(msg[1].buf,
174 dev->regs + I2C_TASKMEM_BASE + i2c->rbuf,
180 if (num == 1 && !(msg[0].flags & I2C_M_RD)) {
181 ddbcpyto(I2C_TASKMEM_BASE + i2c->wbuf, msg[0].buf, msg[0].len);
182 ddbwritel(msg[0].len, i2c->regs + I2C_TASKLENGTH);
183 if (!ddb_i2c_cmd(i2c, addr, 2))
186 if (num == 1 && (msg[0].flags & I2C_M_RD)) {
187 ddbwritel(msg[0].len << 16, i2c->regs + I2C_TASKLENGTH);
188 if (!ddb_i2c_cmd(i2c, addr, 3)) {
189 ddbcpyfrom(msg[0].buf,
190 I2C_TASKMEM_BASE + i2c->rbuf, msg[0].len);
198 static u32 ddb_i2c_functionality(struct i2c_adapter *adap)
200 return I2C_FUNC_SMBUS_EMUL;
203 static struct i2c_algorithm ddb_i2c_algo = {
204 .master_xfer = ddb_i2c_master_xfer,
205 .functionality = ddb_i2c_functionality,
208 static void ddb_i2c_release(struct ddb *dev)
212 struct i2c_adapter *adap;
214 for (i = 0; i < dev->info->port_num; i++) {
217 i2c_del_adapter(adap);
221 static int ddb_i2c_init(struct ddb *dev)
225 struct i2c_adapter *adap;
227 for (i = 0; i < dev->info->port_num; i++) {
231 i2c->wbuf = i * (I2C_TASKMEM_SIZE / 4);
232 i2c->rbuf = i2c->wbuf + (I2C_TASKMEM_SIZE / 8);
233 i2c->regs = 0x80 + i * 0x20;
234 ddbwritel(I2C_SPEED_100, i2c->regs + I2C_TIMING);
235 ddbwritel((i2c->rbuf << 16) | i2c->wbuf,
236 i2c->regs + I2C_TASKADDRESS);
237 init_waitqueue_head(&i2c->wq);
240 i2c_set_adapdata(adap, i2c);
241 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
242 adap->class = I2C_ADAP_CLASS_TV_DIGITAL|I2C_CLASS_TV_ANALOG;
244 #ifdef I2C_CLASS_TV_ANALOG
245 adap->class = I2C_CLASS_TV_ANALOG;
248 strcpy(adap->name, "ddbridge");
249 adap->algo = &ddb_i2c_algo;
250 adap->algo_data = (void *)i2c;
251 adap->dev.parent = &dev->pdev->dev;
252 stat = i2c_add_adapter(adap);
257 for (j = 0; j < i; j++) {
260 i2c_del_adapter(adap);
266 /******************************************************************************/
267 /******************************************************************************/
268 /******************************************************************************/
271 static void set_table(struct ddb *dev, u32 off,
272 dma_addr_t *pbuf, u32 num)
277 base = DMA_BASE_ADDRESS_TABLE + off;
278 for (i = 0; i < num; i++) {
280 ddbwritel(mem & 0xffffffff, base + i * 8);
281 ddbwritel(mem >> 32, base + i * 8 + 4);
286 static void ddb_address_table(struct ddb *dev)
292 for (i = 0; i < dev->info->port_num * 2; i++) {
293 base = DMA_BASE_ADDRESS_TABLE + i * 0x100;
294 pbuf = dev->input[i].pbuf;
295 for (j = 0; j < dev->input[i].dma_buf_num; j++) {
297 ddbwritel(mem & 0xffffffff, base + j * 8);
298 ddbwritel(mem >> 32, base + j * 8 + 4);
301 for (i = 0; i < dev->info->port_num; i++) {
302 base = DMA_BASE_ADDRESS_TABLE + 0x800 + i * 0x100;
303 pbuf = dev->output[i].pbuf;
304 for (j = 0; j < dev->output[i].dma_buf_num; j++) {
306 ddbwritel(mem & 0xffffffff, base + j * 8);
307 ddbwritel(mem >> 32, base + j * 8 + 4);
312 static void io_free(struct pci_dev *pdev, u8 **vbuf,
313 dma_addr_t *pbuf, u32 size, int num)
317 for (i = 0; i < num; i++) {
319 pci_free_consistent(pdev, size, vbuf[i], pbuf[i]);
325 static int io_alloc(struct pci_dev *pdev, u8 **vbuf,
326 dma_addr_t *pbuf, u32 size, int num)
330 for (i = 0; i < num; i++) {
331 vbuf[i] = pci_alloc_consistent(pdev, size, &pbuf[i]);
338 static int ddb_buffers_alloc(struct ddb *dev)
341 struct ddb_port *port;
343 for (i = 0; i < dev->info->port_num; i++) {
344 port = &dev->port[i];
345 switch (port->class) {
347 if (io_alloc(dev->pdev, port->input[0]->vbuf,
348 port->input[0]->pbuf,
349 port->input[0]->dma_buf_size,
350 port->input[0]->dma_buf_num) < 0)
352 if (io_alloc(dev->pdev, port->input[1]->vbuf,
353 port->input[1]->pbuf,
354 port->input[1]->dma_buf_size,
355 port->input[1]->dma_buf_num) < 0)
359 if (io_alloc(dev->pdev, port->input[0]->vbuf,
360 port->input[0]->pbuf,
361 port->input[0]->dma_buf_size,
362 port->input[0]->dma_buf_num) < 0)
364 if (io_alloc(dev->pdev, port->output->vbuf,
366 port->output->dma_buf_size,
367 port->output->dma_buf_num) < 0)
374 ddb_address_table(dev);
378 static void ddb_buffers_free(struct ddb *dev)
381 struct ddb_port *port;
383 for (i = 0; i < dev->info->port_num; i++) {
384 port = &dev->port[i];
385 io_free(dev->pdev, port->input[0]->vbuf,
386 port->input[0]->pbuf,
387 port->input[0]->dma_buf_size,
388 port->input[0]->dma_buf_num);
389 io_free(dev->pdev, port->input[1]->vbuf,
390 port->input[1]->pbuf,
391 port->input[1]->dma_buf_size,
392 port->input[1]->dma_buf_num);
393 io_free(dev->pdev, port->output->vbuf,
395 port->output->dma_buf_size,
396 port->output->dma_buf_num);
400 static void ddb_input_start(struct ddb_input *input)
402 struct ddb *dev = input->port->dev;
404 spin_lock_irq(&input->lock);
409 ddbwritel(0, TS_INPUT_CONTROL(input->nr));
410 ddbwritel(2, TS_INPUT_CONTROL(input->nr));
411 ddbwritel(0, TS_INPUT_CONTROL(input->nr));
413 ddbwritel((1 << 16) |
414 (input->dma_buf_num << 11) |
415 (input->dma_buf_size >> 7),
416 DMA_BUFFER_SIZE(input->nr));
417 ddbwritel(0, DMA_BUFFER_ACK(input->nr));
419 ddbwritel(1, DMA_BASE_WRITE);
420 ddbwritel(3, DMA_BUFFER_CONTROL(input->nr));
421 ddbwritel(9, TS_INPUT_CONTROL(input->nr));
423 spin_unlock_irq(&input->lock);
426 static void ddb_input_stop(struct ddb_input *input)
428 struct ddb *dev = input->port->dev;
430 spin_lock_irq(&input->lock);
431 ddbwritel(0, TS_INPUT_CONTROL(input->nr));
432 ddbwritel(0, DMA_BUFFER_CONTROL(input->nr));
434 spin_unlock_irq(&input->lock);
437 static void ddb_output_start(struct ddb_output *output)
439 struct ddb *dev = output->port->dev;
441 spin_lock_irq(&output->lock);
444 ddbwritel(0, TS_OUTPUT_CONTROL(output->nr));
445 ddbwritel(2, TS_OUTPUT_CONTROL(output->nr));
446 ddbwritel(0, TS_OUTPUT_CONTROL(output->nr));
447 ddbwritel(0x3c, TS_OUTPUT_CONTROL(output->nr));
448 ddbwritel((1 << 16) |
449 (output->dma_buf_num << 11) |
450 (output->dma_buf_size >> 7),
451 DMA_BUFFER_SIZE(output->nr + 8));
452 ddbwritel(0, DMA_BUFFER_ACK(output->nr + 8));
454 ddbwritel(1, DMA_BASE_READ);
455 ddbwritel(3, DMA_BUFFER_CONTROL(output->nr + 8));
456 /* ddbwritel(0xbd, TS_OUTPUT_CONTROL(output->nr)); */
457 ddbwritel(0x1d, TS_OUTPUT_CONTROL(output->nr));
459 spin_unlock_irq(&output->lock);
462 static void ddb_output_stop(struct ddb_output *output)
464 struct ddb *dev = output->port->dev;
466 spin_lock_irq(&output->lock);
467 ddbwritel(0, TS_OUTPUT_CONTROL(output->nr));
468 ddbwritel(0, DMA_BUFFER_CONTROL(output->nr + 8));
470 spin_unlock_irq(&output->lock);
473 static u32 ddb_output_free(struct ddb_output *output)
475 u32 idx, off, stat = output->stat;
478 idx = (stat >> 11) & 0x1f;
479 off = (stat & 0x7ff) << 7;
481 if (output->cbuf != idx) {
482 if ((((output->cbuf + 1) % output->dma_buf_num) == idx) &&
483 (output->dma_buf_size - output->coff <= 188))
487 diff = off - output->coff;
488 if (diff <= 0 || diff > 188)
493 static ssize_t ddb_output_write(struct ddb_output *output,
494 const __user u8 *buf, size_t count)
496 struct ddb *dev = output->port->dev;
497 u32 idx, off, stat = output->stat;
498 u32 left = count, len;
500 idx = (stat >> 11) & 0x1f;
501 off = (stat & 0x7ff) << 7;
504 len = output->dma_buf_size - output->coff;
505 if ((((output->cbuf + 1) % output->dma_buf_num) == idx) &&
511 if (output->cbuf == idx) {
512 if (off > output->coff) {
514 len = off - output->coff;
525 if (copy_from_user(output->vbuf[output->cbuf] + output->coff,
531 if (output->coff == output->dma_buf_size) {
533 output->cbuf = ((output->cbuf + 1) % output->dma_buf_num);
535 ddbwritel((output->cbuf << 11) | (output->coff >> 7),
536 DMA_BUFFER_ACK(output->nr + 8));
541 static u32 ddb_input_avail(struct ddb_input *input)
543 struct ddb *dev = input->port->dev;
544 u32 idx, off, stat = input->stat;
545 u32 ctrl = ddbreadl(DMA_BUFFER_CONTROL(input->nr));
547 idx = (stat >> 11) & 0x1f;
548 off = (stat & 0x7ff) << 7;
551 dev_err(&dev->pdev->dev, "IA %d %d %08x\n", idx, off, ctrl);
552 ddbwritel(input->stat, DMA_BUFFER_ACK(input->nr));
555 if (input->cbuf != idx)
560 static ssize_t ddb_input_read(struct ddb_input *input, __user u8 *buf, size_t count)
562 struct ddb *dev = input->port->dev;
564 u32 idx, free, stat = input->stat;
567 idx = (stat >> 11) & 0x1f;
570 if (input->cbuf == idx)
572 free = input->dma_buf_size - input->coff;
575 ret = copy_to_user(buf, input->vbuf[input->cbuf] +
580 if (input->coff == input->dma_buf_size) {
582 input->cbuf = (input->cbuf+1) % input->dma_buf_num;
585 ddbwritel((input->cbuf << 11) | (input->coff >> 7),
586 DMA_BUFFER_ACK(input->nr));
591 /******************************************************************************/
592 /******************************************************************************/
593 /******************************************************************************/
596 static struct ddb_input *fe2input(struct ddb *dev, struct dvb_frontend *fe)
600 for (i = 0; i < dev->info->port_num * 2; i++) {
601 if (dev->input[i].fe == fe)
602 return &dev->input[i];
608 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
610 struct ddb_input *input = fe->sec_priv;
611 struct ddb_port *port = input->port;
615 mutex_lock(&port->i2c_gate_lock);
616 status = input->gate_ctrl(fe, 1);
618 status = input->gate_ctrl(fe, 0);
619 mutex_unlock(&port->i2c_gate_lock);
624 static int demod_attach_drxk(struct ddb_input *input)
626 struct i2c_adapter *i2c = &input->port->i2c->adap;
627 struct dvb_frontend *fe;
628 struct drxk_config config;
629 struct device *dev = &input->port->dev->pdev->dev;
631 memset(&config, 0, sizeof(config));
632 config.microcode_name = "drxk_a3.mc";
633 config.qam_demod_parameter_count = 4;
634 config.adr = 0x29 + (input->nr & 1);
636 fe = input->fe = dvb_attach(drxk_attach, &config, i2c);
638 dev_err(dev, "No DRXK found!\n");
641 fe->sec_priv = input;
642 input->gate_ctrl = fe->ops.i2c_gate_ctrl;
643 fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
647 static int tuner_attach_tda18271(struct ddb_input *input)
649 struct i2c_adapter *i2c = &input->port->i2c->adap;
650 struct dvb_frontend *fe;
651 struct device *dev = &input->port->dev->pdev->dev;
653 if (input->fe->ops.i2c_gate_ctrl)
654 input->fe->ops.i2c_gate_ctrl(input->fe, 1);
655 fe = dvb_attach(tda18271c2dd_attach, input->fe, i2c, 0x60);
657 dev_err(dev, "No TDA18271 found!\n");
660 if (input->fe->ops.i2c_gate_ctrl)
661 input->fe->ops.i2c_gate_ctrl(input->fe, 0);
665 /******************************************************************************/
666 /******************************************************************************/
667 /******************************************************************************/
669 static struct stv0367_config ddb_stv0367_config[] = {
671 .demod_address = 0x1f,
674 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
675 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
676 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
678 .demod_address = 0x1e,
681 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
682 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
683 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
687 static int demod_attach_stv0367(struct ddb_input *input)
689 struct i2c_adapter *i2c = &input->port->i2c->adap;
690 struct device *dev = &input->port->dev->pdev->dev;
692 /* attach frontend */
693 input->fe = dvb_attach(stv0367ddb_attach,
694 &ddb_stv0367_config[(input->nr & 1)], i2c);
697 dev_err(dev, "stv0367ddb_attach failed (not found?)\n");
701 input->fe->sec_priv = input;
702 input->gate_ctrl = input->fe->ops.i2c_gate_ctrl;
703 input->fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
708 static int tuner_tda18212_ping(struct ddb_input *input, unsigned short adr)
710 struct i2c_adapter *adapter = &input->port->i2c->adap;
711 struct device *dev = &input->port->dev->pdev->dev;
716 dev_dbg(dev, "stv0367-tda18212 tuner ping\n");
717 if (input->fe->ops.i2c_gate_ctrl)
718 input->fe->ops.i2c_gate_ctrl(input->fe, 1);
720 if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
721 dev_dbg(dev, "tda18212 ping 1 fail\n");
722 if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
723 dev_warn(dev, "tda18212 ping failed, expect problems\n");
725 if (input->fe->ops.i2c_gate_ctrl)
726 input->fe->ops.i2c_gate_ctrl(input->fe, 0);
731 static int demod_attach_cxd28xx(struct ddb_input *input, int par, int osc24)
733 struct i2c_adapter *i2c = &input->port->i2c->adap;
734 struct device *dev = &input->port->dev->pdev->dev;
735 struct cxd2841er_config cfg;
737 /* the cxd2841er driver expects 8bit/shifted I2C addresses */
738 cfg.i2c_addr = ((input->nr & 1) ? 0x6d : 0x6c) << 1;
740 cfg.xtal = osc24 ? SONY_XTAL_24000 : SONY_XTAL_20500;
741 cfg.flags = CXD2841ER_AUTO_IFHZ | CXD2841ER_EARLY_TUNE |
742 CXD2841ER_NO_WAIT_LOCK | CXD2841ER_NO_AGCNEG |
746 cfg.flags |= CXD2841ER_TS_SERIAL;
748 /* attach frontend */
749 input->fe = dvb_attach(cxd2841er_attach_t_c, &cfg, i2c);
752 dev_err(dev, "No Sony CXD28xx found!\n");
756 input->fe->sec_priv = input;
757 input->gate_ctrl = input->fe->ops.i2c_gate_ctrl;
758 input->fe->ops.i2c_gate_ctrl = drxk_gate_ctrl;
763 static int tuner_attach_tda18212(struct ddb_input *input, u32 porttype)
765 struct i2c_adapter *adapter = &input->port->i2c->adap;
766 struct device *dev = &input->port->dev->pdev->dev;
767 struct i2c_client *client;
768 struct tda18212_config config = {
778 struct i2c_board_info board_info = {
780 .platform_data = &config,
784 board_info.addr = 0x63;
786 board_info.addr = 0x60;
788 /* due to a hardware quirk with the I2C gate on the stv0367+tda18212
789 * combo, the tda18212 must be probed by reading it's id _twice_ when
790 * cold started, or it very likely will fail.
792 if (porttype == DDB_TUNER_DVBCT_ST)
793 tuner_tda18212_ping(input, board_info.addr);
795 request_module(board_info.type);
797 /* perform tuner init/attach */
798 client = i2c_new_device(adapter, &board_info);
799 if (client == NULL || client->dev.driver == NULL)
802 if (!try_module_get(client->dev.driver->owner)) {
803 i2c_unregister_device(client);
807 input->i2c_client[0] = client;
811 dev_warn(dev, "TDA18212 tuner not found. Device is not fully operational.\n");
815 /******************************************************************************/
816 /******************************************************************************/
817 /******************************************************************************/
819 static struct stv090x_config stv0900 = {
821 .demod_mode = STV090x_DUAL,
822 .clk_mode = STV090x_CLK_EXT,
827 .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
828 .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
830 .repeater_level = STV090x_RPTLEVEL_16,
832 .adc1_range = STV090x_ADC_1Vpp,
833 .adc2_range = STV090x_ADC_1Vpp,
835 .diseqc_envelope_mode = true,
838 static struct stv090x_config stv0900_aa = {
840 .demod_mode = STV090x_DUAL,
841 .clk_mode = STV090x_CLK_EXT,
846 .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
847 .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
849 .repeater_level = STV090x_RPTLEVEL_16,
851 .adc1_range = STV090x_ADC_1Vpp,
852 .adc2_range = STV090x_ADC_1Vpp,
854 .diseqc_envelope_mode = true,
857 static struct stv6110x_config stv6110a = {
863 static struct stv6110x_config stv6110b = {
869 static int demod_attach_stv0900(struct ddb_input *input, int type)
871 struct i2c_adapter *i2c = &input->port->i2c->adap;
872 struct device *dev = &input->port->dev->pdev->dev;
873 struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
875 input->fe = dvb_attach(stv090x_attach, feconf, i2c,
876 (input->nr & 1) ? STV090x_DEMODULATOR_1
877 : STV090x_DEMODULATOR_0);
879 dev_err(dev, "No STV0900 found!\n");
882 if (!dvb_attach(lnbh24_attach, input->fe, i2c, 0,
884 (0x09 - type) : (0x0b - type))) {
885 dev_err(dev, "No LNBH24 found!\n");
891 static int tuner_attach_stv6110(struct ddb_input *input, int type)
893 struct i2c_adapter *i2c = &input->port->i2c->adap;
894 struct device *dev = &input->port->dev->pdev->dev;
895 struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
896 struct stv6110x_config *tunerconf = (input->nr & 1) ?
897 &stv6110b : &stv6110a;
898 const struct stv6110x_devctl *ctl;
900 ctl = dvb_attach(stv6110x_attach, input->fe, tunerconf, i2c);
902 dev_err(dev, "No STV6110X found!\n");
905 dev_info(dev, "attach tuner input %d adr %02x\n",
906 input->nr, tunerconf->addr);
908 feconf->tuner_init = ctl->tuner_init;
909 feconf->tuner_sleep = ctl->tuner_sleep;
910 feconf->tuner_set_mode = ctl->tuner_set_mode;
911 feconf->tuner_set_frequency = ctl->tuner_set_frequency;
912 feconf->tuner_get_frequency = ctl->tuner_get_frequency;
913 feconf->tuner_set_bandwidth = ctl->tuner_set_bandwidth;
914 feconf->tuner_get_bandwidth = ctl->tuner_get_bandwidth;
915 feconf->tuner_set_bbgain = ctl->tuner_set_bbgain;
916 feconf->tuner_get_bbgain = ctl->tuner_get_bbgain;
917 feconf->tuner_set_refclk = ctl->tuner_set_refclk;
918 feconf->tuner_get_status = ctl->tuner_get_status;
923 static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
924 int (*start_feed)(struct dvb_demux_feed *),
925 int (*stop_feed)(struct dvb_demux_feed *),
928 dvbdemux->priv = priv;
930 dvbdemux->filternum = 256;
931 dvbdemux->feednum = 256;
932 dvbdemux->start_feed = start_feed;
933 dvbdemux->stop_feed = stop_feed;
934 dvbdemux->write_to_decoder = NULL;
935 dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |
936 DMX_SECTION_FILTERING |
937 DMX_MEMORY_BASED_FILTERING);
938 return dvb_dmx_init(dvbdemux);
941 static int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
942 struct dvb_demux *dvbdemux,
943 struct dmx_frontend *hw_frontend,
944 struct dmx_frontend *mem_frontend,
945 struct dvb_adapter *dvb_adapter)
949 dmxdev->filternum = 256;
950 dmxdev->demux = &dvbdemux->dmx;
951 dmxdev->capabilities = 0;
952 ret = dvb_dmxdev_init(dmxdev, dvb_adapter);
956 hw_frontend->source = DMX_FRONTEND_0;
957 dvbdemux->dmx.add_frontend(&dvbdemux->dmx, hw_frontend);
958 mem_frontend->source = DMX_MEMORY_FE;
959 dvbdemux->dmx.add_frontend(&dvbdemux->dmx, mem_frontend);
960 return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
963 static int start_feed(struct dvb_demux_feed *dvbdmxfeed)
965 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
966 struct ddb_input *input = dvbdmx->priv;
969 ddb_input_start(input);
971 return ++input->users;
974 static int stop_feed(struct dvb_demux_feed *dvbdmxfeed)
976 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
977 struct ddb_input *input = dvbdmx->priv;
982 ddb_input_stop(input);
987 static void dvb_input_detach(struct ddb_input *input)
989 struct dvb_adapter *adap = &input->adap;
990 struct dvb_demux *dvbdemux = &input->demux;
991 struct i2c_client *client;
993 switch (input->attached) {
995 client = input->i2c_client[0];
997 module_put(client->dev.driver->owner);
998 i2c_unregister_device(client);
1001 dvb_unregister_frontend(input->fe2);
1005 dvb_unregister_frontend(input->fe);
1006 dvb_frontend_detach(input->fe);
1011 dvb_net_release(&input->dvbnet);
1014 dvbdemux->dmx.close(&dvbdemux->dmx);
1015 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1016 &input->hw_frontend);
1017 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1018 &input->mem_frontend);
1019 dvb_dmxdev_release(&input->dmxdev);
1022 dvb_dmx_release(&input->demux);
1025 dvb_unregister_adapter(adap);
1027 input->attached = 0;
1030 static int dvb_input_attach(struct ddb_input *input)
1033 struct ddb_port *port = input->port;
1034 struct dvb_adapter *adap = &input->adap;
1035 struct dvb_demux *dvbdemux = &input->demux;
1036 struct device *dev = &input->port->dev->pdev->dev;
1037 int sony_osc24 = 0, sony_tspar = 0;
1039 ret = dvb_register_adapter(adap, "DDBridge", THIS_MODULE,
1040 &input->port->dev->pdev->dev,
1043 dev_err(dev, "Could not register adapter. Check if you enabled enough adapters in dvb-core!\n");
1046 input->attached = 1;
1048 ret = my_dvb_dmx_ts_card_init(dvbdemux, "SW demux",
1053 input->attached = 2;
1055 ret = my_dvb_dmxdev_ts_card_init(&input->dmxdev, &input->demux,
1056 &input->hw_frontend,
1057 &input->mem_frontend, adap);
1060 input->attached = 3;
1062 ret = dvb_net_init(adap, &input->dvbnet, input->dmxdev.demux);
1065 input->attached = 4;
1068 switch (port->type) {
1069 case DDB_TUNER_DVBS_ST:
1070 if (demod_attach_stv0900(input, 0) < 0)
1072 if (tuner_attach_stv6110(input, 0) < 0)
1075 if (dvb_register_frontend(adap, input->fe) < 0)
1079 case DDB_TUNER_DVBS_ST_AA:
1080 if (demod_attach_stv0900(input, 1) < 0)
1082 if (tuner_attach_stv6110(input, 1) < 0)
1085 if (dvb_register_frontend(adap, input->fe) < 0)
1089 case DDB_TUNER_DVBCT_TR:
1090 if (demod_attach_drxk(input) < 0)
1092 if (tuner_attach_tda18271(input) < 0)
1094 if (dvb_register_frontend(adap, input->fe) < 0)
1097 if (dvb_register_frontend(adap, input->fe2) < 0)
1099 input->fe2->tuner_priv = input->fe->tuner_priv;
1100 memcpy(&input->fe2->ops.tuner_ops,
1101 &input->fe->ops.tuner_ops,
1102 sizeof(struct dvb_tuner_ops));
1105 case DDB_TUNER_DVBCT_ST:
1106 if (demod_attach_stv0367(input) < 0)
1108 if (tuner_attach_tda18212(input, port->type) < 0)
1111 if (dvb_register_frontend(adap, input->fe) < 0)
1115 case DDB_TUNER_DVBC2T2I_SONY_P:
1116 case DDB_TUNER_DVBCT2_SONY_P:
1117 case DDB_TUNER_DVBC2T2_SONY_P:
1118 case DDB_TUNER_ISDBT_SONY_P:
1119 if (port->type == DDB_TUNER_DVBC2T2I_SONY_P)
1121 if (input->port->dev->info->ts_quirks & TS_QUIRK_ALT_OSC)
1123 if (input->port->dev->info->ts_quirks & TS_QUIRK_SERIAL)
1128 if (demod_attach_cxd28xx(input, sony_tspar, sony_osc24) < 0)
1130 if (tuner_attach_tda18212(input, port->type) < 0)
1133 if (dvb_register_frontend(adap, input->fe) < 0)
1137 case DDB_TUNER_XO2_DVBC2T2I_SONY:
1138 case DDB_TUNER_XO2_DVBCT2_SONY:
1139 case DDB_TUNER_XO2_DVBC2T2_SONY:
1140 case DDB_TUNER_XO2_ISDBT_SONY:
1141 if (port->type == DDB_TUNER_XO2_DVBC2T2I_SONY)
1144 if (demod_attach_cxd28xx(input, 0, sony_osc24) < 0)
1146 if (tuner_attach_tda18212(input, port->type) < 0)
1149 if (dvb_register_frontend(adap, input->fe) < 0)
1155 input->attached = 5;
1159 /****************************************************************************/
1160 /****************************************************************************/
1162 static ssize_t ts_write(struct file *file, const __user char *buf,
1163 size_t count, loff_t *ppos)
1165 struct dvb_device *dvbdev = file->private_data;
1166 struct ddb_output *output = dvbdev->priv;
1167 size_t left = count;
1171 if (ddb_output_free(output) < 188) {
1172 if (file->f_flags & O_NONBLOCK)
1174 if (wait_event_interruptible(
1175 output->wq, ddb_output_free(output) >= 188) < 0)
1178 stat = ddb_output_write(output, buf, left);
1184 return (left == count) ? -EAGAIN : (count - left);
1187 static ssize_t ts_read(struct file *file, __user char *buf,
1188 size_t count, loff_t *ppos)
1190 struct dvb_device *dvbdev = file->private_data;
1191 struct ddb_output *output = dvbdev->priv;
1192 struct ddb_input *input = output->port->input[0];
1195 count -= count % 188;
1198 if (ddb_input_avail(input) < 188) {
1199 if (file->f_flags & O_NONBLOCK)
1201 if (wait_event_interruptible(
1202 input->wq, ddb_input_avail(input) >= 188) < 0)
1205 read = ddb_input_read(input, buf, left);
1211 return (left == count) ? -EAGAIN : (count - left);
1214 static unsigned int ts_poll(struct file *file, poll_table *wait)
1217 struct dvb_device *dvbdev = file->private_data;
1218 struct ddb_output *output = dvbdev->priv;
1219 struct ddb_input *input = output->port->input[0];
1221 unsigned int mask = 0;
1224 if (data_avail_to_read)
1225 mask |= POLLIN | POLLRDNORM;
1226 if (data_avail_to_write)
1227 mask |= POLLOUT | POLLWRNORM;
1229 poll_wait(file, &read_queue, wait);
1230 poll_wait(file, &write_queue, wait);
1235 static const struct file_operations ci_fops = {
1236 .owner = THIS_MODULE,
1239 .open = dvb_generic_open,
1240 .release = dvb_generic_release,
1244 static struct dvb_device dvbdev_ci = {
1251 /****************************************************************************/
1252 /****************************************************************************/
1253 /****************************************************************************/
1255 static void input_tasklet(unsigned long data)
1257 struct ddb_input *input = (struct ddb_input *) data;
1258 struct ddb *dev = input->port->dev;
1260 spin_lock(&input->lock);
1261 if (!input->running) {
1262 spin_unlock(&input->lock);
1265 input->stat = ddbreadl(DMA_BUFFER_CURRENT(input->nr));
1267 if (input->port->class == DDB_PORT_TUNER) {
1268 if (4&ddbreadl(DMA_BUFFER_CONTROL(input->nr)))
1269 dev_err(&dev->pdev->dev, "Overflow input %d\n", input->nr);
1270 while (input->cbuf != ((input->stat >> 11) & 0x1f)
1271 || (4 & safe_ddbreadl(dev, DMA_BUFFER_CONTROL(input->nr)))) {
1272 dvb_dmx_swfilter_packets(&input->demux,
1273 input->vbuf[input->cbuf],
1274 input->dma_buf_size / 188);
1276 input->cbuf = (input->cbuf + 1) % input->dma_buf_num;
1277 ddbwritel((input->cbuf << 11),
1278 DMA_BUFFER_ACK(input->nr));
1279 input->stat = ddbreadl(DMA_BUFFER_CURRENT(input->nr));
1282 if (input->port->class == DDB_PORT_CI)
1283 wake_up(&input->wq);
1284 spin_unlock(&input->lock);
1287 static void output_tasklet(unsigned long data)
1289 struct ddb_output *output = (struct ddb_output *) data;
1290 struct ddb *dev = output->port->dev;
1292 spin_lock(&output->lock);
1293 if (!output->running) {
1294 spin_unlock(&output->lock);
1297 output->stat = ddbreadl(DMA_BUFFER_CURRENT(output->nr + 8));
1298 wake_up(&output->wq);
1299 spin_unlock(&output->lock);
1303 static struct cxd2099_cfg cxd_cfg = {
1311 static int ddb_ci_attach(struct ddb_port *port)
1315 ret = dvb_register_adapter(&port->output->adap,
1318 &port->dev->pdev->dev,
1322 port->en = cxd2099_attach(&cxd_cfg, port, &port->i2c->adap);
1324 dvb_unregister_adapter(&port->output->adap);
1327 ddb_input_start(port->input[0]);
1328 ddb_output_start(port->output);
1329 dvb_ca_en50221_init(&port->output->adap,
1331 ret = dvb_register_device(&port->output->adap, &port->output->dev,
1332 &dvbdev_ci, (void *) port->output,
1337 static int ddb_port_attach(struct ddb_port *port)
1339 struct device *dev = &port->dev->pdev->dev;
1342 switch (port->class) {
1343 case DDB_PORT_TUNER:
1344 ret = dvb_input_attach(port->input[0]);
1347 ret = dvb_input_attach(port->input[1]);
1350 ret = ddb_ci_attach(port);
1356 dev_err(dev, "port_attach on port %d failed\n", port->nr);
1360 static int ddb_ports_attach(struct ddb *dev)
1363 struct ddb_port *port;
1365 for (i = 0; i < dev->info->port_num; i++) {
1366 port = &dev->port[i];
1367 ret = ddb_port_attach(port);
1374 static void ddb_ports_detach(struct ddb *dev)
1377 struct ddb_port *port;
1379 for (i = 0; i < dev->info->port_num; i++) {
1380 port = &dev->port[i];
1381 switch (port->class) {
1382 case DDB_PORT_TUNER:
1383 dvb_input_detach(port->input[0]);
1384 dvb_input_detach(port->input[1]);
1387 dvb_unregister_device(port->output->dev);
1389 ddb_input_stop(port->input[0]);
1390 ddb_output_stop(port->output);
1391 dvb_ca_en50221_release(port->en);
1394 dvb_unregister_adapter(&port->output->adap);
1401 /****************************************************************************/
1402 /****************************************************************************/
1404 static int init_xo2(struct ddb_port *port)
1406 struct i2c_adapter *i2c = &port->i2c->adap;
1407 struct device *dev = &port->dev->pdev->dev;
1411 res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1415 if (data[0] != 0x01) {
1416 dev_info(dev, "Port %d: invalid XO2\n", port->nr);
1420 i2c_read_reg(i2c, 0x10, 0x08, &val);
1422 i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1425 /* Enable tuner power, disable pll, reset demods */
1426 i2c_write_reg(i2c, 0x10, 0x08, 0x04);
1427 usleep_range(2000, 3000);
1428 /* Release demod resets */
1429 i2c_write_reg(i2c, 0x10, 0x08, 0x07);
1431 /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1432 i2c_write_reg(i2c, 0x10, 0x09,
1433 ((xo2_speed >= 0 && xo2_speed <= 3) ? xo2_speed : 2));
1435 i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1436 i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1438 usleep_range(2000, 3000);
1440 i2c_write_reg(i2c, 0x10, 0x08, 0x87);
1445 static int port_has_xo2(struct ddb_port *port, u8 *type, u8 *id)
1447 u8 probe[1] = { 0x00 }, data[4];
1449 *type = DDB_XO2_TYPE_NONE;
1451 if (i2c_io(&port->i2c->adap, 0x10, probe, 1, data, 4))
1453 if (data[0] == 'D' && data[1] == 'F') {
1455 *type = DDB_XO2_TYPE_DUOFLEX;
1458 if (data[0] == 'C' && data[1] == 'I') {
1460 *type = DDB_XO2_TYPE_CI;
1466 /****************************************************************************/
1467 /****************************************************************************/
1469 static int port_has_ci(struct ddb_port *port)
1472 return i2c_read_reg(&port->i2c->adap, 0x40, 0, &val) ? 0 : 1;
1475 static int port_has_stv0900(struct ddb_port *port)
1478 if (i2c_read_reg16(&port->i2c->adap, 0x69, 0xf100, &val) < 0)
1483 static int port_has_stv0900_aa(struct ddb_port *port)
1486 if (i2c_read_reg16(&port->i2c->adap, 0x68, 0xf100, &val) < 0)
1491 static int port_has_drxks(struct ddb_port *port)
1494 if (i2c_read(&port->i2c->adap, 0x29, &val) < 0)
1496 if (i2c_read(&port->i2c->adap, 0x2a, &val) < 0)
1501 static int port_has_stv0367(struct ddb_port *port)
1504 if (i2c_read_reg16(&port->i2c->adap, 0x1e, 0xf000, &val) < 0)
1508 if (i2c_read_reg16(&port->i2c->adap, 0x1f, 0xf000, &val) < 0)
1515 static int port_has_cxd28xx(struct ddb_port *port, u8 *id)
1517 struct i2c_adapter *i2c = &port->i2c->adap;
1520 status = i2c_write_reg(&port->i2c->adap, 0x6e, 0, 0);
1523 status = i2c_read_reg(i2c, 0x6e, 0xfd, id);
1529 static void ddb_port_probe(struct ddb_port *port)
1531 struct ddb *dev = port->dev;
1532 char *modname = "NO MODULE";
1533 u8 xo2_type, xo2_id, cxd_id;
1535 port->class = DDB_PORT_NONE;
1537 if (port_has_ci(port)) {
1539 port->class = DDB_PORT_CI;
1540 ddbwritel(I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1541 } else if (port_has_xo2(port, &xo2_type, &xo2_id)) {
1542 dev_dbg(&dev->pdev->dev, "Port %d (TAB %d): XO2 type: %d, id: %d\n",
1543 port->nr, port->nr+1, xo2_type, xo2_id);
1545 ddbwritel(I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1548 case DDB_XO2_TYPE_DUOFLEX:
1550 switch (xo2_id >> 2) {
1552 modname = "DUAL DVB-S2 (unsupported)";
1553 port->class = DDB_PORT_NONE;
1554 port->type = DDB_TUNER_XO2_DVBS_STV0910;
1557 modname = "DUAL DVB-C/T/T2";
1558 port->class = DDB_PORT_TUNER;
1559 port->type = DDB_TUNER_XO2_DVBCT2_SONY;
1562 modname = "DUAL DVB-ISDBT";
1563 port->class = DDB_PORT_TUNER;
1564 port->type = DDB_TUNER_XO2_ISDBT_SONY;
1567 modname = "DUAL DVB-C/C2/T/T2";
1568 port->class = DDB_PORT_TUNER;
1569 port->type = DDB_TUNER_XO2_DVBC2T2_SONY;
1572 modname = "DUAL ATSC (unsupported)";
1573 port->class = DDB_PORT_NONE;
1574 port->type = DDB_TUNER_XO2_ATSC_ST;
1577 modname = "DUAL DVB-C/C2/T/T2/ISDBT";
1578 port->class = DDB_PORT_TUNER;
1579 port->type = DDB_TUNER_XO2_DVBC2T2I_SONY;
1582 modname = "Unknown XO2 DuoFlex module\n";
1586 case DDB_XO2_TYPE_CI:
1587 dev_info(&dev->pdev->dev, "DuoFlex CI modules not supported\n");
1590 dev_info(&dev->pdev->dev, "Unknown XO2 DuoFlex module\n");
1593 } else if (port_has_cxd28xx(port, &cxd_id)) {
1596 modname = "DUAL DVB-C2T2 CXD2843";
1597 port->class = DDB_PORT_TUNER;
1598 port->type = DDB_TUNER_DVBC2T2_SONY_P;
1601 modname = "DUAL DVB-CT2 CXD2837";
1602 port->class = DDB_PORT_TUNER;
1603 port->type = DDB_TUNER_DVBCT2_SONY_P;
1606 modname = "DUAL ISDB-T CXD2838";
1607 port->class = DDB_PORT_TUNER;
1608 port->type = DDB_TUNER_ISDBT_SONY_P;
1611 modname = "DUAL DVB-C2T2 ISDB-T CXD2854";
1612 port->class = DDB_PORT_TUNER;
1613 port->type = DDB_TUNER_DVBC2T2I_SONY_P;
1616 modname = "Unknown CXD28xx tuner";
1619 ddbwritel(I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1620 } else if (port_has_stv0900(port)) {
1621 modname = "DUAL DVB-S2";
1622 port->class = DDB_PORT_TUNER;
1623 port->type = DDB_TUNER_DVBS_ST;
1624 ddbwritel(I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1625 } else if (port_has_stv0900_aa(port)) {
1626 modname = "DUAL DVB-S2";
1627 port->class = DDB_PORT_TUNER;
1628 port->type = DDB_TUNER_DVBS_ST_AA;
1629 ddbwritel(I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1630 } else if (port_has_drxks(port)) {
1631 modname = "DUAL DVB-C/T";
1632 port->class = DDB_PORT_TUNER;
1633 port->type = DDB_TUNER_DVBCT_TR;
1634 ddbwritel(I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1635 } else if (port_has_stv0367(port)) {
1636 modname = "DUAL DVB-C/T";
1637 port->class = DDB_PORT_TUNER;
1638 port->type = DDB_TUNER_DVBCT_ST;
1639 ddbwritel(I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1642 dev_info(&dev->pdev->dev, "Port %d (TAB %d): %s\n",
1643 port->nr, port->nr+1, modname);
1646 static void ddb_input_init(struct ddb_port *port, int nr)
1648 struct ddb *dev = port->dev;
1649 struct ddb_input *input = &dev->input[nr];
1653 input->dma_buf_num = INPUT_DMA_BUFS;
1654 input->dma_buf_size = INPUT_DMA_SIZE;
1655 ddbwritel(0, TS_INPUT_CONTROL(nr));
1656 ddbwritel(2, TS_INPUT_CONTROL(nr));
1657 ddbwritel(0, TS_INPUT_CONTROL(nr));
1658 ddbwritel(0, DMA_BUFFER_ACK(nr));
1659 tasklet_init(&input->tasklet, input_tasklet, (unsigned long) input);
1660 spin_lock_init(&input->lock);
1661 init_waitqueue_head(&input->wq);
1664 static void ddb_output_init(struct ddb_port *port, int nr)
1666 struct ddb *dev = port->dev;
1667 struct ddb_output *output = &dev->output[nr];
1669 output->port = port;
1670 output->dma_buf_num = OUTPUT_DMA_BUFS;
1671 output->dma_buf_size = OUTPUT_DMA_SIZE;
1673 ddbwritel(0, TS_OUTPUT_CONTROL(nr));
1674 ddbwritel(2, TS_OUTPUT_CONTROL(nr));
1675 ddbwritel(0, TS_OUTPUT_CONTROL(nr));
1676 tasklet_init(&output->tasklet, output_tasklet, (unsigned long) output);
1677 init_waitqueue_head(&output->wq);
1680 static void ddb_ports_init(struct ddb *dev)
1683 struct ddb_port *port;
1685 for (i = 0; i < dev->info->port_num; i++) {
1686 port = &dev->port[i];
1689 port->i2c = &dev->i2c[i];
1690 port->input[0] = &dev->input[2 * i];
1691 port->input[1] = &dev->input[2 * i + 1];
1692 port->output = &dev->output[i];
1694 mutex_init(&port->i2c_gate_lock);
1695 ddb_port_probe(port);
1696 ddb_input_init(port, 2 * i);
1697 ddb_input_init(port, 2 * i + 1);
1698 ddb_output_init(port, i);
1702 static void ddb_ports_release(struct ddb *dev)
1705 struct ddb_port *port;
1707 for (i = 0; i < dev->info->port_num; i++) {
1708 port = &dev->port[i];
1710 tasklet_kill(&port->input[0]->tasklet);
1711 tasklet_kill(&port->input[1]->tasklet);
1712 tasklet_kill(&port->output->tasklet);
1716 /****************************************************************************/
1717 /****************************************************************************/
1718 /****************************************************************************/
1720 static void irq_handle_i2c(struct ddb *dev, int n)
1722 struct ddb_i2c *i2c = &dev->i2c[n];
1728 static irqreturn_t irq_handler(int irq, void *dev_id)
1730 struct ddb *dev = (struct ddb *) dev_id;
1731 u32 s = ddbreadl(INTERRUPT_STATUS);
1737 ddbwritel(s, INTERRUPT_ACK);
1740 irq_handle_i2c(dev, 0);
1742 irq_handle_i2c(dev, 1);
1744 irq_handle_i2c(dev, 2);
1746 irq_handle_i2c(dev, 3);
1749 tasklet_schedule(&dev->input[0].tasklet);
1751 tasklet_schedule(&dev->input[1].tasklet);
1753 tasklet_schedule(&dev->input[2].tasklet);
1755 tasklet_schedule(&dev->input[3].tasklet);
1757 tasklet_schedule(&dev->input[4].tasklet);
1759 tasklet_schedule(&dev->input[5].tasklet);
1761 tasklet_schedule(&dev->input[6].tasklet);
1763 tasklet_schedule(&dev->input[7].tasklet);
1766 tasklet_schedule(&dev->output[0].tasklet);
1768 tasklet_schedule(&dev->output[1].tasklet);
1770 tasklet_schedule(&dev->output[2].tasklet);
1772 tasklet_schedule(&dev->output[3].tasklet);
1774 /* if (s & 0x000f0000) printk(KERN_DEBUG "%08x\n", istat); */
1775 } while ((s = ddbreadl(INTERRUPT_STATUS)));
1780 /******************************************************************************/
1781 /******************************************************************************/
1782 /******************************************************************************/
1784 static int flashio(struct ddb *dev, u8 *wbuf, u32 wlen, u8 *rbuf, u32 rlen)
1789 ddbwritel(1, SPI_CONTROL);
1791 /* FIXME: check for big-endian */
1792 data = swab32(*(u32 *)wbuf);
1795 ddbwritel(data, SPI_DATA);
1796 while (safe_ddbreadl(dev, SPI_CONTROL) & 0x0004)
1801 ddbwritel(0x0001 | ((wlen << (8 + 3)) & 0x1f00), SPI_CONTROL);
1803 ddbwritel(0x0003 | ((wlen << (8 + 3)) & 0x1f00), SPI_CONTROL);
1806 shift = ((4 - wlen) * 8);
1815 ddbwritel(data, SPI_DATA);
1816 while (safe_ddbreadl(dev, SPI_CONTROL) & 0x0004)
1820 ddbwritel(0, SPI_CONTROL);
1824 ddbwritel(1, SPI_CONTROL);
1827 ddbwritel(0xffffffff, SPI_DATA);
1828 while (safe_ddbreadl(dev, SPI_CONTROL) & 0x0004)
1830 data = ddbreadl(SPI_DATA);
1831 *(u32 *) rbuf = swab32(data);
1835 ddbwritel(0x0003 | ((rlen << (8 + 3)) & 0x1F00), SPI_CONTROL);
1836 ddbwritel(0xffffffff, SPI_DATA);
1837 while (safe_ddbreadl(dev, SPI_CONTROL) & 0x0004)
1840 data = ddbreadl(SPI_DATA);
1841 ddbwritel(0, SPI_CONTROL);
1844 data <<= ((4 - rlen) * 8);
1847 *rbuf = ((data >> 24) & 0xff);
1855 #define DDB_MAGIC 'd'
1857 struct ddb_flashio {
1858 __user __u8 *write_buf;
1860 __user __u8 *read_buf;
1864 #define IOCTL_DDB_FLASHIO _IOWR(DDB_MAGIC, 0x00, struct ddb_flashio)
1866 #define DDB_NAME "ddbridge"
1869 static struct ddb *ddbs[32];
1870 static struct class *ddb_class;
1871 static int ddb_major;
1873 static int ddb_open(struct inode *inode, struct file *file)
1875 struct ddb *dev = ddbs[iminor(inode)];
1877 file->private_data = dev;
1881 static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1883 struct ddb *dev = file->private_data;
1884 __user void *parg = (__user void *)arg;
1888 case IOCTL_DDB_FLASHIO:
1890 struct ddb_flashio fio;
1893 if (copy_from_user(&fio, parg, sizeof(fio)))
1896 if (fio.write_len > 1028 || fio.read_len > 1028)
1898 if (fio.write_len + fio.read_len > 1028)
1901 wbuf = &dev->iobuf[0];
1902 rbuf = wbuf + fio.write_len;
1904 if (copy_from_user(wbuf, fio.write_buf, fio.write_len))
1906 res = flashio(dev, wbuf, fio.write_len, rbuf, fio.read_len);
1909 if (copy_to_user(fio.read_buf, rbuf, fio.read_len))
1919 static const struct file_operations ddb_fops = {
1920 .unlocked_ioctl = ddb_ioctl,
1924 static char *ddb_devnode(struct device *device, umode_t *mode)
1926 struct ddb *dev = dev_get_drvdata(device);
1928 return kasprintf(GFP_KERNEL, "ddbridge/card%d", dev->nr);
1931 static int ddb_class_create(void)
1933 ddb_major = register_chrdev(0, DDB_NAME, &ddb_fops);
1937 ddb_class = class_create(THIS_MODULE, DDB_NAME);
1938 if (IS_ERR(ddb_class)) {
1939 unregister_chrdev(ddb_major, DDB_NAME);
1940 return PTR_ERR(ddb_class);
1942 ddb_class->devnode = ddb_devnode;
1946 static void ddb_class_destroy(void)
1948 class_destroy(ddb_class);
1949 unregister_chrdev(ddb_major, DDB_NAME);
1952 static int ddb_device_create(struct ddb *dev)
1954 dev->nr = ddb_num++;
1955 dev->ddb_dev = device_create(ddb_class, NULL,
1956 MKDEV(ddb_major, dev->nr),
1957 dev, "ddbridge%d", dev->nr);
1958 ddbs[dev->nr] = dev;
1959 if (IS_ERR(dev->ddb_dev))
1964 static void ddb_device_destroy(struct ddb *dev)
1967 if (IS_ERR(dev->ddb_dev))
1969 device_destroy(ddb_class, MKDEV(ddb_major, 0));
1973 /****************************************************************************/
1974 /****************************************************************************/
1975 /****************************************************************************/
1977 static void ddb_unmap(struct ddb *dev)
1985 static void ddb_remove(struct pci_dev *pdev)
1987 struct ddb *dev = pci_get_drvdata(pdev);
1989 ddb_ports_detach(dev);
1990 ddb_i2c_release(dev);
1992 ddbwritel(0, INTERRUPT_ENABLE);
1993 free_irq(dev->pdev->irq, dev);
1994 #ifdef CONFIG_PCI_MSI
1996 pci_disable_msi(dev->pdev);
1998 ddb_ports_release(dev);
1999 ddb_buffers_free(dev);
2000 ddb_device_destroy(dev);
2003 pci_set_drvdata(pdev, NULL);
2004 pci_disable_device(pdev);
2008 static int ddb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2012 int irq_flag = IRQF_SHARED;
2014 if (pci_enable_device(pdev) < 0)
2017 dev = vzalloc(sizeof(struct ddb));
2022 pci_set_drvdata(pdev, dev);
2023 dev->info = (struct ddb_info *) id->driver_data;
2024 dev_info(&pdev->dev, "Detected %s\n", dev->info->name);
2026 dev->regs = ioremap(pci_resource_start(dev->pdev, 0),
2027 pci_resource_len(dev->pdev, 0));
2032 dev_info(&pdev->dev, "HW %08x FW %08x\n", ddbreadl(0), ddbreadl(4));
2034 #ifdef CONFIG_PCI_MSI
2035 if (pci_msi_enabled())
2036 stat = pci_enable_msi(dev->pdev);
2038 dev_info(&pdev->dev, "MSI not available.\n");
2044 stat = request_irq(dev->pdev->irq, irq_handler,
2045 irq_flag, "DDBridge", (void *) dev);
2048 ddbwritel(0, DMA_BASE_WRITE);
2049 ddbwritel(0, DMA_BASE_READ);
2050 ddbwritel(0xffffffff, INTERRUPT_ACK);
2051 ddbwritel(0xfff0f, INTERRUPT_ENABLE);
2052 ddbwritel(0, MSI1_ENABLE);
2055 if (dev->info->board_control) {
2056 ddbwritel(0, DDB_LINK_TAG(0) | BOARD_CONTROL);
2058 ddbwritel(dev->info->board_control_2,
2059 DDB_LINK_TAG(0) | BOARD_CONTROL);
2060 usleep_range(2000, 3000);
2061 ddbwritel(dev->info->board_control_2
2062 | dev->info->board_control,
2063 DDB_LINK_TAG(0) | BOARD_CONTROL);
2064 usleep_range(2000, 3000);
2067 if (ddb_i2c_init(dev) < 0)
2069 ddb_ports_init(dev);
2070 if (ddb_buffers_alloc(dev) < 0) {
2071 dev_err(&pdev->dev, "Could not allocate buffer memory\n");
2074 if (ddb_ports_attach(dev) < 0)
2076 ddb_device_create(dev);
2080 ddb_ports_detach(dev);
2081 dev_err(&pdev->dev, "fail3\n");
2082 ddb_ports_release(dev);
2084 dev_err(&pdev->dev, "fail2\n");
2085 ddb_buffers_free(dev);
2087 dev_err(&pdev->dev, "fail1\n");
2089 pci_disable_msi(dev->pdev);
2091 free_irq(dev->pdev->irq, dev);
2093 dev_err(&pdev->dev, "fail\n");
2095 pci_set_drvdata(pdev, NULL);
2096 pci_disable_device(pdev);
2100 /******************************************************************************/
2101 /******************************************************************************/
2102 /******************************************************************************/
2104 static const struct ddb_info ddb_none = {
2106 .name = "Digital Devices PCIe bridge",
2109 static const struct ddb_info ddb_octopus = {
2110 .type = DDB_OCTOPUS,
2111 .name = "Digital Devices Octopus DVB adapter",
2115 static const struct ddb_info ddb_octopus_le = {
2116 .type = DDB_OCTOPUS,
2117 .name = "Digital Devices Octopus LE DVB adapter",
2121 static const struct ddb_info ddb_octopus_oem = {
2122 .type = DDB_OCTOPUS,
2123 .name = "Digital Devices Octopus OEM",
2127 static const struct ddb_info ddb_octopus_mini = {
2128 .type = DDB_OCTOPUS,
2129 .name = "Digital Devices Octopus Mini",
2133 static const struct ddb_info ddb_v6 = {
2134 .type = DDB_OCTOPUS,
2135 .name = "Digital Devices Cine S2 V6 DVB adapter",
2138 static const struct ddb_info ddb_v6_5 = {
2139 .type = DDB_OCTOPUS,
2140 .name = "Digital Devices Cine S2 V6.5 DVB adapter",
2144 static const struct ddb_info ddb_dvbct = {
2145 .type = DDB_OCTOPUS,
2146 .name = "Digital Devices DVBCT V6.1 DVB adapter",
2150 static const struct ddb_info ddb_ctv7 = {
2151 .type = DDB_OCTOPUS,
2152 .name = "Digital Devices Cine CT V7 DVB adapter",
2155 .board_control_2 = 4,
2158 static const struct ddb_info ddb_satixS2v3 = {
2159 .type = DDB_OCTOPUS,
2160 .name = "Mystique SaTiX-S2 V3 DVB adapter",
2164 static const struct ddb_info ddb_octopusv3 = {
2165 .type = DDB_OCTOPUS,
2166 .name = "Digital Devices Octopus V3 DVB adapter",
2170 /*** MaxA8 adapters ***********************************************************/
2172 static struct ddb_info ddb_ct2_8 = {
2173 .type = DDB_OCTOPUS_MAX_CT,
2174 .name = "Digital Devices MAX A8 CT2",
2176 .board_control = 0x0ff,
2177 .board_control_2 = 0xf00,
2178 .ts_quirks = TS_QUIRK_SERIAL,
2181 static struct ddb_info ddb_c2t2_8 = {
2182 .type = DDB_OCTOPUS_MAX_CT,
2183 .name = "Digital Devices MAX A8 C2T2",
2185 .board_control = 0x0ff,
2186 .board_control_2 = 0xf00,
2187 .ts_quirks = TS_QUIRK_SERIAL,
2190 static struct ddb_info ddb_isdbt_8 = {
2191 .type = DDB_OCTOPUS_MAX_CT,
2192 .name = "Digital Devices MAX A8 ISDBT",
2194 .board_control = 0x0ff,
2195 .board_control_2 = 0xf00,
2196 .ts_quirks = TS_QUIRK_SERIAL,
2199 static struct ddb_info ddb_c2t2i_v0_8 = {
2200 .type = DDB_OCTOPUS_MAX_CT,
2201 .name = "Digital Devices MAX A8 C2T2I V0",
2203 .board_control = 0x0ff,
2204 .board_control_2 = 0xf00,
2205 .ts_quirks = TS_QUIRK_SERIAL | TS_QUIRK_ALT_OSC,
2208 static struct ddb_info ddb_c2t2i_8 = {
2209 .type = DDB_OCTOPUS_MAX_CT,
2210 .name = "Digital Devices MAX A8 C2T2I",
2212 .board_control = 0x0ff,
2213 .board_control_2 = 0xf00,
2214 .ts_quirks = TS_QUIRK_SERIAL,
2217 /******************************************************************************/
2219 #define DDVID 0xdd01 /* Digital Devices Vendor ID */
2221 #define DDB_ID(_vend, _dev, _subvend, _subdev, _driverdata) { \
2222 .vendor = _vend, .device = _dev, \
2223 .subvendor = _subvend, .subdevice = _subdev, \
2224 .driver_data = (unsigned long)&_driverdata }
2226 static const struct pci_device_id ddb_id_tbl[] = {
2227 DDB_ID(DDVID, 0x0002, DDVID, 0x0001, ddb_octopus),
2228 DDB_ID(DDVID, 0x0003, DDVID, 0x0001, ddb_octopus),
2229 DDB_ID(DDVID, 0x0005, DDVID, 0x0004, ddb_octopusv3),
2230 DDB_ID(DDVID, 0x0003, DDVID, 0x0002, ddb_octopus_le),
2231 DDB_ID(DDVID, 0x0003, DDVID, 0x0003, ddb_octopus_oem),
2232 DDB_ID(DDVID, 0x0003, DDVID, 0x0010, ddb_octopus_mini),
2233 DDB_ID(DDVID, 0x0005, DDVID, 0x0011, ddb_octopus_mini),
2234 DDB_ID(DDVID, 0x0003, DDVID, 0x0020, ddb_v6),
2235 DDB_ID(DDVID, 0x0003, DDVID, 0x0021, ddb_v6_5),
2236 DDB_ID(DDVID, 0x0003, DDVID, 0x0030, ddb_dvbct),
2237 DDB_ID(DDVID, 0x0003, DDVID, 0xdb03, ddb_satixS2v3),
2238 DDB_ID(DDVID, 0x0006, DDVID, 0x0031, ddb_ctv7),
2239 DDB_ID(DDVID, 0x0006, DDVID, 0x0032, ddb_ctv7),
2240 DDB_ID(DDVID, 0x0006, DDVID, 0x0033, ddb_ctv7),
2241 DDB_ID(DDVID, 0x0008, DDVID, 0x0034, ddb_ct2_8),
2242 DDB_ID(DDVID, 0x0008, DDVID, 0x0035, ddb_c2t2_8),
2243 DDB_ID(DDVID, 0x0008, DDVID, 0x0036, ddb_isdbt_8),
2244 DDB_ID(DDVID, 0x0008, DDVID, 0x0037, ddb_c2t2i_v0_8),
2245 DDB_ID(DDVID, 0x0008, DDVID, 0x0038, ddb_c2t2i_8),
2246 DDB_ID(DDVID, 0x0006, DDVID, 0x0039, ddb_ctv7),
2247 /* in case sub-ids got deleted in flash */
2248 DDB_ID(DDVID, 0x0003, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2249 DDB_ID(DDVID, 0x0005, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2250 DDB_ID(DDVID, 0x0006, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2251 DDB_ID(DDVID, 0x0007, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2252 DDB_ID(DDVID, 0x0008, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2253 DDB_ID(DDVID, 0x0011, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2254 DDB_ID(DDVID, 0x0013, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2255 DDB_ID(DDVID, 0x0201, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2256 DDB_ID(DDVID, 0x0320, PCI_ANY_ID, PCI_ANY_ID, ddb_none),
2259 MODULE_DEVICE_TABLE(pci, ddb_id_tbl);
2262 static struct pci_driver ddb_pci_driver = {
2264 .id_table = ddb_id_tbl,
2266 .remove = ddb_remove,
2269 static __init int module_init_ddbridge(void)
2273 pr_info("Digital Devices PCIE bridge driver, Copyright (C) 2010-11 Digital Devices GmbH\n");
2275 ret = ddb_class_create();
2278 ret = pci_register_driver(&ddb_pci_driver);
2280 ddb_class_destroy();
2284 static __exit void module_exit_ddbridge(void)
2286 pci_unregister_driver(&ddb_pci_driver);
2287 ddb_class_destroy();
2290 module_init(module_init_ddbridge);
2291 module_exit(module_exit_ddbridge);
2293 MODULE_DESCRIPTION("Digital Devices PCIe Bridge");
2294 MODULE_AUTHOR("Ralph Metzler");
2295 MODULE_LICENSE("GPL");
2296 MODULE_VERSION("0.5");