2 * ddbridge-core.c: Digital Devices bridge core functions
4 * Copyright (C) 2010-2017 Digital Devices GmbH
5 * Marcus Metzler <mocm@metzlerbros.de>
6 * Ralph Metzler <rjkm@metzlerbros.de>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 only, as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * To obtain the license, point your browser to
20 * http://www.gnu.org/copyleft/gpl.html
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/delay.h>
27 #include <linux/slab.h>
28 #include <linux/poll.h>
30 #include <linux/pci.h>
31 #include <linux/pci_ids.h>
32 #include <linux/timer.h>
33 #include <linux/i2c.h>
34 #include <linux/swab.h>
35 #include <linux/vmalloc.h>
38 #include "ddbridge-i2c.h"
39 #include "ddbridge-regs.h"
40 #include "ddbridge-maxs8.h"
41 #include "ddbridge-io.h"
43 #include "tda18271c2dd.h"
49 #include "stv0367_priv.h"
50 #include "cxd2841er.h"
57 /****************************************************************************/
59 #define DDB_MAX_ADAPTER 64
61 /****************************************************************************/
63 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
65 static int adapter_alloc;
66 module_param(adapter_alloc, int, 0444);
67 MODULE_PARM_DESC(adapter_alloc,
68 "0-one adapter per io, 1-one per tab with io, 2-one per tab, 3-one for all");
70 /****************************************************************************/
72 static DEFINE_MUTEX(redirect_lock);
74 struct workqueue_struct *ddb_wq;
76 static struct ddb *ddbs[DDB_MAX_ADAPTER];
78 /****************************************************************************/
79 /****************************************************************************/
80 /****************************************************************************/
82 static void ddb_set_dma_table(struct ddb_io *io)
84 struct ddb *dev = io->port->dev;
85 struct ddb_dma *dma = io->dma;
91 for (i = 0; i < dma->num; i++) {
93 ddbwritel(dev, mem & 0xffffffff, dma->bufregs + i * 8);
94 ddbwritel(dev, mem >> 32, dma->bufregs + i * 8 + 4);
96 dma->bufval = ((dma->div & 0x0f) << 16) |
97 ((dma->num & 0x1f) << 11) |
98 ((dma->size >> 7) & 0x7ff);
101 static void ddb_set_dma_tables(struct ddb *dev)
105 for (i = 0; i < DDB_MAX_PORT; i++) {
106 if (dev->port[i].input[0])
107 ddb_set_dma_table(dev->port[i].input[0]);
108 if (dev->port[i].input[1])
109 ddb_set_dma_table(dev->port[i].input[1]);
110 if (dev->port[i].output)
111 ddb_set_dma_table(dev->port[i].output);
116 /****************************************************************************/
117 /****************************************************************************/
118 /****************************************************************************/
120 static void ddb_redirect_dma(struct ddb *dev,
121 struct ddb_dma *sdma,
122 struct ddb_dma *ddma)
127 sdma->bufval = ddma->bufval;
128 base = sdma->bufregs;
129 for (i = 0; i < ddma->num; i++) {
131 ddbwritel(dev, mem & 0xffffffff, base + i * 8);
132 ddbwritel(dev, mem >> 32, base + i * 8 + 4);
136 static int ddb_unredirect(struct ddb_port *port)
138 struct ddb_input *oredi, *iredi = NULL;
139 struct ddb_output *iredo = NULL;
141 /* dev_info(port->dev->dev,
142 * "unredirect %d.%d\n", port->dev->nr, port->nr);
144 mutex_lock(&redirect_lock);
145 if (port->output->dma->running) {
146 mutex_unlock(&redirect_lock);
149 oredi = port->output->redi;
152 if (port->input[0]) {
153 iredi = port->input[0]->redi;
154 iredo = port->input[0]->redo;
157 iredo->port->output->redi = oredi;
158 if (iredo->port->input[0]) {
159 iredo->port->input[0]->redi = iredi;
160 ddb_redirect_dma(oredi->port->dev,
161 oredi->dma, iredo->dma);
163 port->input[0]->redo = NULL;
164 ddb_set_dma_table(port->input[0]);
167 port->input[0]->redi = NULL;
170 port->output->redi = NULL;
172 ddb_set_dma_table(oredi);
174 mutex_unlock(&redirect_lock);
178 static int ddb_redirect(u32 i, u32 p)
180 struct ddb *idev = ddbs[(i >> 4) & 0x3f];
181 struct ddb_input *input, *input2;
182 struct ddb *pdev = ddbs[(p >> 4) & 0x3f];
183 struct ddb_port *port;
187 if (!idev->has_dma || !pdev->has_dma)
190 port = &pdev->port[p & 0x0f];
193 if (ddb_unredirect(port))
199 input = &idev->input[i & 7];
203 mutex_lock(&redirect_lock);
204 if (port->output->dma->running || input->dma->running) {
205 mutex_unlock(&redirect_lock);
208 input2 = port->input[0];
211 input2->redi = input->redi;
214 input2->redi = input;
216 input->redo = port->output;
217 port->output->redi = input;
219 ddb_redirect_dma(input->port->dev, input->dma, port->output->dma);
220 mutex_unlock(&redirect_lock);
224 /****************************************************************************/
225 /****************************************************************************/
226 /****************************************************************************/
228 static void dma_free(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
234 for (i = 0; i < dma->num; i++) {
237 dma_unmap_single(&pdev->dev, dma->pbuf[i],
239 dir ? DMA_TO_DEVICE :
244 dma_free_coherent(&pdev->dev, dma->size,
245 dma->vbuf[i], dma->pbuf[i]);
253 static int dma_alloc(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
259 for (i = 0; i < dma->num; i++) {
261 dma->vbuf[i] = kmalloc(dma->size, __GFP_RETRY_MAYFAIL);
264 dma->pbuf[i] = dma_map_single(&pdev->dev,
267 dir ? DMA_TO_DEVICE :
269 if (dma_mapping_error(&pdev->dev, dma->pbuf[i])) {
275 dma->vbuf[i] = dma_alloc_coherent(&pdev->dev,
286 int ddb_buffers_alloc(struct ddb *dev)
289 struct ddb_port *port;
291 for (i = 0; i < dev->port_num; i++) {
292 port = &dev->port[i];
293 switch (port->class) {
295 if (port->input[0]->dma)
296 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
299 if (port->input[1]->dma)
300 if (dma_alloc(dev->pdev, port->input[1]->dma, 0)
306 if (port->input[0]->dma)
307 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
310 if (port->output->dma)
311 if (dma_alloc(dev->pdev, port->output->dma, 1)
319 ddb_set_dma_tables(dev);
323 void ddb_buffers_free(struct ddb *dev)
326 struct ddb_port *port;
328 for (i = 0; i < dev->port_num; i++) {
329 port = &dev->port[i];
331 if (port->input[0] && port->input[0]->dma)
332 dma_free(dev->pdev, port->input[0]->dma, 0);
333 if (port->input[1] && port->input[1]->dma)
334 dma_free(dev->pdev, port->input[1]->dma, 0);
335 if (port->output && port->output->dma)
336 dma_free(dev->pdev, port->output->dma, 1);
340 static void calc_con(struct ddb_output *output, u32 *con, u32 *con2, u32 flags)
342 struct ddb *dev = output->port->dev;
343 u32 bitrate = output->port->obr, max_bitrate = 72000;
344 u32 gap = 4, nco = 0;
347 if (output->port->gap != 0xffffffff) {
349 gap = output->port->gap;
352 if (dev->link[0].info->type == DDB_OCTOPUS_CI && output->port->nr > 1) {
354 if (dev->link[0].ids.regmapid >= 0x10003 && !(flags & 1)) {
359 if (bitrate != 72000) {
360 if (bitrate >= 96000)
364 nco = (bitrate * 8192 + 71999)
369 /* Divider and gap */
371 if (bitrate <= 64000) {
374 } else if (bitrate <= 72000) {
383 if (bitrate > 72000) {
384 *con |= 0x810; /* 96 MBit/s and gap */
387 *con |= 0x10; /* enable gap */
390 if (max_bitrate > 0) {
391 if (bitrate > max_bitrate)
392 bitrate = max_bitrate;
395 gap = ((max_bitrate - bitrate) * 94) / bitrate;
397 *con &= ~0x10; /* Disable gap */
404 *con2 = (nco << 16) | gap;
407 static void ddb_output_start(struct ddb_output *output)
409 struct ddb *dev = output->port->dev;
410 u32 con = 0x11c, con2 = 0;
413 spin_lock_irq(&output->dma->lock);
414 output->dma->cbuf = 0;
415 output->dma->coff = 0;
416 output->dma->stat = 0;
417 ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
420 if (output->port->input[0]->port->class == DDB_PORT_LOOP)
421 con = (1UL << 13) | 0x14;
423 calc_con(output, &con, &con2, 0);
425 ddbwritel(dev, 0, TS_CONTROL(output));
426 ddbwritel(dev, 2, TS_CONTROL(output));
427 ddbwritel(dev, 0, TS_CONTROL(output));
428 ddbwritel(dev, con, TS_CONTROL(output));
429 ddbwritel(dev, con2, TS_CONTROL2(output));
432 ddbwritel(dev, output->dma->bufval,
433 DMA_BUFFER_SIZE(output->dma));
434 ddbwritel(dev, 0, DMA_BUFFER_ACK(output->dma));
435 ddbwritel(dev, 1, DMA_BASE_READ);
436 ddbwritel(dev, 7, DMA_BUFFER_CONTROL(output->dma));
439 ddbwritel(dev, con | 1, TS_CONTROL(output));
442 output->dma->running = 1;
443 spin_unlock_irq(&output->dma->lock);
447 static void ddb_output_stop(struct ddb_output *output)
449 struct ddb *dev = output->port->dev;
452 spin_lock_irq(&output->dma->lock);
454 ddbwritel(dev, 0, TS_CONTROL(output));
457 ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
458 output->dma->running = 0;
459 spin_unlock_irq(&output->dma->lock);
463 static void ddb_input_stop(struct ddb_input *input)
465 struct ddb *dev = input->port->dev;
466 u32 tag = DDB_LINK_TAG(input->port->lnr);
469 spin_lock_irq(&input->dma->lock);
470 ddbwritel(dev, 0, tag | TS_CONTROL(input));
472 ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
473 input->dma->running = 0;
474 spin_unlock_irq(&input->dma->lock);
478 static void ddb_input_start(struct ddb_input *input)
480 struct ddb *dev = input->port->dev;
483 spin_lock_irq(&input->dma->lock);
484 input->dma->cbuf = 0;
485 input->dma->coff = 0;
486 input->dma->stat = 0;
487 ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
489 ddbwritel(dev, 0, TS_CONTROL(input));
490 ddbwritel(dev, 2, TS_CONTROL(input));
491 ddbwritel(dev, 0, TS_CONTROL(input));
494 ddbwritel(dev, input->dma->bufval,
495 DMA_BUFFER_SIZE(input->dma));
496 ddbwritel(dev, 0, DMA_BUFFER_ACK(input->dma));
497 ddbwritel(dev, 1, DMA_BASE_WRITE);
498 ddbwritel(dev, 3, DMA_BUFFER_CONTROL(input->dma));
501 ddbwritel(dev, 0x09, TS_CONTROL(input));
504 input->dma->running = 1;
505 spin_unlock_irq(&input->dma->lock);
510 static void ddb_input_start_all(struct ddb_input *input)
512 struct ddb_input *i = input;
513 struct ddb_output *o;
515 mutex_lock(&redirect_lock);
516 while (i && (o = i->redo)) {
518 i = o->port->input[0];
522 ddb_input_start(input);
523 mutex_unlock(&redirect_lock);
526 static void ddb_input_stop_all(struct ddb_input *input)
528 struct ddb_input *i = input;
529 struct ddb_output *o;
531 mutex_lock(&redirect_lock);
532 ddb_input_stop(input);
533 while (i && (o = i->redo)) {
535 i = o->port->input[0];
539 mutex_unlock(&redirect_lock);
542 static u32 ddb_output_free(struct ddb_output *output)
544 u32 idx, off, stat = output->dma->stat;
547 idx = (stat >> 11) & 0x1f;
548 off = (stat & 0x7ff) << 7;
550 if (output->dma->cbuf != idx) {
551 if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
552 (output->dma->size - output->dma->coff <= 188))
556 diff = off - output->dma->coff;
557 if (diff <= 0 || diff > 188)
562 static ssize_t ddb_output_write(struct ddb_output *output,
563 const __user u8 *buf, size_t count)
565 struct ddb *dev = output->port->dev;
566 u32 idx, off, stat = output->dma->stat;
567 u32 left = count, len;
569 idx = (stat >> 11) & 0x1f;
570 off = (stat & 0x7ff) << 7;
573 len = output->dma->size - output->dma->coff;
574 if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
580 if (output->dma->cbuf == idx) {
581 if (off > output->dma->coff) {
582 len = off - output->dma->coff;
591 if (copy_from_user(output->dma->vbuf[output->dma->cbuf] +
596 dma_sync_single_for_device(dev->dev,
597 output->dma->pbuf[output->dma->cbuf],
598 output->dma->size, DMA_TO_DEVICE);
601 output->dma->coff += len;
602 if (output->dma->coff == output->dma->size) {
603 output->dma->coff = 0;
604 output->dma->cbuf = ((output->dma->cbuf + 1) %
608 (output->dma->cbuf << 11) |
609 (output->dma->coff >> 7),
610 DMA_BUFFER_ACK(output->dma));
615 static u32 ddb_input_avail(struct ddb_input *input)
617 struct ddb *dev = input->port->dev;
618 u32 idx, off, stat = input->dma->stat;
619 u32 ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(input->dma));
621 idx = (stat >> 11) & 0x1f;
622 off = (stat & 0x7ff) << 7;
625 dev_err(dev->dev, "IA %d %d %08x\n", idx, off, ctrl);
626 ddbwritel(dev, stat, DMA_BUFFER_ACK(input->dma));
629 if (input->dma->cbuf != idx)
634 static ssize_t ddb_input_read(struct ddb_input *input,
635 __user u8 *buf, size_t count)
637 struct ddb *dev = input->port->dev;
639 u32 idx, free, stat = input->dma->stat;
642 idx = (stat >> 11) & 0x1f;
645 if (input->dma->cbuf == idx)
647 free = input->dma->size - input->dma->coff;
651 dma_sync_single_for_cpu(dev->dev,
652 input->dma->pbuf[input->dma->cbuf],
653 input->dma->size, DMA_FROM_DEVICE);
654 ret = copy_to_user(buf, input->dma->vbuf[input->dma->cbuf] +
655 input->dma->coff, free);
658 input->dma->coff += free;
659 if (input->dma->coff == input->dma->size) {
660 input->dma->coff = 0;
661 input->dma->cbuf = (input->dma->cbuf + 1) %
667 (input->dma->cbuf << 11) | (input->dma->coff >> 7),
668 DMA_BUFFER_ACK(input->dma));
673 /****************************************************************************/
674 /****************************************************************************/
676 static ssize_t ts_write(struct file *file, const __user char *buf,
677 size_t count, loff_t *ppos)
679 struct dvb_device *dvbdev = file->private_data;
680 struct ddb_output *output = dvbdev->priv;
681 struct ddb *dev = output->port->dev;
688 if (ddb_output_free(output) < 188) {
689 if (file->f_flags & O_NONBLOCK)
691 if (wait_event_interruptible(
693 ddb_output_free(output) >= 188) < 0)
696 stat = ddb_output_write(output, buf, left);
702 return (left == count) ? -EAGAIN : (count - left);
705 static ssize_t ts_read(struct file *file, __user char *buf,
706 size_t count, loff_t *ppos)
708 struct dvb_device *dvbdev = file->private_data;
709 struct ddb_output *output = dvbdev->priv;
710 struct ddb_input *input = output->port->input[0];
711 struct ddb *dev = output->port->dev;
718 if (ddb_input_avail(input) < 188) {
719 if (file->f_flags & O_NONBLOCK)
721 if (wait_event_interruptible(
723 ddb_input_avail(input) >= 188) < 0)
726 stat = ddb_input_read(input, buf, left);
732 return (count && (left == count)) ? -EAGAIN : (count - left);
735 static unsigned int ts_poll(struct file *file, poll_table *wait)
737 struct dvb_device *dvbdev = file->private_data;
738 struct ddb_output *output = dvbdev->priv;
739 struct ddb_input *input = output->port->input[0];
741 unsigned int mask = 0;
743 poll_wait(file, &input->dma->wq, wait);
744 poll_wait(file, &output->dma->wq, wait);
745 if (ddb_input_avail(input) >= 188)
746 mask |= POLLIN | POLLRDNORM;
747 if (ddb_output_free(output) >= 188)
748 mask |= POLLOUT | POLLWRNORM;
752 static int ts_release(struct inode *inode, struct file *file)
754 struct dvb_device *dvbdev = file->private_data;
755 struct ddb_output *output = NULL;
756 struct ddb_input *input = NULL;
759 output = dvbdev->priv;
760 input = output->port->input[0];
763 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
766 ddb_input_stop(input);
767 } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
770 ddb_output_stop(output);
772 return dvb_generic_release(inode, file);
775 static int ts_open(struct inode *inode, struct file *file)
778 struct dvb_device *dvbdev = file->private_data;
779 struct ddb_output *output = NULL;
780 struct ddb_input *input = NULL;
783 output = dvbdev->priv;
784 input = output->port->input[0];
787 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
790 if (input->redo || input->redi)
792 } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
797 err = dvb_generic_open(inode, file);
800 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
801 ddb_input_start(input);
802 else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
803 ddb_output_start(output);
807 static const struct file_operations ci_fops = {
808 .owner = THIS_MODULE,
812 .release = ts_release,
817 static struct dvb_device dvbdev_ci = {
826 /****************************************************************************/
827 /****************************************************************************/
829 static int locked_gate_ctrl(struct dvb_frontend *fe, int enable)
831 struct ddb_input *input = fe->sec_priv;
832 struct ddb_port *port = input->port;
833 struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
837 mutex_lock(&port->i2c_gate_lock);
838 status = dvb->i2c_gate_ctrl(fe, 1);
840 status = dvb->i2c_gate_ctrl(fe, 0);
841 mutex_unlock(&port->i2c_gate_lock);
846 static int demod_attach_drxk(struct ddb_input *input)
848 struct i2c_adapter *i2c = &input->port->i2c->adap;
849 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
850 struct device *dev = input->port->dev->dev;
851 struct dvb_frontend *fe;
852 struct drxk_config config;
854 memset(&config, 0, sizeof(config));
855 config.adr = 0x29 + (input->nr & 1);
856 config.microcode_name = "drxk_a3.mc";
858 fe = dvb->fe = dvb_attach(drxk_attach, &config, i2c);
860 dev_err(dev, "No DRXK found!\n");
863 fe->sec_priv = input;
864 dvb->i2c_gate_ctrl = fe->ops.i2c_gate_ctrl;
865 fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
869 static int tuner_attach_tda18271(struct ddb_input *input)
871 struct i2c_adapter *i2c = &input->port->i2c->adap;
872 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
873 struct device *dev = input->port->dev->dev;
874 struct dvb_frontend *fe;
876 if (dvb->fe->ops.i2c_gate_ctrl)
877 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
878 fe = dvb_attach(tda18271c2dd_attach, dvb->fe, i2c, 0x60);
879 if (dvb->fe->ops.i2c_gate_ctrl)
880 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
882 dev_err(dev, "No TDA18271 found!\n");
888 /******************************************************************************/
889 /******************************************************************************/
890 /******************************************************************************/
892 static struct stv0367_config ddb_stv0367_config[] = {
894 .demod_address = 0x1f,
897 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
898 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
899 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
901 .demod_address = 0x1e,
904 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
905 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
906 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
910 static int demod_attach_stv0367(struct ddb_input *input)
912 struct i2c_adapter *i2c = &input->port->i2c->adap;
913 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
914 struct device *dev = input->port->dev->dev;
915 struct dvb_frontend *fe;
917 /* attach frontend */
918 fe = dvb->fe = dvb_attach(stv0367ddb_attach,
919 &ddb_stv0367_config[(input->nr & 1)], i2c);
922 dev_err(dev, "No stv0367 found!\n");
925 fe->sec_priv = input;
926 dvb->i2c_gate_ctrl = fe->ops.i2c_gate_ctrl;
927 fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
931 static int tuner_tda18212_ping(struct ddb_input *input, unsigned short adr)
933 struct i2c_adapter *adapter = &input->port->i2c->adap;
934 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
935 struct device *dev = input->port->dev->dev;
939 dev_dbg(dev, "stv0367-tda18212 tuner ping\n");
940 if (dvb->fe->ops.i2c_gate_ctrl)
941 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
943 if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
944 dev_dbg(dev, "tda18212 ping 1 fail\n");
945 if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
946 dev_warn(dev, "tda18212 ping failed, expect problems\n");
948 if (dvb->fe->ops.i2c_gate_ctrl)
949 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
954 static int demod_attach_cxd28xx(struct ddb_input *input, int par, int osc24)
956 struct i2c_adapter *i2c = &input->port->i2c->adap;
957 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
958 struct device *dev = input->port->dev->dev;
959 struct dvb_frontend *fe;
960 struct cxd2841er_config cfg;
962 /* the cxd2841er driver expects 8bit/shifted I2C addresses */
963 cfg.i2c_addr = ((input->nr & 1) ? 0x6d : 0x6c) << 1;
965 cfg.xtal = osc24 ? SONY_XTAL_24000 : SONY_XTAL_20500;
966 cfg.flags = CXD2841ER_AUTO_IFHZ | CXD2841ER_EARLY_TUNE |
967 CXD2841ER_NO_WAIT_LOCK | CXD2841ER_NO_AGCNEG |
971 cfg.flags |= CXD2841ER_TS_SERIAL;
973 /* attach frontend */
974 fe = dvb->fe = dvb_attach(cxd2841er_attach_t_c, &cfg, i2c);
977 dev_err(dev, "No cxd2837/38/43/54 found!\n");
980 fe->sec_priv = input;
981 dvb->i2c_gate_ctrl = fe->ops.i2c_gate_ctrl;
982 fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
986 static int tuner_attach_tda18212(struct ddb_input *input, u32 porttype)
988 struct i2c_adapter *adapter = &input->port->i2c->adap;
989 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
990 struct device *dev = input->port->dev->dev;
991 struct i2c_client *client;
992 struct tda18212_config config = {
1002 struct i2c_board_info board_info = {
1004 .platform_data = &config,
1008 board_info.addr = 0x63;
1010 board_info.addr = 0x60;
1012 /* due to a hardware quirk with the I2C gate on the stv0367+tda18212
1013 * combo, the tda18212 must be probed by reading it's id _twice_ when
1014 * cold started, or it very likely will fail.
1016 if (porttype == DDB_TUNER_DVBCT_ST)
1017 tuner_tda18212_ping(input, board_info.addr);
1019 request_module(board_info.type);
1021 /* perform tuner init/attach */
1022 client = i2c_new_device(adapter, &board_info);
1023 if (client == NULL || client->dev.driver == NULL)
1026 if (!try_module_get(client->dev.driver->owner)) {
1027 i2c_unregister_device(client);
1031 dvb->i2c_client[0] = client;
1035 dev_notice(dev, "TDA18212 tuner not found. Device is not fully operational.\n");
1039 /****************************************************************************/
1040 /****************************************************************************/
1041 /****************************************************************************/
1043 static struct stv090x_config stv0900 = {
1045 .demod_mode = STV090x_DUAL,
1046 .clk_mode = STV090x_CLK_EXT,
1051 .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
1052 .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
1057 .repeater_level = STV090x_RPTLEVEL_16,
1059 .adc1_range = STV090x_ADC_1Vpp,
1060 .adc2_range = STV090x_ADC_1Vpp,
1062 .diseqc_envelope_mode = true,
1065 static struct stv090x_config stv0900_aa = {
1067 .demod_mode = STV090x_DUAL,
1068 .clk_mode = STV090x_CLK_EXT,
1073 .ts1_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
1074 .ts2_mode = STV090x_TSMODE_SERIAL_PUNCTURED,
1079 .repeater_level = STV090x_RPTLEVEL_16,
1081 .adc1_range = STV090x_ADC_1Vpp,
1082 .adc2_range = STV090x_ADC_1Vpp,
1084 .diseqc_envelope_mode = true,
1087 static struct stv6110x_config stv6110a = {
1093 static struct stv6110x_config stv6110b = {
1099 static int demod_attach_stv0900(struct ddb_input *input, int type)
1101 struct i2c_adapter *i2c = &input->port->i2c->adap;
1102 struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1103 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1104 struct device *dev = input->port->dev->dev;
1106 dvb->fe = dvb_attach(stv090x_attach, feconf, i2c,
1107 (input->nr & 1) ? STV090x_DEMODULATOR_1
1108 : STV090x_DEMODULATOR_0);
1110 dev_err(dev, "No STV0900 found!\n");
1113 if (!dvb_attach(lnbh24_attach, dvb->fe, i2c, 0,
1114 0, (input->nr & 1) ?
1115 (0x09 - type) : (0x0b - type))) {
1116 dev_err(dev, "No LNBH24 found!\n");
1122 static int tuner_attach_stv6110(struct ddb_input *input, int type)
1124 struct i2c_adapter *i2c = &input->port->i2c->adap;
1125 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1126 struct device *dev = input->port->dev->dev;
1127 struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1128 struct stv6110x_config *tunerconf = (input->nr & 1) ?
1129 &stv6110b : &stv6110a;
1130 const struct stv6110x_devctl *ctl;
1132 ctl = dvb_attach(stv6110x_attach, dvb->fe, tunerconf, i2c);
1134 dev_err(dev, "No STV6110X found!\n");
1137 dev_info(dev, "attach tuner input %d adr %02x\n",
1138 input->nr, tunerconf->addr);
1140 feconf->tuner_init = ctl->tuner_init;
1141 feconf->tuner_sleep = ctl->tuner_sleep;
1142 feconf->tuner_set_mode = ctl->tuner_set_mode;
1143 feconf->tuner_set_frequency = ctl->tuner_set_frequency;
1144 feconf->tuner_get_frequency = ctl->tuner_get_frequency;
1145 feconf->tuner_set_bandwidth = ctl->tuner_set_bandwidth;
1146 feconf->tuner_get_bandwidth = ctl->tuner_get_bandwidth;
1147 feconf->tuner_set_bbgain = ctl->tuner_set_bbgain;
1148 feconf->tuner_get_bbgain = ctl->tuner_get_bbgain;
1149 feconf->tuner_set_refclk = ctl->tuner_set_refclk;
1150 feconf->tuner_get_status = ctl->tuner_get_status;
1155 static const struct stv0910_cfg stv0910_p = {
1162 static const struct lnbh25_config lnbh25_cfg = {
1163 .i2c_address = 0x0c << 1,
1164 .data2_config = LNBH25_TEN
1167 static int demod_attach_stv0910(struct ddb_input *input, int type)
1169 struct i2c_adapter *i2c = &input->port->i2c->adap;
1170 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1171 struct device *dev = input->port->dev->dev;
1172 struct stv0910_cfg cfg = stv0910_p;
1173 struct lnbh25_config lnbcfg = lnbh25_cfg;
1180 dvb->fe = dvb_attach(stv0910_attach, i2c, &cfg, (input->nr & 1));
1183 dvb->fe = dvb_attach(stv0910_attach, i2c,
1184 &cfg, (input->nr & 1));
1187 dev_err(dev, "No STV0910 found!\n");
1191 /* attach lnbh25 - leftshift by one as the lnbh25 driver expects 8bit
1194 lnbcfg.i2c_address = (((input->nr & 1) ? 0x0d : 0x0c) << 1);
1195 if (!dvb_attach(lnbh25_attach, dvb->fe, &lnbcfg, i2c)) {
1196 lnbcfg.i2c_address = (((input->nr & 1) ? 0x09 : 0x08) << 1);
1197 if (!dvb_attach(lnbh25_attach, dvb->fe, &lnbcfg, i2c)) {
1198 dev_err(dev, "No LNBH25 found!\n");
1206 static int tuner_attach_stv6111(struct ddb_input *input, int type)
1208 struct i2c_adapter *i2c = &input->port->i2c->adap;
1209 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1210 struct device *dev = input->port->dev->dev;
1211 struct dvb_frontend *fe;
1212 u8 adr = (type ? 0 : 4) + ((input->nr & 1) ? 0x63 : 0x60);
1214 fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr);
1216 fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr & ~4);
1218 dev_err(dev, "No STV6111 found at 0x%02x!\n", adr);
1225 static int start_feed(struct dvb_demux_feed *dvbdmxfeed)
1227 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1228 struct ddb_input *input = dvbdmx->priv;
1229 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1232 ddb_input_start_all(input);
1234 return ++dvb->users;
1237 static int stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1239 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1240 struct ddb_input *input = dvbdmx->priv;
1241 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1246 ddb_input_stop_all(input);
1250 static void dvb_input_detach(struct ddb_input *input)
1252 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1253 struct dvb_demux *dvbdemux = &dvb->demux;
1254 struct i2c_client *client;
1256 switch (dvb->attached) {
1259 dvb_unregister_frontend(dvb->fe2);
1261 dvb_unregister_frontend(dvb->fe);
1265 dvb_frontend_detach(dvb->fe2);
1267 dvb_frontend_detach(dvb->fe);
1268 dvb->fe = dvb->fe2 = NULL;
1271 client = dvb->i2c_client[0];
1273 module_put(client->dev.driver->owner);
1274 i2c_unregister_device(client);
1277 dvb_net_release(&dvb->dvbnet);
1280 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1282 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1283 &dvb->mem_frontend);
1286 dvb_dmxdev_release(&dvb->dmxdev);
1289 dvb_dmx_release(&dvb->demux);
1294 dvb->attached = 0x00;
1297 static int dvb_register_adapters(struct ddb *dev)
1300 struct ddb_port *port;
1301 struct dvb_adapter *adap;
1303 if (adapter_alloc == 3) {
1304 port = &dev->port[0];
1305 adap = port->dvb[0].adap;
1306 ret = dvb_register_adapter(adap, "DDBridge", THIS_MODULE,
1311 port->dvb[0].adap_registered = 1;
1312 for (i = 0; i < dev->port_num; i++) {
1313 port = &dev->port[i];
1314 port->dvb[0].adap = adap;
1315 port->dvb[1].adap = adap;
1320 for (i = 0; i < dev->port_num; i++) {
1321 port = &dev->port[i];
1322 switch (port->class) {
1323 case DDB_PORT_TUNER:
1324 adap = port->dvb[0].adap;
1325 ret = dvb_register_adapter(adap, "DDBridge",
1331 port->dvb[0].adap_registered = 1;
1333 if (adapter_alloc > 0) {
1334 port->dvb[1].adap = port->dvb[0].adap;
1337 adap = port->dvb[1].adap;
1338 ret = dvb_register_adapter(adap, "DDBridge",
1344 port->dvb[1].adap_registered = 1;
1349 adap = port->dvb[0].adap;
1350 ret = dvb_register_adapter(adap, "DDBridge",
1356 port->dvb[0].adap_registered = 1;
1359 if (adapter_alloc < 2)
1361 adap = port->dvb[0].adap;
1362 ret = dvb_register_adapter(adap, "DDBridge",
1368 port->dvb[0].adap_registered = 1;
1375 static void dvb_unregister_adapters(struct ddb *dev)
1378 struct ddb_port *port;
1379 struct ddb_dvb *dvb;
1381 for (i = 0; i < dev->link[0].info->port_num; i++) {
1382 port = &dev->port[i];
1384 dvb = &port->dvb[0];
1385 if (dvb->adap_registered)
1386 dvb_unregister_adapter(dvb->adap);
1387 dvb->adap_registered = 0;
1389 dvb = &port->dvb[1];
1390 if (dvb->adap_registered)
1391 dvb_unregister_adapter(dvb->adap);
1392 dvb->adap_registered = 0;
1396 static int dvb_input_attach(struct ddb_input *input)
1399 struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1400 struct ddb_port *port = input->port;
1401 struct dvb_adapter *adap = dvb->adap;
1402 struct dvb_demux *dvbdemux = &dvb->demux;
1403 int par = 0, osc24 = 0;
1405 dvb->attached = 0x01;
1407 dvbdemux->priv = input;
1408 dvbdemux->dmx.capabilities = DMX_TS_FILTERING |
1409 DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
1410 dvbdemux->start_feed = start_feed;
1411 dvbdemux->stop_feed = stop_feed;
1412 dvbdemux->filternum = dvbdemux->feednum = 256;
1413 ret = dvb_dmx_init(dvbdemux);
1416 dvb->attached = 0x10;
1418 dvb->dmxdev.filternum = 256;
1419 dvb->dmxdev.demux = &dvbdemux->dmx;
1420 ret = dvb_dmxdev_init(&dvb->dmxdev, adap);
1423 dvb->attached = 0x11;
1425 dvb->mem_frontend.source = DMX_MEMORY_FE;
1426 dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->mem_frontend);
1427 dvb->hw_frontend.source = DMX_FRONTEND_0;
1428 dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->hw_frontend);
1429 ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, &dvb->hw_frontend);
1432 dvb->attached = 0x12;
1434 ret = dvb_net_init(adap, &dvb->dvbnet, dvb->dmxdev.demux);
1437 dvb->attached = 0x20;
1439 dvb->fe = dvb->fe2 = NULL;
1440 switch (port->type) {
1441 case DDB_TUNER_MXL5XX:
1442 if (fe_attach_mxl5xx(input) < 0)
1445 case DDB_TUNER_DVBS_ST:
1446 if (demod_attach_stv0900(input, 0) < 0)
1448 if (tuner_attach_stv6110(input, 0) < 0)
1451 case DDB_TUNER_DVBS_ST_AA:
1452 if (demod_attach_stv0900(input, 1) < 0)
1454 if (tuner_attach_stv6110(input, 1) < 0)
1457 case DDB_TUNER_DVBS_STV0910:
1458 if (demod_attach_stv0910(input, 0) < 0)
1460 if (tuner_attach_stv6111(input, 0) < 0)
1463 case DDB_TUNER_DVBS_STV0910_PR:
1464 if (demod_attach_stv0910(input, 1) < 0)
1466 if (tuner_attach_stv6111(input, 1) < 0)
1469 case DDB_TUNER_DVBS_STV0910_P:
1470 if (demod_attach_stv0910(input, 0) < 0)
1472 if (tuner_attach_stv6111(input, 1) < 0)
1475 case DDB_TUNER_DVBCT_TR:
1476 if (demod_attach_drxk(input) < 0)
1478 if (tuner_attach_tda18271(input) < 0)
1481 case DDB_TUNER_DVBCT_ST:
1482 if (demod_attach_stv0367(input) < 0)
1484 if (tuner_attach_tda18212(input, port->type) < 0) {
1486 dvb_frontend_detach(dvb->fe2);
1488 dvb_frontend_detach(dvb->fe);
1492 case DDB_TUNER_DVBC2T2I_SONY_P:
1493 if (input->port->dev->link[input->port->lnr].info->ts_quirks &
1499 case DDB_TUNER_DVBCT2_SONY_P:
1500 case DDB_TUNER_DVBC2T2_SONY_P:
1501 case DDB_TUNER_ISDBT_SONY_P:
1502 if (input->port->dev->link[input->port->lnr].info->ts_quirks
1507 if (demod_attach_cxd28xx(input, par, osc24) < 0)
1509 if (tuner_attach_tda18212(input, port->type) < 0) {
1511 dvb_frontend_detach(dvb->fe2);
1513 dvb_frontend_detach(dvb->fe);
1517 case DDB_TUNER_DVBC2T2I_SONY:
1520 case DDB_TUNER_DVBCT2_SONY:
1521 case DDB_TUNER_DVBC2T2_SONY:
1522 case DDB_TUNER_ISDBT_SONY:
1523 if (demod_attach_cxd28xx(input, 0, osc24) < 0)
1525 if (tuner_attach_tda18212(input, port->type) < 0) {
1527 dvb_frontend_detach(dvb->fe2);
1529 dvb_frontend_detach(dvb->fe);
1536 dvb->attached = 0x30;
1539 if (dvb_register_frontend(adap, dvb->fe) < 0)
1543 if (dvb_register_frontend(adap, dvb->fe2) < 0)
1545 dvb->fe2->tuner_priv = dvb->fe->tuner_priv;
1546 memcpy(&dvb->fe2->ops.tuner_ops,
1547 &dvb->fe->ops.tuner_ops,
1548 sizeof(struct dvb_tuner_ops));
1552 dvb->attached = 0x31;
1556 static int port_has_encti(struct ddb_port *port)
1558 struct device *dev = port->dev->dev;
1560 int ret = i2c_read_reg(&port->i2c->adap, 0x20, 0, &val);
1563 dev_info(dev, "[0x20]=0x%02x\n", val);
1567 static int port_has_cxd(struct ddb_port *port, u8 *type)
1570 u8 probe[4] = { 0xe0, 0x00, 0x00, 0x00 }, data[4];
1571 struct i2c_msg msgs[2] = {{ .addr = 0x40, .flags = 0,
1572 .buf = probe, .len = 4 },
1573 { .addr = 0x40, .flags = I2C_M_RD,
1574 .buf = data, .len = 4 } };
1575 val = i2c_transfer(&port->i2c->adap, msgs, 2);
1579 if (data[0] == 0x02 && data[1] == 0x2b && data[3] == 0x43)
1586 static int port_has_xo2(struct ddb_port *port, u8 *type, u8 *id)
1588 u8 probe[1] = { 0x00 }, data[4];
1590 if (i2c_io(&port->i2c->adap, 0x10, probe, 1, data, 4))
1592 if (data[0] == 'D' && data[1] == 'F') {
1597 if (data[0] == 'C' && data[1] == 'I') {
1605 static int port_has_stv0900(struct ddb_port *port)
1609 if (i2c_read_reg16(&port->i2c->adap, 0x69, 0xf100, &val) < 0)
1614 static int port_has_stv0900_aa(struct ddb_port *port, u8 *id)
1616 if (i2c_read_reg16(&port->i2c->adap, 0x68, 0xf100, id) < 0)
1621 static int port_has_drxks(struct ddb_port *port)
1625 if (i2c_read(&port->i2c->adap, 0x29, &val) < 0)
1627 if (i2c_read(&port->i2c->adap, 0x2a, &val) < 0)
1632 static int port_has_stv0367(struct ddb_port *port)
1636 if (i2c_read_reg16(&port->i2c->adap, 0x1e, 0xf000, &val) < 0)
1640 if (i2c_read_reg16(&port->i2c->adap, 0x1f, 0xf000, &val) < 0)
1647 static int init_xo2(struct ddb_port *port)
1649 struct i2c_adapter *i2c = &port->i2c->adap;
1650 struct ddb *dev = port->dev;
1654 res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1658 if (data[0] != 0x01) {
1659 dev_info(dev->dev, "Port %d: invalid XO2\n", port->nr);
1663 i2c_read_reg(i2c, 0x10, 0x08, &val);
1665 i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1668 /* Enable tuner power, disable pll, reset demods */
1669 i2c_write_reg(i2c, 0x10, 0x08, 0x04);
1670 usleep_range(2000, 3000);
1671 /* Release demod resets */
1672 i2c_write_reg(i2c, 0x10, 0x08, 0x07);
1674 /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1675 i2c_write_reg(i2c, 0x10, 0x09, xo2_speed);
1677 if (dev->link[port->lnr].info->con_clock) {
1678 dev_info(dev->dev, "Setting continuous clock for XO2\n");
1679 i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1680 i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1682 i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1683 i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1686 usleep_range(2000, 3000);
1688 i2c_write_reg(i2c, 0x10, 0x08, 0x87);
1693 static int init_xo2_ci(struct ddb_port *port)
1695 struct i2c_adapter *i2c = &port->i2c->adap;
1696 struct ddb *dev = port->dev;
1700 res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1705 dev_info(dev->dev, "Port %d: invalid XO2 CI %02x\n",
1709 dev_info(dev->dev, "Port %d: DuoFlex CI %u.%u\n",
1710 port->nr, data[0], data[1]);
1712 i2c_read_reg(i2c, 0x10, 0x08, &val);
1714 i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1717 /* Enable both CI */
1718 i2c_write_reg(i2c, 0x10, 0x08, 3);
1719 usleep_range(2000, 3000);
1722 /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1723 i2c_write_reg(i2c, 0x10, 0x09, 1);
1725 i2c_write_reg(i2c, 0x10, 0x08, 0x83);
1726 usleep_range(2000, 3000);
1728 if (dev->link[port->lnr].info->con_clock) {
1729 dev_info(dev->dev, "Setting continuous clock for DuoFlex CI\n");
1730 i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1731 i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1733 i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1734 i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1739 static int port_has_cxd28xx(struct ddb_port *port, u8 *id)
1741 struct i2c_adapter *i2c = &port->i2c->adap;
1744 status = i2c_write_reg(&port->i2c->adap, 0x6e, 0, 0);
1747 status = i2c_read_reg(i2c, 0x6e, 0xfd, id);
1753 static char *xo2names[] = {
1754 "DUAL DVB-S2", "DUAL DVB-C/T/T2",
1755 "DUAL DVB-ISDBT", "DUAL DVB-C/C2/T/T2",
1756 "DUAL ATSC", "DUAL DVB-C/C2/T/T2,ISDB-T",
1760 static char *xo2types[] = {
1761 "DVBS_ST", "DVBCT2_SONY",
1762 "ISDBT_SONY", "DVBC2T2_SONY",
1763 "ATSC_ST", "DVBC2T2I_SONY"
1766 static void ddb_port_probe(struct ddb_port *port)
1768 struct ddb *dev = port->dev;
1772 port->name = "NO MODULE";
1773 port->type_name = "NONE";
1774 port->class = DDB_PORT_NONE;
1776 /* Handle missing ports and ports without I2C */
1778 if (port->nr == ts_loop) {
1779 port->name = "TS LOOP";
1780 port->class = DDB_PORT_LOOP;
1784 if (port->nr == 1 && dev->link[l].info->type == DDB_OCTOPUS_CI &&
1785 dev->link[l].info->i2c_mask == 1) {
1786 port->name = "NO TAB";
1787 port->class = DDB_PORT_NONE;
1791 if (dev->link[l].info->type == DDB_OCTOPUS_MAX) {
1792 port->name = "DUAL DVB-S2 MAX";
1793 port->type_name = "MXL5XX";
1794 port->class = DDB_PORT_TUNER;
1795 port->type = DDB_TUNER_MXL5XX;
1797 ddbwritel(dev, I2C_SPEED_400,
1798 port->i2c->regs + I2C_TIMING);
1802 if (port->nr > 1 && dev->link[l].info->type == DDB_OCTOPUS_CI) {
1803 port->name = "CI internal";
1804 port->type_name = "INTERNAL";
1805 port->class = DDB_PORT_CI;
1806 port->type = DDB_CI_INTERNAL;
1812 /* Probe ports with I2C */
1814 if (port_has_cxd(port, &id)) {
1817 port->type_name = "CXD2099";
1818 port->class = DDB_PORT_CI;
1819 port->type = DDB_CI_EXTERNAL_SONY;
1820 ddbwritel(dev, I2C_SPEED_400,
1821 port->i2c->regs + I2C_TIMING);
1823 dev_info(dev->dev, "Port %d: Uninitialized DuoFlex\n",
1827 } else if (port_has_xo2(port, &type, &id)) {
1828 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1829 /*dev_info(dev->dev, "XO2 ID %02x\n", id);*/
1831 port->name = "DuoFlex CI";
1832 port->class = DDB_PORT_CI;
1833 port->type = DDB_CI_EXTERNAL_XO2;
1834 port->type_name = "CI_XO2";
1840 port->name = "unknown XO2 DuoFlex";
1841 port->type_name = "UNKNOWN";
1843 port->name = xo2names[id];
1844 port->class = DDB_PORT_TUNER;
1845 port->type = DDB_TUNER_XO2 + id;
1846 port->type_name = xo2types[id];
1849 } else if (port_has_cxd28xx(port, &id)) {
1852 port->name = "DUAL DVB-C2T2 CXD2843";
1853 port->type = DDB_TUNER_DVBC2T2_SONY_P;
1854 port->type_name = "DVBC2T2_SONY";
1857 port->name = "DUAL DVB-CT2 CXD2837";
1858 port->type = DDB_TUNER_DVBCT2_SONY_P;
1859 port->type_name = "DVBCT2_SONY";
1862 port->name = "DUAL ISDB-T CXD2838";
1863 port->type = DDB_TUNER_ISDBT_SONY_P;
1864 port->type_name = "ISDBT_SONY";
1867 port->name = "DUAL DVB-C2T2 ISDB-T CXD2854";
1868 port->type = DDB_TUNER_DVBC2T2I_SONY_P;
1869 port->type_name = "DVBC2T2I_ISDBT_SONY";
1874 port->class = DDB_PORT_TUNER;
1875 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1876 } else if (port_has_stv0900(port)) {
1877 port->name = "DUAL DVB-S2";
1878 port->class = DDB_PORT_TUNER;
1879 port->type = DDB_TUNER_DVBS_ST;
1880 port->type_name = "DVBS_ST";
1881 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1882 } else if (port_has_stv0900_aa(port, &id)) {
1883 port->name = "DUAL DVB-S2";
1884 port->class = DDB_PORT_TUNER;
1886 if (port->nr == 0 &&
1887 dev->link[l].info->ts_quirks & TS_QUIRK_REVERSED)
1888 port->type = DDB_TUNER_DVBS_STV0910_PR;
1890 port->type = DDB_TUNER_DVBS_STV0910_P;
1891 port->type_name = "DVBS_ST_0910";
1893 port->type = DDB_TUNER_DVBS_ST_AA;
1894 port->type_name = "DVBS_ST_AA";
1896 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1897 } else if (port_has_drxks(port)) {
1898 port->name = "DUAL DVB-C/T";
1899 port->class = DDB_PORT_TUNER;
1900 port->type = DDB_TUNER_DVBCT_TR;
1901 port->type_name = "DVBCT_TR";
1902 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1903 } else if (port_has_stv0367(port)) {
1904 port->name = "DUAL DVB-C/T";
1905 port->class = DDB_PORT_TUNER;
1906 port->type = DDB_TUNER_DVBCT_ST;
1907 port->type_name = "DVBCT_ST";
1908 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1909 } else if (port_has_encti(port)) {
1910 port->name = "ENCTI";
1911 port->class = DDB_PORT_LOOP;
1916 /****************************************************************************/
1917 /****************************************************************************/
1918 /****************************************************************************/
1920 static int wait_ci_ready(struct ddb_ci *ci)
1926 if (ddbreadl(ci->port->dev,
1927 CI_CONTROL(ci->nr)) & CI_READY)
1936 static int read_attribute_mem(struct dvb_ca_en50221 *ca,
1937 int slot, int address)
1939 struct ddb_ci *ci = ca->data;
1940 u32 val, off = (address >> 1) & (CI_BUFFER_SIZE - 1);
1942 if (address > CI_BUFFER_SIZE)
1944 ddbwritel(ci->port->dev, CI_READ_CMD | (1 << 16) | address,
1945 CI_DO_READ_ATTRIBUTES(ci->nr));
1947 val = 0xff & ddbreadl(ci->port->dev, CI_BUFFER(ci->nr) + off);
1951 static int write_attribute_mem(struct dvb_ca_en50221 *ca, int slot,
1952 int address, u8 value)
1954 struct ddb_ci *ci = ca->data;
1956 ddbwritel(ci->port->dev, CI_WRITE_CMD | (value << 16) | address,
1957 CI_DO_ATTRIBUTE_RW(ci->nr));
1962 static int read_cam_control(struct dvb_ca_en50221 *ca,
1963 int slot, u8 address)
1966 struct ddb_ci *ci = ca->data;
1969 ddbwritel(ci->port->dev, CI_READ_CMD | address,
1970 CI_DO_IO_RW(ci->nr));
1973 res = ddbreadl(ci->port->dev, CI_READDATA(ci->nr));
1983 static int write_cam_control(struct dvb_ca_en50221 *ca, int slot,
1984 u8 address, u8 value)
1986 struct ddb_ci *ci = ca->data;
1988 ddbwritel(ci->port->dev, CI_WRITE_CMD | (value << 16) | address,
1989 CI_DO_IO_RW(ci->nr));
1994 static int slot_reset(struct dvb_ca_en50221 *ca, int slot)
1996 struct ddb_ci *ci = ca->data;
1998 ddbwritel(ci->port->dev, CI_POWER_ON,
1999 CI_CONTROL(ci->nr));
2001 ddbwritel(ci->port->dev, CI_POWER_ON | CI_RESET_CAM,
2002 CI_CONTROL(ci->nr));
2003 ddbwritel(ci->port->dev, CI_ENABLE | CI_POWER_ON | CI_RESET_CAM,
2004 CI_CONTROL(ci->nr));
2006 ddbwritel(ci->port->dev, CI_ENABLE | CI_POWER_ON,
2007 CI_CONTROL(ci->nr));
2011 static int slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
2013 struct ddb_ci *ci = ca->data;
2015 ddbwritel(ci->port->dev, 0, CI_CONTROL(ci->nr));
2020 static int slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
2022 struct ddb_ci *ci = ca->data;
2023 u32 val = ddbreadl(ci->port->dev, CI_CONTROL(ci->nr));
2025 ddbwritel(ci->port->dev, val | CI_BYPASS_DISABLE,
2026 CI_CONTROL(ci->nr));
2030 static int poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
2032 struct ddb_ci *ci = ca->data;
2033 u32 val = ddbreadl(ci->port->dev, CI_CONTROL(ci->nr));
2036 if (val & CI_CAM_DETECT)
2037 stat |= DVB_CA_EN50221_POLL_CAM_PRESENT;
2038 if (val & CI_CAM_READY)
2039 stat |= DVB_CA_EN50221_POLL_CAM_READY;
2043 static struct dvb_ca_en50221 en_templ = {
2044 .read_attribute_mem = read_attribute_mem,
2045 .write_attribute_mem = write_attribute_mem,
2046 .read_cam_control = read_cam_control,
2047 .write_cam_control = write_cam_control,
2048 .slot_reset = slot_reset,
2049 .slot_shutdown = slot_shutdown,
2050 .slot_ts_enable = slot_ts_enable,
2051 .poll_slot_status = poll_slot_status,
2054 static void ci_attach(struct ddb_port *port)
2056 struct ddb_ci *ci = NULL;
2058 ci = kzalloc(sizeof(*ci), GFP_KERNEL);
2061 memcpy(&ci->en, &en_templ, sizeof(en_templ));
2065 ci->nr = port->nr - 2;
2068 /****************************************************************************/
2069 /****************************************************************************/
2070 /****************************************************************************/
2072 static int write_creg(struct ddb_ci *ci, u8 data, u8 mask)
2074 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2075 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2077 ci->port->creg = (ci->port->creg & ~mask) | data;
2078 return i2c_write_reg(i2c, adr, 0x02, ci->port->creg);
2081 static int read_attribute_mem_xo2(struct dvb_ca_en50221 *ca,
2082 int slot, int address)
2084 struct ddb_ci *ci = ca->data;
2085 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2086 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2090 res = i2c_read_reg16(i2c, adr, 0x8000 | address, &val);
2091 return res ? res : val;
2094 static int write_attribute_mem_xo2(struct dvb_ca_en50221 *ca, int slot,
2095 int address, u8 value)
2097 struct ddb_ci *ci = ca->data;
2098 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2099 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2101 return i2c_write_reg16(i2c, adr, 0x8000 | address, value);
2104 static int read_cam_control_xo2(struct dvb_ca_en50221 *ca,
2105 int slot, u8 address)
2107 struct ddb_ci *ci = ca->data;
2108 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2109 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2113 res = i2c_read_reg(i2c, adr, 0x20 | (address & 3), &val);
2114 return res ? res : val;
2117 static int write_cam_control_xo2(struct dvb_ca_en50221 *ca, int slot,
2118 u8 address, u8 value)
2120 struct ddb_ci *ci = ca->data;
2121 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2122 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2124 return i2c_write_reg(i2c, adr, 0x20 | (address & 3), value);
2127 static int slot_reset_xo2(struct dvb_ca_en50221 *ca, int slot)
2129 struct ddb_ci *ci = ca->data;
2131 dev_dbg(ci->port->dev->dev, "%s\n", __func__);
2132 write_creg(ci, 0x01, 0x01);
2133 write_creg(ci, 0x04, 0x04);
2135 write_creg(ci, 0x02, 0x02);
2136 write_creg(ci, 0x00, 0x04);
2137 write_creg(ci, 0x18, 0x18);
2141 static int slot_shutdown_xo2(struct dvb_ca_en50221 *ca, int slot)
2143 struct ddb_ci *ci = ca->data;
2145 dev_dbg(ci->port->dev->dev, "%s\n", __func__);
2146 write_creg(ci, 0x10, 0xff);
2147 write_creg(ci, 0x08, 0x08);
2151 static int slot_ts_enable_xo2(struct dvb_ca_en50221 *ca, int slot)
2153 struct ddb_ci *ci = ca->data;
2155 dev_info(ci->port->dev->dev, "%s\n", __func__);
2156 write_creg(ci, 0x00, 0x10);
2160 static int poll_slot_status_xo2(struct dvb_ca_en50221 *ca, int slot, int open)
2162 struct ddb_ci *ci = ca->data;
2163 struct i2c_adapter *i2c = &ci->port->i2c->adap;
2164 u8 adr = (ci->port->type == DDB_CI_EXTERNAL_XO2) ? 0x12 : 0x13;
2168 i2c_read_reg(i2c, adr, 0x01, &val);
2171 stat |= DVB_CA_EN50221_POLL_CAM_PRESENT;
2173 stat |= DVB_CA_EN50221_POLL_CAM_READY;
2177 static struct dvb_ca_en50221 en_xo2_templ = {
2178 .read_attribute_mem = read_attribute_mem_xo2,
2179 .write_attribute_mem = write_attribute_mem_xo2,
2180 .read_cam_control = read_cam_control_xo2,
2181 .write_cam_control = write_cam_control_xo2,
2182 .slot_reset = slot_reset_xo2,
2183 .slot_shutdown = slot_shutdown_xo2,
2184 .slot_ts_enable = slot_ts_enable_xo2,
2185 .poll_slot_status = poll_slot_status_xo2,
2188 static void ci_xo2_attach(struct ddb_port *port)
2192 ci = kzalloc(sizeof(*ci), GFP_KERNEL);
2195 memcpy(&ci->en, &en_xo2_templ, sizeof(en_xo2_templ));
2199 ci->nr = port->nr - 2;
2201 write_creg(ci, 0x10, 0xff);
2202 write_creg(ci, 0x08, 0x08);
2205 /****************************************************************************/
2206 /****************************************************************************/
2207 /****************************************************************************/
2209 static struct cxd2099_cfg cxd_cfg = {
2217 static int ddb_ci_attach(struct ddb_port *port)
2219 switch (port->type) {
2220 case DDB_CI_EXTERNAL_SONY:
2221 cxd_cfg.bitrate = ci_bitrate;
2222 port->en = cxd2099_attach(&cxd_cfg, port, &port->i2c->adap);
2225 dvb_ca_en50221_init(port->dvb[0].adap,
2229 case DDB_CI_EXTERNAL_XO2:
2230 case DDB_CI_EXTERNAL_XO2_B:
2231 ci_xo2_attach(port);
2234 dvb_ca_en50221_init(port->dvb[0].adap, port->en, 0, 1);
2237 case DDB_CI_INTERNAL:
2241 dvb_ca_en50221_init(port->dvb[0].adap, port->en, 0, 1);
2247 static int ddb_port_attach(struct ddb_port *port)
2251 switch (port->class) {
2252 case DDB_PORT_TUNER:
2253 ret = dvb_input_attach(port->input[0]);
2256 ret = dvb_input_attach(port->input[1]);
2259 port->input[0]->redi = port->input[0];
2260 port->input[1]->redi = port->input[1];
2263 ret = ddb_ci_attach(port);
2268 ret = dvb_register_device(port->dvb[0].adap,
2270 &dvbdev_ci, (void *) port->output,
2277 dev_err(port->dev->dev, "port_attach on port %d failed\n",
2282 int ddb_ports_attach(struct ddb *dev)
2285 struct ddb_port *port;
2287 if (dev->port_num) {
2288 ret = dvb_register_adapters(dev);
2290 dev_err(dev->dev, "Registering adapters failed. Check DVB_MAX_ADAPTERS in config.\n");
2294 for (i = 0; i < dev->port_num; i++) {
2295 port = &dev->port[i];
2296 ret = ddb_port_attach(port);
2301 void ddb_ports_detach(struct ddb *dev)
2304 struct ddb_port *port;
2306 for (i = 0; i < dev->port_num; i++) {
2307 port = &dev->port[i];
2309 switch (port->class) {
2310 case DDB_PORT_TUNER:
2311 dvb_input_detach(port->input[0]);
2312 dvb_input_detach(port->input[1]);
2316 if (port->dvb[0].dev)
2317 dvb_unregister_device(port->dvb[0].dev);
2319 dvb_ca_en50221_release(port->en);
2326 dvb_unregister_adapters(dev);
2330 /* Copy input DMA pointers to output DMA and ACK. */
2332 static void input_write_output(struct ddb_input *input,
2333 struct ddb_output *output)
2335 ddbwritel(output->port->dev,
2336 input->dma->stat, DMA_BUFFER_ACK(output->dma));
2337 output->dma->cbuf = (input->dma->stat >> 11) & 0x1f;
2338 output->dma->coff = (input->dma->stat & 0x7ff) << 7;
2341 static void output_ack_input(struct ddb_output *output,
2342 struct ddb_input *input)
2344 ddbwritel(input->port->dev,
2345 output->dma->stat, DMA_BUFFER_ACK(input->dma));
2348 static void input_write_dvb(struct ddb_input *input,
2349 struct ddb_input *input2)
2351 struct ddb_dvb *dvb = &input2->port->dvb[input2->nr & 1];
2352 struct ddb_dma *dma, *dma2;
2353 struct ddb *dev = input->port->dev;
2356 dma = dma2 = input->dma;
2357 /* if there also is an output connected, do not ACK.
2358 * input_write_output will ACK.
2361 dma2 = input->redo->dma;
2364 while (dma->cbuf != ((dma->stat >> 11) & 0x1f)
2365 || (4 & dma->ctrl)) {
2366 if (4 & dma->ctrl) {
2367 /* dev_err(dev->dev, "Overflow dma %d\n", dma->nr); */
2371 dma_sync_single_for_cpu(dev->dev, dma2->pbuf[dma->cbuf],
2372 dma2->size, DMA_FROM_DEVICE);
2373 dvb_dmx_swfilter_packets(&dvb->demux,
2374 dma2->vbuf[dma->cbuf],
2376 dma->cbuf = (dma->cbuf + 1) % dma2->num;
2378 ddbwritel(dev, (dma->cbuf << 11),
2379 DMA_BUFFER_ACK(dma));
2380 dma->stat = safe_ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2381 dma->ctrl = safe_ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2385 static void input_work(struct work_struct *work)
2387 struct ddb_dma *dma = container_of(work, struct ddb_dma, work);
2388 struct ddb_input *input = (struct ddb_input *) dma->io;
2389 struct ddb *dev = input->port->dev;
2390 unsigned long flags;
2392 spin_lock_irqsave(&dma->lock, flags);
2393 if (!dma->running) {
2394 spin_unlock_irqrestore(&dma->lock, flags);
2397 dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2398 dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2401 input_write_dvb(input, input->redi);
2403 input_write_output(input, input->redo);
2405 spin_unlock_irqrestore(&dma->lock, flags);
2408 static void input_handler(unsigned long data)
2410 struct ddb_input *input = (struct ddb_input *) data;
2411 struct ddb_dma *dma = input->dma;
2414 /* If there is no input connected, input_tasklet() will
2415 * just copy pointers and ACK. So, there is no need to go
2416 * through the tasklet scheduler.
2419 queue_work(ddb_wq, &dma->work);
2421 input_work(&dma->work);
2424 static void output_handler(unsigned long data)
2426 struct ddb_output *output = (struct ddb_output *) data;
2427 struct ddb_dma *dma = output->dma;
2428 struct ddb *dev = output->port->dev;
2430 spin_lock(&dma->lock);
2431 if (!dma->running) {
2432 spin_unlock(&dma->lock);
2435 dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2436 dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2438 output_ack_input(output, output->redi);
2440 spin_unlock(&dma->lock);
2443 /****************************************************************************/
2444 /****************************************************************************/
2446 static const struct ddb_regmap *io_regmap(struct ddb_io *io, int link)
2448 const struct ddb_info *info;
2451 info = io->port->dev->link[io->port->lnr].info;
2453 info = io->port->dev->link[0].info;
2458 return info->regmap;
2461 static void ddb_dma_init(struct ddb_io *io, int nr, int out)
2463 struct ddb_dma *dma;
2464 const struct ddb_regmap *rm = io_regmap(io, 0);
2466 dma = out ? &io->port->dev->odma[nr] : &io->port->dev->idma[nr];
2470 spin_lock_init(&dma->lock);
2471 init_waitqueue_head(&dma->wq);
2473 dma->regs = rm->odma->base + rm->odma->size * nr;
2474 dma->bufregs = rm->odma_buf->base + rm->odma_buf->size * nr;
2475 dma->num = OUTPUT_DMA_BUFS;
2476 dma->size = OUTPUT_DMA_SIZE;
2477 dma->div = OUTPUT_DMA_IRQ_DIV;
2479 INIT_WORK(&dma->work, input_work);
2480 dma->regs = rm->idma->base + rm->idma->size * nr;
2481 dma->bufregs = rm->idma_buf->base + rm->idma_buf->size * nr;
2482 dma->num = INPUT_DMA_BUFS;
2483 dma->size = INPUT_DMA_SIZE;
2484 dma->div = INPUT_DMA_IRQ_DIV;
2486 ddbwritel(io->port->dev, 0, DMA_BUFFER_ACK(dma));
2487 dev_dbg(io->port->dev->dev, "init link %u, io %u, dma %u, dmaregs %08x bufregs %08x\n",
2488 io->port->lnr, io->nr, nr, dma->regs, dma->bufregs);
2491 static void ddb_input_init(struct ddb_port *port, int nr, int pnr, int anr)
2493 struct ddb *dev = port->dev;
2494 struct ddb_input *input = &dev->input[anr];
2495 const struct ddb_regmap *rm;
2497 port->input[pnr] = input;
2500 rm = io_regmap(input, 1);
2501 input->regs = DDB_LINK_TAG(port->lnr) |
2502 (rm->input->base + rm->input->size * nr);
2503 dev_dbg(dev->dev, "init link %u, input %u, regs %08x\n",
2504 port->lnr, nr, input->regs);
2507 const struct ddb_regmap *rm0 = io_regmap(input, 0);
2508 u32 base = rm0->irq_base_idma;
2512 dma_nr += 32 + (port->lnr - 1) * 8;
2514 dev_dbg(dev->dev, "init link %u, input %u, handler %u\n",
2515 port->lnr, nr, dma_nr + base);
2517 dev->handler[0][dma_nr + base] = input_handler;
2518 dev->handler_data[0][dma_nr + base] = (unsigned long) input;
2519 ddb_dma_init(input, dma_nr, 0);
2523 static void ddb_output_init(struct ddb_port *port, int nr)
2525 struct ddb *dev = port->dev;
2526 struct ddb_output *output = &dev->output[nr];
2527 const struct ddb_regmap *rm;
2529 port->output = output;
2531 output->port = port;
2532 rm = io_regmap(output, 1);
2533 output->regs = DDB_LINK_TAG(port->lnr) |
2534 (rm->output->base + rm->output->size * nr);
2536 dev_dbg(dev->dev, "init link %u, output %u, regs %08x\n",
2537 port->lnr, nr, output->regs);
2540 const struct ddb_regmap *rm0 = io_regmap(output, 0);
2541 u32 base = rm0->irq_base_odma;
2543 dev->handler[0][nr + base] = output_handler;
2544 dev->handler_data[0][nr + base] = (unsigned long) output;
2545 ddb_dma_init(output, nr, 1);
2549 static int ddb_port_match_i2c(struct ddb_port *port)
2551 struct ddb *dev = port->dev;
2554 for (i = 0; i < dev->i2c_num; i++) {
2555 if (dev->i2c[i].link == port->lnr &&
2556 dev->i2c[i].nr == port->nr) {
2557 port->i2c = &dev->i2c[i];
2564 static int ddb_port_match_link_i2c(struct ddb_port *port)
2566 struct ddb *dev = port->dev;
2569 for (i = 0; i < dev->i2c_num; i++) {
2570 if (dev->i2c[i].link == port->lnr) {
2571 port->i2c = &dev->i2c[i];
2578 void ddb_ports_init(struct ddb *dev)
2581 struct ddb_port *port;
2582 const struct ddb_info *info;
2583 const struct ddb_regmap *rm;
2585 for (p = l = 0; l < DDB_MAX_LINK; l++) {
2586 info = dev->link[l].info;
2592 for (i = 0; i < info->port_num; i++, p++) {
2593 port = &dev->port[p];
2598 port->gap = 0xffffffff;
2599 port->obr = ci_bitrate;
2600 mutex_init(&port->i2c_gate_lock);
2602 if (!ddb_port_match_i2c(port)) {
2603 if (info->type == DDB_OCTOPUS_MAX)
2604 ddb_port_match_link_i2c(port);
2607 ddb_port_probe(port);
2609 port->dvb[0].adap = &dev->adap[2 * p];
2610 port->dvb[1].adap = &dev->adap[2 * p + 1];
2612 if ((port->class == DDB_PORT_NONE) && i && p &&
2613 dev->port[p - 1].type == DDB_CI_EXTERNAL_XO2) {
2614 port->class = DDB_PORT_CI;
2615 port->type = DDB_CI_EXTERNAL_XO2_B;
2616 port->name = "DuoFlex CI_B";
2617 port->i2c = dev->port[p - 1].i2c;
2620 dev_info(dev->dev, "Port %u: Link %u, Link Port %u (TAB %u): %s\n",
2621 port->pnr, port->lnr, port->nr, port->nr + 1,
2624 if (port->class == DDB_PORT_CI &&
2625 port->type == DDB_CI_EXTERNAL_XO2) {
2626 ddb_input_init(port, 2 * i, 0, 2 * i);
2627 ddb_output_init(port, i);
2631 if (port->class == DDB_PORT_CI &&
2632 port->type == DDB_CI_EXTERNAL_XO2_B) {
2633 ddb_input_init(port, 2 * i - 1, 0, 2 * i - 1);
2634 ddb_output_init(port, i);
2638 if (port->class == DDB_PORT_NONE)
2641 switch (dev->link[l].info->type) {
2642 case DDB_OCTOPUS_CI:
2644 ddb_input_init(port, 2 + i, 0, 2 + i);
2645 ddb_input_init(port, 4 + i, 1, 4 + i);
2646 ddb_output_init(port, i);
2650 ddb_input_init(port, 2 * i, 0, 2 * i);
2651 ddb_input_init(port, 2 * i + 1, 1, 2 * i + 1);
2652 ddb_output_init(port, i);
2654 case DDB_OCTOPUS_MAX:
2655 case DDB_OCTOPUS_MAX_CT:
2656 ddb_input_init(port, 2 * i, 0, 2 * p);
2657 ddb_input_init(port, 2 * i + 1, 1, 2 * p + 1);
2667 void ddb_ports_release(struct ddb *dev)
2670 struct ddb_port *port;
2672 for (i = 0; i < dev->port_num; i++) {
2673 port = &dev->port[i];
2674 if (port->input[0] && port->input[0]->dma)
2675 cancel_work_sync(&port->input[0]->dma->work);
2676 if (port->input[1] && port->input[1]->dma)
2677 cancel_work_sync(&port->input[1]->dma->work);
2678 if (port->output && port->output->dma)
2679 cancel_work_sync(&port->output->dma->work);
2683 /****************************************************************************/
2684 /****************************************************************************/
2685 /****************************************************************************/
2687 #define IRQ_HANDLE(_nr) \
2688 do { if ((s & (1UL << ((_nr) & 0x1f))) && dev->handler[0][_nr]) \
2689 dev->handler[0][_nr](dev->handler_data[0][_nr]); } \
2692 static void irq_handle_msg(struct ddb *dev, u32 s)
2701 static void irq_handle_io(struct ddb *dev, u32 s)
2704 if ((s & 0x000000f0)) {
2710 if ((s & 0x0000ff00)) {
2720 if ((s & 0x00ff0000)) {
2730 if ((s & 0xff000000)) {
2742 irqreturn_t ddb_irq_handler0(int irq, void *dev_id)
2744 struct ddb *dev = (struct ddb *) dev_id;
2745 u32 s = ddbreadl(dev, INTERRUPT_STATUS);
2750 if (!(s & 0xfffff00))
2752 ddbwritel(dev, s & 0xfffff00, INTERRUPT_ACK);
2753 irq_handle_io(dev, s);
2754 } while ((s = ddbreadl(dev, INTERRUPT_STATUS)));
2759 irqreturn_t ddb_irq_handler1(int irq, void *dev_id)
2761 struct ddb *dev = (struct ddb *) dev_id;
2762 u32 s = ddbreadl(dev, INTERRUPT_STATUS);
2769 ddbwritel(dev, s & 0x0000f, INTERRUPT_ACK);
2770 irq_handle_msg(dev, s);
2771 } while ((s = ddbreadl(dev, INTERRUPT_STATUS)));
2776 irqreturn_t ddb_irq_handler(int irq, void *dev_id)
2778 struct ddb *dev = (struct ddb *) dev_id;
2779 u32 s = ddbreadl(dev, INTERRUPT_STATUS);
2780 int ret = IRQ_HANDLED;
2787 ddbwritel(dev, s, INTERRUPT_ACK);
2790 irq_handle_msg(dev, s);
2792 irq_handle_io(dev, s);
2793 } while ((s = ddbreadl(dev, INTERRUPT_STATUS)));
2798 /****************************************************************************/
2799 /****************************************************************************/
2800 /****************************************************************************/
2802 static int reg_wait(struct ddb *dev, u32 reg, u32 bit)
2806 while (safe_ddbreadl(dev, reg) & bit) {
2814 static int flashio(struct ddb *dev, u32 lnr, u8 *wbuf, u32 wlen, u8 *rbuf,
2818 u32 tag = DDB_LINK_TAG(lnr);
2819 struct ddb_link *link = &dev->link[lnr];
2821 mutex_lock(&link->flash_mutex);
2823 ddbwritel(dev, 1, tag | SPI_CONTROL);
2825 /* FIXME: check for big-endian */
2826 data = swab32(*(u32 *) wbuf);
2829 ddbwritel(dev, data, tag | SPI_DATA);
2830 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2834 ddbwritel(dev, 0x0001 | ((wlen << (8 + 3)) & 0x1f00),
2837 ddbwritel(dev, 0x0003 | ((wlen << (8 + 3)) & 0x1f00),
2841 shift = ((4 - wlen) * 8);
2850 ddbwritel(dev, data, tag | SPI_DATA);
2851 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2855 ddbwritel(dev, 0, tag | SPI_CONTROL);
2859 ddbwritel(dev, 1, tag | SPI_CONTROL);
2862 ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2863 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2865 data = ddbreadl(dev, tag | SPI_DATA);
2866 *(u32 *) rbuf = swab32(data);
2870 ddbwritel(dev, 0x0003 | ((rlen << (8 + 3)) & 0x1F00),
2872 ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2873 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2876 data = ddbreadl(dev, tag | SPI_DATA);
2877 ddbwritel(dev, 0, tag | SPI_CONTROL);
2880 data <<= ((4 - rlen) * 8);
2883 *rbuf = ((data >> 24) & 0xff);
2889 mutex_unlock(&link->flash_mutex);
2892 mutex_unlock(&link->flash_mutex);
2896 int ddbridge_flashread(struct ddb *dev, u32 link, u8 *buf, u32 addr, u32 len)
2898 u8 cmd[4] = {0x03, (addr >> 16) & 0xff,
2899 (addr >> 8) & 0xff, addr & 0xff};
2901 return flashio(dev, link, cmd, 4, buf, len);
2905 * TODO/FIXME: add/implement IOCTLs from upstream driver
2908 #define DDB_NAME "ddbridge"
2911 static int ddb_major;
2912 static DEFINE_MUTEX(ddb_mutex);
2914 static int ddb_release(struct inode *inode, struct file *file)
2916 struct ddb *dev = file->private_data;
2918 dev->ddb_dev_users--;
2922 static int ddb_open(struct inode *inode, struct file *file)
2924 struct ddb *dev = ddbs[iminor(inode)];
2926 if (dev->ddb_dev_users)
2928 dev->ddb_dev_users++;
2929 file->private_data = dev;
2933 static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2935 struct ddb *dev = file->private_data;
2937 dev_warn(dev->dev, "DDB IOCTLs unsupported (cmd: %d, arg: %lu)\n",
2943 static const struct file_operations ddb_fops = {
2944 .unlocked_ioctl = ddb_ioctl,
2946 .release = ddb_release,
2949 static char *ddb_devnode(struct device *device, umode_t *mode)
2951 struct ddb *dev = dev_get_drvdata(device);
2953 return kasprintf(GFP_KERNEL, "ddbridge/card%d", dev->nr);
2956 #define __ATTR_MRO(_name, _show) { \
2957 .attr = { .name = __stringify(_name), .mode = 0444 }, \
2961 #define __ATTR_MWO(_name, _store) { \
2962 .attr = { .name = __stringify(_name), .mode = 0222 }, \
2966 static ssize_t ports_show(struct device *device,
2967 struct device_attribute *attr, char *buf)
2969 struct ddb *dev = dev_get_drvdata(device);
2971 return sprintf(buf, "%d\n", dev->port_num);
2974 static ssize_t ts_irq_show(struct device *device,
2975 struct device_attribute *attr, char *buf)
2977 struct ddb *dev = dev_get_drvdata(device);
2979 return sprintf(buf, "%d\n", dev->ts_irq);
2982 static ssize_t i2c_irq_show(struct device *device,
2983 struct device_attribute *attr, char *buf)
2985 struct ddb *dev = dev_get_drvdata(device);
2987 return sprintf(buf, "%d\n", dev->i2c_irq);
2990 static ssize_t fan_show(struct device *device,
2991 struct device_attribute *attr, char *buf)
2993 struct ddb *dev = dev_get_drvdata(device);
2996 val = ddbreadl(dev, GPIO_OUTPUT) & 1;
2997 return sprintf(buf, "%d\n", val);
3000 static ssize_t fan_store(struct device *device, struct device_attribute *d,
3001 const char *buf, size_t count)
3003 struct ddb *dev = dev_get_drvdata(device);
3006 if (sscanf(buf, "%u\n", &val) != 1)
3008 ddbwritel(dev, 1, GPIO_DIRECTION);
3009 ddbwritel(dev, val & 1, GPIO_OUTPUT);
3013 static ssize_t fanspeed_show(struct device *device,
3014 struct device_attribute *attr, char *buf)
3016 struct ddb *dev = dev_get_drvdata(device);
3017 int num = attr->attr.name[8] - 0x30;
3018 struct ddb_link *link = &dev->link[num];
3021 spd = ddblreadl(link, TEMPMON_FANCONTROL) & 0xff;
3022 return sprintf(buf, "%u\n", spd * 100);
3025 static ssize_t temp_show(struct device *device,
3026 struct device_attribute *attr, char *buf)
3028 struct ddb *dev = dev_get_drvdata(device);
3029 struct ddb_link *link = &dev->link[0];
3030 struct i2c_adapter *adap;
3034 if (!link->info->temp_num)
3035 return sprintf(buf, "no sensor\n");
3036 adap = &dev->i2c[link->info->temp_bus].adap;
3037 if (i2c_read_regs(adap, 0x48, 0, tmp, 2) < 0)
3038 return sprintf(buf, "read_error\n");
3039 temp = (tmp[0] << 3) | (tmp[1] >> 5);
3041 if (link->info->temp_num == 2) {
3042 if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
3043 return sprintf(buf, "read_error\n");
3044 temp2 = (tmp[0] << 3) | (tmp[1] >> 5);
3046 return sprintf(buf, "%d %d\n", temp, temp2);
3048 return sprintf(buf, "%d\n", temp);
3051 static ssize_t ctemp_show(struct device *device,
3052 struct device_attribute *attr, char *buf)
3054 struct ddb *dev = dev_get_drvdata(device);
3055 struct i2c_adapter *adap;
3058 int num = attr->attr.name[4] - 0x30;
3060 adap = &dev->i2c[num].adap;
3063 if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
3064 if (i2c_read_regs(adap, 0x4d, 0, tmp, 2) < 0)
3065 return sprintf(buf, "no sensor\n");
3066 temp = tmp[0] * 1000;
3067 return sprintf(buf, "%d\n", temp);
3070 static ssize_t led_show(struct device *device,
3071 struct device_attribute *attr, char *buf)
3073 struct ddb *dev = dev_get_drvdata(device);
3074 int num = attr->attr.name[3] - 0x30;
3076 return sprintf(buf, "%d\n", dev->leds & (1 << num) ? 1 : 0);
3080 static void ddb_set_led(struct ddb *dev, int num, int val)
3082 if (!dev->link[0].info->led_num)
3084 switch (dev->port[num].class) {
3085 case DDB_PORT_TUNER:
3086 switch (dev->port[num].type) {
3087 case DDB_TUNER_DVBS_ST:
3088 i2c_write_reg16(&dev->i2c[num].adap,
3089 0x69, 0xf14c, val ? 2 : 0);
3091 case DDB_TUNER_DVBCT_ST:
3092 i2c_write_reg16(&dev->i2c[num].adap,
3094 i2c_write_reg16(&dev->i2c[num].adap,
3095 0x1f, 0xf00f, val ? 1 : 0);
3097 case DDB_TUNER_XO2 ... DDB_TUNER_DVBC2T2I_SONY:
3101 i2c_read_reg(&dev->i2c[num].adap, 0x10, 0x08, &v);
3102 v = (v & ~0x10) | (val ? 0x10 : 0);
3103 i2c_write_reg(&dev->i2c[num].adap, 0x10, 0x08, v);
3113 static ssize_t led_store(struct device *device,
3114 struct device_attribute *attr,
3115 const char *buf, size_t count)
3117 struct ddb *dev = dev_get_drvdata(device);
3118 int num = attr->attr.name[3] - 0x30;
3121 if (sscanf(buf, "%u\n", &val) != 1)
3124 dev->leds |= (1 << num);
3126 dev->leds &= ~(1 << num);
3127 ddb_set_led(dev, num, val);
3131 static ssize_t snr_show(struct device *device,
3132 struct device_attribute *attr, char *buf)
3134 struct ddb *dev = dev_get_drvdata(device);
3136 int num = attr->attr.name[3] - 0x30;
3138 if (dev->port[num].type >= DDB_TUNER_XO2) {
3139 if (i2c_read_regs(&dev->i2c[num].adap, 0x10, 0x10, snr, 16) < 0)
3140 return sprintf(buf, "NO SNR\n");
3143 /* serial number at 0x100-0x11f */
3144 if (i2c_read_regs16(&dev->i2c[num].adap,
3145 0x57, 0x100, snr, 32) < 0)
3146 if (i2c_read_regs16(&dev->i2c[num].adap,
3147 0x50, 0x100, snr, 32) < 0)
3148 return sprintf(buf, "NO SNR\n");
3149 snr[31] = 0; /* in case it is not terminated on EEPROM */
3151 return sprintf(buf, "%s\n", snr);
3154 static ssize_t bsnr_show(struct device *device,
3155 struct device_attribute *attr, char *buf)
3157 struct ddb *dev = dev_get_drvdata(device);
3160 ddbridge_flashread(dev, 0, snr, 0x10, 15);
3161 snr[15] = 0; /* in case it is not terminated on EEPROM */
3162 return sprintf(buf, "%s\n", snr);
3165 static ssize_t bpsnr_show(struct device *device,
3166 struct device_attribute *attr, char *buf)
3168 struct ddb *dev = dev_get_drvdata(device);
3169 unsigned char snr[32];
3174 if (i2c_read_regs16(&dev->i2c[0].adap,
3175 0x50, 0x0000, snr, 32) < 0 ||
3177 return sprintf(buf, "NO SNR\n");
3178 snr[31] = 0; /* in case it is not terminated on EEPROM */
3179 return sprintf(buf, "%s\n", snr);
3182 static ssize_t redirect_show(struct device *device,
3183 struct device_attribute *attr, char *buf)
3188 static ssize_t redirect_store(struct device *device,
3189 struct device_attribute *attr,
3190 const char *buf, size_t count)
3195 if (sscanf(buf, "%x %x\n", &i, &p) != 2)
3197 res = ddb_redirect(i, p);
3200 dev_info(device, "redirect: %02x, %02x\n", i, p);
3204 static ssize_t gap_show(struct device *device,
3205 struct device_attribute *attr, char *buf)
3207 struct ddb *dev = dev_get_drvdata(device);
3208 int num = attr->attr.name[3] - 0x30;
3210 return sprintf(buf, "%d\n", dev->port[num].gap);
3214 static ssize_t gap_store(struct device *device, struct device_attribute *attr,
3215 const char *buf, size_t count)
3217 struct ddb *dev = dev_get_drvdata(device);
3218 int num = attr->attr.name[3] - 0x30;
3221 if (sscanf(buf, "%u\n", &val) != 1)
3227 dev->port[num].gap = val;
3231 static ssize_t version_show(struct device *device,
3232 struct device_attribute *attr, char *buf)
3234 struct ddb *dev = dev_get_drvdata(device);
3236 return sprintf(buf, "%08x %08x\n",
3237 dev->link[0].ids.hwid, dev->link[0].ids.regmapid);
3240 static ssize_t hwid_show(struct device *device,
3241 struct device_attribute *attr, char *buf)
3243 struct ddb *dev = dev_get_drvdata(device);
3245 return sprintf(buf, "0x%08X\n", dev->link[0].ids.hwid);
3248 static ssize_t regmap_show(struct device *device,
3249 struct device_attribute *attr, char *buf)
3251 struct ddb *dev = dev_get_drvdata(device);
3253 return sprintf(buf, "0x%08X\n", dev->link[0].ids.regmapid);
3256 static ssize_t fmode_show(struct device *device,
3257 struct device_attribute *attr, char *buf)
3259 int num = attr->attr.name[5] - 0x30;
3260 struct ddb *dev = dev_get_drvdata(device);
3262 return sprintf(buf, "%u\n", dev->link[num].lnb.fmode);
3265 static ssize_t devid_show(struct device *device,
3266 struct device_attribute *attr, char *buf)
3268 int num = attr->attr.name[5] - 0x30;
3269 struct ddb *dev = dev_get_drvdata(device);
3271 return sprintf(buf, "%08x\n", dev->link[num].ids.devid);
3274 static ssize_t fmode_store(struct device *device, struct device_attribute *attr,
3275 const char *buf, size_t count)
3277 struct ddb *dev = dev_get_drvdata(device);
3278 int num = attr->attr.name[5] - 0x30;
3281 if (sscanf(buf, "%u\n", &val) != 1)
3285 lnb_init_fmode(dev, &dev->link[num], val);
3289 static struct device_attribute ddb_attrs[] = {
3294 __ATTR(gap0, 0664, gap_show, gap_store),
3295 __ATTR(gap1, 0664, gap_show, gap_store),
3296 __ATTR(gap2, 0664, gap_show, gap_store),
3297 __ATTR(gap3, 0664, gap_show, gap_store),
3298 __ATTR(fmode0, 0664, fmode_show, fmode_store),
3299 __ATTR(fmode1, 0664, fmode_show, fmode_store),
3300 __ATTR(fmode2, 0664, fmode_show, fmode_store),
3301 __ATTR(fmode3, 0664, fmode_show, fmode_store),
3302 __ATTR_MRO(devid0, devid_show),
3303 __ATTR_MRO(devid1, devid_show),
3304 __ATTR_MRO(devid2, devid_show),
3305 __ATTR_MRO(devid3, devid_show),
3308 __ATTR(redirect, 0664, redirect_show, redirect_store),
3309 __ATTR_MRO(snr, bsnr_show),
3314 static struct device_attribute ddb_attrs_temp[] = {
3318 static struct device_attribute ddb_attrs_fan[] = {
3319 __ATTR(fan, 0664, fan_show, fan_store),
3322 static struct device_attribute ddb_attrs_snr[] = {
3323 __ATTR_MRO(snr0, snr_show),
3324 __ATTR_MRO(snr1, snr_show),
3325 __ATTR_MRO(snr2, snr_show),
3326 __ATTR_MRO(snr3, snr_show),
3329 static struct device_attribute ddb_attrs_ctemp[] = {
3330 __ATTR_MRO(temp0, ctemp_show),
3331 __ATTR_MRO(temp1, ctemp_show),
3332 __ATTR_MRO(temp2, ctemp_show),
3333 __ATTR_MRO(temp3, ctemp_show),
3336 static struct device_attribute ddb_attrs_led[] = {
3337 __ATTR(led0, 0664, led_show, led_store),
3338 __ATTR(led1, 0664, led_show, led_store),
3339 __ATTR(led2, 0664, led_show, led_store),
3340 __ATTR(led3, 0664, led_show, led_store),
3343 static struct device_attribute ddb_attrs_fanspeed[] = {
3344 __ATTR_MRO(fanspeed0, fanspeed_show),
3345 __ATTR_MRO(fanspeed1, fanspeed_show),
3346 __ATTR_MRO(fanspeed2, fanspeed_show),
3347 __ATTR_MRO(fanspeed3, fanspeed_show),
3350 static struct class ddb_class = {
3352 .owner = THIS_MODULE,
3353 .devnode = ddb_devnode,
3356 int ddb_class_create(void)
3358 ddb_major = register_chrdev(0, DDB_NAME, &ddb_fops);
3361 if (class_register(&ddb_class) < 0)
3366 void ddb_class_destroy(void)
3368 class_unregister(&ddb_class);
3369 unregister_chrdev(ddb_major, DDB_NAME);
3372 static void ddb_device_attrs_del(struct ddb *dev)
3376 for (i = 0; i < 4; i++)
3377 if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3378 device_remove_file(dev->ddb_dev,
3379 &ddb_attrs_fanspeed[i]);
3380 for (i = 0; i < dev->link[0].info->temp_num; i++)
3381 device_remove_file(dev->ddb_dev, &ddb_attrs_temp[i]);
3382 for (i = 0; i < dev->link[0].info->fan_num; i++)
3383 device_remove_file(dev->ddb_dev, &ddb_attrs_fan[i]);
3384 for (i = 0; i < dev->i2c_num && i < 4; i++) {
3385 if (dev->link[0].info->led_num)
3386 device_remove_file(dev->ddb_dev, &ddb_attrs_led[i]);
3387 device_remove_file(dev->ddb_dev, &ddb_attrs_snr[i]);
3388 device_remove_file(dev->ddb_dev, &ddb_attrs_ctemp[i]);
3390 for (i = 0; ddb_attrs[i].attr.name != NULL; i++)
3391 device_remove_file(dev->ddb_dev, &ddb_attrs[i]);
3394 static int ddb_device_attrs_add(struct ddb *dev)
3398 for (i = 0; ddb_attrs[i].attr.name != NULL; i++)
3399 if (device_create_file(dev->ddb_dev, &ddb_attrs[i]))
3401 for (i = 0; i < dev->link[0].info->temp_num; i++)
3402 if (device_create_file(dev->ddb_dev, &ddb_attrs_temp[i]))
3404 for (i = 0; i < dev->link[0].info->fan_num; i++)
3405 if (device_create_file(dev->ddb_dev, &ddb_attrs_fan[i]))
3407 for (i = 0; (i < dev->i2c_num) && (i < 4); i++) {
3408 if (device_create_file(dev->ddb_dev, &ddb_attrs_snr[i]))
3410 if (device_create_file(dev->ddb_dev, &ddb_attrs_ctemp[i]))
3412 if (dev->link[0].info->led_num)
3413 if (device_create_file(dev->ddb_dev,
3417 for (i = 0; i < 4; i++)
3418 if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3419 if (device_create_file(dev->ddb_dev,
3420 &ddb_attrs_fanspeed[i]))
3427 int ddb_device_create(struct ddb *dev)
3431 if (ddb_num == DDB_MAX_ADAPTER)
3433 mutex_lock(&ddb_mutex);
3435 ddbs[dev->nr] = dev;
3436 dev->ddb_dev = device_create(&ddb_class, dev->dev,
3437 MKDEV(ddb_major, dev->nr),
3438 dev, "ddbridge%d", dev->nr);
3439 if (IS_ERR(dev->ddb_dev)) {
3440 res = PTR_ERR(dev->ddb_dev);
3441 dev_info(dev->dev, "Could not create ddbridge%d\n", dev->nr);
3444 res = ddb_device_attrs_add(dev);
3446 ddb_device_attrs_del(dev);
3447 device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3448 ddbs[dev->nr] = NULL;
3449 dev->ddb_dev = ERR_PTR(-ENODEV);
3453 mutex_unlock(&ddb_mutex);
3457 void ddb_device_destroy(struct ddb *dev)
3459 if (IS_ERR(dev->ddb_dev))
3461 ddb_device_attrs_del(dev);
3462 device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3465 /****************************************************************************/
3466 /****************************************************************************/
3467 /****************************************************************************/
3469 static void tempmon_setfan(struct ddb_link *link)
3471 u32 temp, temp2, pwm;
3473 if ((ddblreadl(link, TEMPMON_CONTROL) &
3474 TEMPMON_CONTROL_OVERTEMP) != 0) {
3475 dev_info(link->dev->dev, "Over temperature condition\n");
3476 link->overtemperature_error = 1;
3478 temp = (ddblreadl(link, TEMPMON_SENSOR0) >> 8) & 0xFF;
3481 temp2 = (ddblreadl(link, TEMPMON_SENSOR1) >> 8) & 0xFF;
3487 pwm = (ddblreadl(link, TEMPMON_FANCONTROL) >> 8) & 0x0F;
3491 if (temp >= link->temp_tab[pwm]) {
3492 while (pwm < 10 && temp >= link->temp_tab[pwm + 1])
3495 while (pwm > 1 && temp < link->temp_tab[pwm - 2])
3498 ddblwritel(link, (pwm << 8), TEMPMON_FANCONTROL);
3501 static void temp_handler(unsigned long data)
3503 struct ddb_link *link = (struct ddb_link *) data;
3505 spin_lock(&link->temp_lock);
3506 tempmon_setfan(link);
3507 spin_unlock(&link->temp_lock);
3510 static int tempmon_init(struct ddb_link *link, int first_time)
3512 struct ddb *dev = link->dev;
3516 spin_lock_irq(&link->temp_lock);
3518 static u8 temperature_table[11] = {
3519 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80 };
3521 memcpy(link->temp_tab, temperature_table,
3522 sizeof(temperature_table));
3524 dev->handler[l][link->info->tempmon_irq] = temp_handler;
3525 dev->handler_data[l][link->info->tempmon_irq] = (unsigned long) link;
3526 ddblwritel(link, (TEMPMON_CONTROL_OVERTEMP | TEMPMON_CONTROL_AUTOSCAN |
3527 TEMPMON_CONTROL_INTENABLE),
3529 ddblwritel(link, (3 << 8), TEMPMON_FANCONTROL);
3531 link->overtemperature_error =
3532 ((ddblreadl(link, TEMPMON_CONTROL) &
3533 TEMPMON_CONTROL_OVERTEMP) != 0);
3534 if (link->overtemperature_error) {
3535 dev_info(link->dev->dev, "Over temperature condition\n");
3538 tempmon_setfan(link);
3539 spin_unlock_irq(&link->temp_lock);
3543 static int ddb_init_tempmon(struct ddb_link *link)
3545 const struct ddb_info *info = link->info;
3547 if (!info->tempmon_irq)
3549 if (info->type == DDB_OCTOPUS_MAX_CT)
3550 if (link->ids.regmapid < 0x00010002)
3552 spin_lock_init(&link->temp_lock);
3553 dev_dbg(link->dev->dev, "init_tempmon\n");
3554 return tempmon_init(link, 1);
3557 /****************************************************************************/
3558 /****************************************************************************/
3559 /****************************************************************************/
3561 static int ddb_init_boards(struct ddb *dev)
3563 const struct ddb_info *info;
3564 struct ddb_link *link;
3567 for (l = 0; l < DDB_MAX_LINK; l++) {
3568 link = &dev->link[l];
3573 if (info->board_control) {
3574 ddbwritel(dev, 0, DDB_LINK_TAG(l) | BOARD_CONTROL);
3576 ddbwritel(dev, info->board_control_2,
3577 DDB_LINK_TAG(l) | BOARD_CONTROL);
3578 usleep_range(2000, 3000);
3580 info->board_control_2 | info->board_control,
3581 DDB_LINK_TAG(l) | BOARD_CONTROL);
3582 usleep_range(2000, 3000);
3584 ddb_init_tempmon(link);
3589 int ddb_init(struct ddb *dev)
3591 mutex_init(&dev->link[0].lnb.lock);
3592 mutex_init(&dev->link[0].flash_mutex);
3594 ddb_device_create(dev);
3598 ddb_init_boards(dev);
3600 if (ddb_i2c_init(dev) < 0)
3602 ddb_ports_init(dev);
3603 if (ddb_buffers_alloc(dev) < 0) {
3604 dev_info(dev->dev, "Could not allocate buffer memory\n");
3607 if (ddb_ports_attach(dev) < 0)
3610 ddb_device_create(dev);
3612 if (dev->link[0].info->fan_num) {
3613 ddbwritel(dev, 1, GPIO_DIRECTION);
3614 ddbwritel(dev, 1, GPIO_OUTPUT);
3619 ddb_ports_detach(dev);
3620 dev_err(dev->dev, "fail3\n");
3621 ddb_ports_release(dev);
3623 dev_err(dev->dev, "fail2\n");
3624 ddb_buffers_free(dev);
3625 ddb_i2c_release(dev);
3627 dev_err(dev->dev, "fail1\n");
3631 void ddb_unmap(struct ddb *dev)