pci/ddbridge/ddbridge-core.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * ddbridge-core.c: Digital Devices bridge core functions
0004  *
0005  * Copyright (C) 2010-2017 Digital Devices GmbH
0006  *                         Marcus Metzler <mocm@metzlerbros.de>
0007  *                         Ralph Metzler <rjkm@metzlerbros.de>
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/init.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/delay.h>
0014 #include <linux/slab.h>
0015 #include <linux/poll.h>
0016 #include <linux/io.h>
0017 #include <linux/pci.h>
0018 #include <linux/pci_ids.h>
0019 #include <linux/timer.h>
0020 #include <linux/i2c.h>
0021 #include <linux/swab.h>
0022 #include <linux/vmalloc.h>
0023
0024 #include "ddbridge.h"
0025 #include "ddbridge-i2c.h"
0026 #include "ddbridge-regs.h"
0027 #include "ddbridge-max.h"
0028 #include "ddbridge-ci.h"
0029 #include "ddbridge-io.h"
0030
0031 #include "tda18271c2dd.h"
0032 #include "stv6110x.h"
0033 #include "stv090x.h"
0034 #include "lnbh24.h"
0035 #include "drxk.h"
0036 #include "stv0367.h"
0037 #include "stv0367_priv.h"
0038 #include "cxd2841er.h"
0039 #include "tda18212.h"
0040 #include "stv0910.h"
0041 #include "stv6111.h"
0042 #include "lnbh25.h"
0043 #include "cxd2099.h"
0044 #include "ddbridge-dummy-fe.h"
0045
0046 /****************************************************************************/
0047
0048 #define DDB_MAX_ADAPTER 64
0049
0050 /****************************************************************************/
0051
0052 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0053
0054 static int adapter_alloc;
0055 module_param(adapter_alloc, int, 0444);
0056 MODULE_PARM_DESC(adapter_alloc,
0057          "0-one adapter per io, 1-one per tab with io, 2-one per tab, 3-one for all");
0058
0059 static int ci_bitrate = 70000;
0060 module_param(ci_bitrate, int, 0444);
0061 MODULE_PARM_DESC(ci_bitrate, " Bitrate in KHz for output to CI.");
0062
0063 static int ts_loop = -1;
0064 module_param(ts_loop, int, 0444);
0065 MODULE_PARM_DESC(ts_loop, "TS in/out test loop on port ts_loop");
0066
0067 static int xo2_speed = 2;
0068 module_param(xo2_speed, int, 0444);
0069 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");
0070
0071 #ifdef __arm__
0072 static int alt_dma = 1;
0073 #else
0074 static int alt_dma;
0075 #endif
0076 module_param(alt_dma, int, 0444);
0077 MODULE_PARM_DESC(alt_dma, "use alternative DMA buffer handling");
0078
0079 static int no_init;
0080 module_param(no_init, int, 0444);
0081 MODULE_PARM_DESC(no_init, "do not initialize most devices");
0082
0083 static int stv0910_single;
0084 module_param(stv0910_single, int, 0444);
0085 MODULE_PARM_DESC(stv0910_single, "use stv0910 cards as single demods");
0086
0087 static int dma_buf_num = 8;
0088 module_param(dma_buf_num, int, 0444);
0089 MODULE_PARM_DESC(dma_buf_num, "Number of DMA buffers, possible values: 8-32");
0090
0091 static int dma_buf_size = 21;
0092 module_param(dma_buf_size, int, 0444);
0093 MODULE_PARM_DESC(dma_buf_size,
0094          "DMA buffer size as multiple of 128*47, possible values: 1-43");
0095
0096 static int dummy_tuner;
0097 module_param(dummy_tuner, int, 0444);
0098 MODULE_PARM_DESC(dummy_tuner,
0099          "attach dummy tuner to port 0 on Octopus V3 or Octopus Mini cards");
0100
0101 /****************************************************************************/
0102
0103 static DEFINE_MUTEX(redirect_lock);
0104
0105 static struct workqueue_struct *ddb_wq;
0106
0107 static struct ddb *ddbs[DDB_MAX_ADAPTER];
0108
0109 /****************************************************************************/
0110 /****************************************************************************/
0111 /****************************************************************************/
0112
0113 struct ddb_irq *ddb_irq_set(struct ddb *dev, u32 link, u32 nr,
0114                 void (*handler)(void *), void *data)
0115 {
0116     struct ddb_irq *irq = &dev->link[link].irq[nr];
0117
0118     irq->handler = handler;
0119     irq->data = data;
0120     return irq;
0121 }
0122
0123 static void ddb_set_dma_table(struct ddb_io *io)
0124 {
0125     struct ddb *dev = io->port->dev;
0126     struct ddb_dma *dma = io->dma;
0127     u32 i;
0128     u64 mem;
0129
0130     if (!dma)
0131         return;
0132     for (i = 0; i < dma->num; i++) {
0133         mem = dma->pbuf[i];
0134         ddbwritel(dev, mem & 0xffffffff, dma->bufregs + i * 8);
0135         ddbwritel(dev, mem >> 32, dma->bufregs + i * 8 + 4);
0136     }
0137     dma->bufval = ((dma->div & 0x0f) << 16) |
0138         ((dma->num & 0x1f) << 11) |
0139         ((dma->size >> 7) & 0x7ff);
0140 }
0141
0142 static void ddb_set_dma_tables(struct ddb *dev)
0143 {
0144     u32 i;
0145
0146     for (i = 0; i < DDB_MAX_PORT; i++) {
0147         if (dev->port[i].input[0])
0148             ddb_set_dma_table(dev->port[i].input[0]);
0149         if (dev->port[i].input[1])
0150             ddb_set_dma_table(dev->port[i].input[1]);
0151         if (dev->port[i].output)
0152             ddb_set_dma_table(dev->port[i].output);
0153     }
0154 }
0155
0156 /****************************************************************************/
0157 /****************************************************************************/
0158 /****************************************************************************/
0159
0160 static void ddb_redirect_dma(struct ddb *dev,
0161                  struct ddb_dma *sdma,
0162                  struct ddb_dma *ddma)
0163 {
0164     u32 i, base;
0165     u64 mem;
0166
0167     sdma->bufval = ddma->bufval;
0168     base = sdma->bufregs;
0169     for (i = 0; i < ddma->num; i++) {
0170         mem = ddma->pbuf[i];
0171         ddbwritel(dev, mem & 0xffffffff, base + i * 8);
0172         ddbwritel(dev, mem >> 32, base + i * 8 + 4);
0173     }
0174 }
0175
0176 static int ddb_unredirect(struct ddb_port *port)
0177 {
0178     struct ddb_input *oredi, *iredi = NULL;
0179     struct ddb_output *iredo = NULL;
0180
0181     /* dev_info(port->dev->dev,
0182      * "unredirect %d.%d\n", port->dev->nr, port->nr);
0183      */
0184     mutex_lock(&redirect_lock);
0185     if (port->output->dma->running) {
0186         mutex_unlock(&redirect_lock);
0187         return -EBUSY;
0188     }
0189     oredi = port->output->redi;
0190     if (!oredi)
0191         goto done;
0192     if (port->input[0]) {
0193         iredi = port->input[0]->redi;
0194         iredo = port->input[0]->redo;
0195
0196         if (iredo) {
0197             iredo->port->output->redi = oredi;
0198             if (iredo->port->input[0]) {
0199                 iredo->port->input[0]->redi = iredi;
0200                 ddb_redirect_dma(oredi->port->dev,
0201                          oredi->dma, iredo->dma);
0202             }
0203             port->input[0]->redo = NULL;
0204             ddb_set_dma_table(port->input[0]);
0205         }
0206         oredi->redi = iredi;
0207         port->input[0]->redi = NULL;
0208     }
0209     oredi->redo = NULL;
0210     port->output->redi = NULL;
0211
0212     ddb_set_dma_table(oredi);
0213 done:
0214     mutex_unlock(&redirect_lock);
0215     return 0;
0216 }
0217
0218 static int ddb_redirect(u32 i, u32 p)
0219 {
0220     struct ddb *idev = ddbs[(i >> 4) & 0x3f];
0221     struct ddb_input *input, *input2;
0222     struct ddb *pdev = ddbs[(p >> 4) & 0x3f];
0223     struct ddb_port *port;
0224
0225     if (!idev || !pdev)
0226         return -EINVAL;
0227     if (!idev->has_dma || !pdev->has_dma)
0228         return -EINVAL;
0229
0230     port = &pdev->port[p & 0x0f];
0231     if (!port->output)
0232         return -EINVAL;
0233     if (ddb_unredirect(port))
0234         return -EBUSY;
0235
0236     if (i == 8)
0237         return 0;
0238
0239     input = &idev->input[i & 7];
0240     if (!input)
0241         return -EINVAL;
0242
0243     mutex_lock(&redirect_lock);
0244     if (port->output->dma->running || input->dma->running) {
0245         mutex_unlock(&redirect_lock);
0246         return -EBUSY;
0247     }
0248     input2 = port->input[0];
0249     if (input2) {
0250         if (input->redi) {
0251             input2->redi = input->redi;
0252             input->redi = NULL;
0253         } else {
0254             input2->redi = input;
0255         }
0256     }
0257     input->redo = port->output;
0258     port->output->redi = input;
0259
0260     ddb_redirect_dma(input->port->dev, input->dma, port->output->dma);
0261     mutex_unlock(&redirect_lock);
0262     return 0;
0263 }
0264
0265 /****************************************************************************/
0266 /****************************************************************************/
0267 /****************************************************************************/
0268
0269 static void dma_free(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
0270 {
0271     int i;
0272
0273     if (!dma)
0274         return;
0275     for (i = 0; i < dma->num; i++) {
0276         if (dma->vbuf[i]) {
0277             if (alt_dma) {
0278                 dma_unmap_single(&pdev->dev, dma->pbuf[i],
0279                          dma->size,
0280                          dir ? DMA_TO_DEVICE :
0281                          DMA_FROM_DEVICE);
0282                 kfree(dma->vbuf[i]);
0283                 dma->vbuf[i] = NULL;
0284             } else {
0285                 dma_free_coherent(&pdev->dev, dma->size,
0286                           dma->vbuf[i], dma->pbuf[i]);
0287             }
0288
0289             dma->vbuf[i] = NULL;
0290         }
0291     }
0292 }
0293
0294 static int dma_alloc(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
0295 {
0296     int i;
0297
0298     if (!dma)
0299         return 0;
0300     for (i = 0; i < dma->num; i++) {
0301         if (alt_dma) {
0302             dma->vbuf[i] = kmalloc(dma->size, __GFP_RETRY_MAYFAIL);
0303             if (!dma->vbuf[i])
0304                 return -ENOMEM;
0305             dma->pbuf[i] = dma_map_single(&pdev->dev,
0306                               dma->vbuf[i],
0307                               dma->size,
0308                               dir ? DMA_TO_DEVICE :
0309                               DMA_FROM_DEVICE);
0310             if (dma_mapping_error(&pdev->dev, dma->pbuf[i])) {
0311                 kfree(dma->vbuf[i]);
0312                 dma->vbuf[i] = NULL;
0313                 return -ENOMEM;
0314             }
0315         } else {
0316             dma->vbuf[i] = dma_alloc_coherent(&pdev->dev,
0317                               dma->size,
0318                               &dma->pbuf[i],
0319                               GFP_KERNEL);
0320             if (!dma->vbuf[i])
0321                 return -ENOMEM;
0322         }
0323     }
0324     return 0;
0325 }
0326
0327 int ddb_buffers_alloc(struct ddb *dev)
0328 {
0329     int i;
0330     struct ddb_port *port;
0331
0332     for (i = 0; i < dev->port_num; i++) {
0333         port = &dev->port[i];
0334         switch (port->class) {
0335         case DDB_PORT_TUNER:
0336             if (port->input[0]->dma)
0337                 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
0338                     < 0)
0339                     return -1;
0340             if (port->input[1]->dma)
0341                 if (dma_alloc(dev->pdev, port->input[1]->dma, 0)
0342                     < 0)
0343                     return -1;
0344             break;
0345         case DDB_PORT_CI:
0346         case DDB_PORT_LOOP:
0347             if (port->input[0]->dma)
0348                 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
0349                     < 0)
0350                     return -1;
0351             if (port->output->dma)
0352                 if (dma_alloc(dev->pdev, port->output->dma, 1)
0353                     < 0)
0354                     return -1;
0355             break;
0356         default:
0357             break;
0358         }
0359     }
0360     ddb_set_dma_tables(dev);
0361     return 0;
0362 }
0363
0364 void ddb_buffers_free(struct ddb *dev)
0365 {
0366     int i;
0367     struct ddb_port *port;
0368
0369     for (i = 0; i < dev->port_num; i++) {
0370         port = &dev->port[i];
0371
0372         if (port->input[0] && port->input[0]->dma)
0373             dma_free(dev->pdev, port->input[0]->dma, 0);
0374         if (port->input[1] && port->input[1]->dma)
0375             dma_free(dev->pdev, port->input[1]->dma, 0);
0376         if (port->output && port->output->dma)
0377             dma_free(dev->pdev, port->output->dma, 1);
0378     }
0379 }
0380
0381 static void calc_con(struct ddb_output *output, u32 *con, u32 *con2, u32 flags)
0382 {
0383     struct ddb *dev = output->port->dev;
0384     u32 bitrate = output->port->obr, max_bitrate = 72000;
0385     u32 gap = 4, nco = 0;
0386
0387     *con = 0x1c;
0388     if (output->port->gap != 0xffffffff) {
0389         flags |= 1;
0390         gap = output->port->gap;
0391         max_bitrate = 0;
0392     }
0393     if (dev->link[0].info->type == DDB_OCTOPUS_CI && output->port->nr > 1) {
0394         *con = 0x10c;
0395         if (dev->link[0].ids.regmapid >= 0x10003 && !(flags & 1)) {
0396             if (!(flags & 2)) {
0397                 /* NCO */
0398                 max_bitrate = 0;
0399                 gap = 0;
0400                 if (bitrate != 72000) {
0401                     if (bitrate >= 96000) {
0402                         *con |= 0x800;
0403                     } else {
0404                         *con |= 0x1000;
0405                         nco = (bitrate * 8192 + 71999)
0406                             / 72000;
0407                     }
0408                 }
0409             } else {
0410                 /* Divider and gap */
0411                 *con |= 0x1810;
0412                 if (bitrate <= 64000) {
0413                     max_bitrate = 64000;
0414                     nco = 8;
0415                 } else if (bitrate <= 72000) {
0416                     max_bitrate = 72000;
0417                     nco = 7;
0418                 } else {
0419                     max_bitrate = 96000;
0420                     nco = 5;
0421                 }
0422             }
0423         } else {
0424             if (bitrate > 72000) {
0425                 *con |= 0x810; /* 96 MBit/s and gap */
0426                 max_bitrate = 96000;
0427             }
0428             *con |= 0x10; /* enable gap */
0429         }
0430     }
0431     if (max_bitrate > 0) {
0432         if (bitrate > max_bitrate)
0433             bitrate = max_bitrate;
0434         if (bitrate < 31000)
0435             bitrate = 31000;
0436         gap = ((max_bitrate - bitrate) * 94) / bitrate;
0437         if (gap < 2)
0438             *con &= ~0x10; /* Disable gap */
0439         else
0440             gap -= 2;
0441         if (gap > 127)
0442             gap = 127;
0443     }
0444
0445     *con2 = (nco << 16) | gap;
0446 }
0447
0448 static void ddb_output_start(struct ddb_output *output)
0449 {
0450     struct ddb *dev = output->port->dev;
0451     u32 con = 0x11c, con2 = 0;
0452
0453     spin_lock_irq(&output->dma->lock);
0454     output->dma->cbuf = 0;
0455     output->dma->coff = 0;
0456     output->dma->stat = 0;
0457     ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
0458
0459     if (output->port->input[0]->port->class == DDB_PORT_LOOP)
0460         con = (1UL << 13) | 0x14;
0461     else
0462         calc_con(output, &con, &con2, 0);
0463
0464     ddbwritel(dev, 0, TS_CONTROL(output));
0465     ddbwritel(dev, 2, TS_CONTROL(output));
0466     ddbwritel(dev, 0, TS_CONTROL(output));
0467     ddbwritel(dev, con, TS_CONTROL(output));
0468     ddbwritel(dev, con2, TS_CONTROL2(output));
0469
0470     ddbwritel(dev, output->dma->bufval,
0471           DMA_BUFFER_SIZE(output->dma));
0472     ddbwritel(dev, 0, DMA_BUFFER_ACK(output->dma));
0473     ddbwritel(dev, 1, DMA_BASE_READ);
0474     ddbwritel(dev, 7, DMA_BUFFER_CONTROL(output->dma));
0475
0476     ddbwritel(dev, con | 1, TS_CONTROL(output));
0477
0478     output->dma->running = 1;
0479     spin_unlock_irq(&output->dma->lock);
0480 }
0481
0482 static void ddb_output_stop(struct ddb_output *output)
0483 {
0484     struct ddb *dev = output->port->dev;
0485
0486     spin_lock_irq(&output->dma->lock);
0487
0488     ddbwritel(dev, 0, TS_CONTROL(output));
0489
0490     ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
0491     output->dma->running = 0;
0492     spin_unlock_irq(&output->dma->lock);
0493 }
0494
0495 static void ddb_input_stop(struct ddb_input *input)
0496 {
0497     struct ddb *dev = input->port->dev;
0498     u32 tag = DDB_LINK_TAG(input->port->lnr);
0499
0500     spin_lock_irq(&input->dma->lock);
0501
0502     ddbwritel(dev, 0, tag | TS_CONTROL(input));
0503
0504     ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
0505     input->dma->running = 0;
0506     spin_unlock_irq(&input->dma->lock);
0507 }
0508
0509 static void ddb_input_start(struct ddb_input *input)
0510 {
0511     struct ddb *dev = input->port->dev;
0512
0513     spin_lock_irq(&input->dma->lock);
0514     input->dma->cbuf = 0;
0515     input->dma->coff = 0;
0516     input->dma->stat = 0;
0517     ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
0518
0519     ddbwritel(dev, 0, TS_CONTROL(input));
0520     ddbwritel(dev, 2, TS_CONTROL(input));
0521     ddbwritel(dev, 0, TS_CONTROL(input));
0522
0523     ddbwritel(dev, input->dma->bufval,
0524           DMA_BUFFER_SIZE(input->dma));
0525     ddbwritel(dev, 0, DMA_BUFFER_ACK(input->dma));
0526     ddbwritel(dev, 1, DMA_BASE_WRITE);
0527     ddbwritel(dev, 3, DMA_BUFFER_CONTROL(input->dma));
0528
0529     ddbwritel(dev, 0x09, TS_CONTROL(input));
0530
0531     if (input->port->type == DDB_TUNER_DUMMY)
0532         ddbwritel(dev, 0x000fff01, TS_CONTROL2(input));
0533
0534     input->dma->running = 1;
0535     spin_unlock_irq(&input->dma->lock);
0536 }
0537
0538 static void ddb_input_start_all(struct ddb_input *input)
0539 {
0540     struct ddb_input *i = input;
0541     struct ddb_output *o;
0542
0543     mutex_lock(&redirect_lock);
0544     while (i && (o = i->redo)) {
0545         ddb_output_start(o);
0546         i = o->port->input[0];
0547         if (i)
0548             ddb_input_start(i);
0549     }
0550     ddb_input_start(input);
0551     mutex_unlock(&redirect_lock);
0552 }
0553
0554 static void ddb_input_stop_all(struct ddb_input *input)
0555 {
0556     struct ddb_input *i = input;
0557     struct ddb_output *o;
0558
0559     mutex_lock(&redirect_lock);
0560     ddb_input_stop(input);
0561     while (i && (o = i->redo)) {
0562         ddb_output_stop(o);
0563         i = o->port->input[0];
0564         if (i)
0565             ddb_input_stop(i);
0566     }
0567     mutex_unlock(&redirect_lock);
0568 }
0569
0570 static u32 ddb_output_free(struct ddb_output *output)
0571 {
0572     u32 idx, off, stat = output->dma->stat;
0573     s32 diff;
0574
0575     idx = (stat >> 11) & 0x1f;
0576     off = (stat & 0x7ff) << 7;
0577
0578     if (output->dma->cbuf != idx) {
0579         if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
0580             (output->dma->size - output->dma->coff <= (2 * 188)))
0581             return 0;
0582         return 188;
0583     }
0584     diff = off - output->dma->coff;
0585     if (diff <= 0 || diff > (2 * 188))
0586         return 188;
0587     return 0;
0588 }
0589
0590 static ssize_t ddb_output_write(struct ddb_output *output,
0591                 const __user u8 *buf, size_t count)
0592 {
0593     struct ddb *dev = output->port->dev;
0594     u32 idx, off, stat = output->dma->stat;
0595     u32 left = count, len;
0596
0597     idx = (stat >> 11) & 0x1f;
0598     off = (stat & 0x7ff) << 7;
0599
0600     while (left) {
0601         len = output->dma->size - output->dma->coff;
0602         if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
0603             off == 0) {
0604             if (len <= 188)
0605                 break;
0606             len -= 188;
0607         }
0608         if (output->dma->cbuf == idx) {
0609             if (off > output->dma->coff) {
0610                 len = off - output->dma->coff;
0611                 len -= (len % 188);
0612                 if (len <= 188)
0613                     break;
0614                 len -= 188;
0615             }
0616         }
0617         if (len > left)
0618             len = left;
0619         if (copy_from_user(output->dma->vbuf[output->dma->cbuf] +
0620                    output->dma->coff,
0621                    buf, len))
0622             return -EIO;
0623         if (alt_dma)
0624             dma_sync_single_for_device(
0625                 dev->dev,
0626                 output->dma->pbuf[output->dma->cbuf],
0627                 output->dma->size, DMA_TO_DEVICE);
0628         left -= len;
0629         buf += len;
0630         output->dma->coff += len;
0631         if (output->dma->coff == output->dma->size) {
0632             output->dma->coff = 0;
0633             output->dma->cbuf = ((output->dma->cbuf + 1) %
0634                          output->dma->num);
0635         }
0636         ddbwritel(dev,
0637               (output->dma->cbuf << 11) |
0638               (output->dma->coff >> 7),
0639               DMA_BUFFER_ACK(output->dma));
0640     }
0641     return count - left;
0642 }
0643
0644 static u32 ddb_input_avail(struct ddb_input *input)
0645 {
0646     struct ddb *dev = input->port->dev;
0647     u32 idx, off, stat = input->dma->stat;
0648     u32 ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(input->dma));
0649
0650     idx = (stat >> 11) & 0x1f;
0651     off = (stat & 0x7ff) << 7;
0652
0653     if (ctrl & 4) {
0654         dev_err(dev->dev, "IA %d %d %08x\n", idx, off, ctrl);
0655         ddbwritel(dev, stat, DMA_BUFFER_ACK(input->dma));
0656         return 0;
0657     }
0658     if (input->dma->cbuf != idx)
0659         return 188;
0660     return 0;
0661 }
0662
0663 static ssize_t ddb_input_read(struct ddb_input *input,
0664                   __user u8 *buf, size_t count)
0665 {
0666     struct ddb *dev = input->port->dev;
0667     u32 left = count;
0668     u32 idx, free, stat = input->dma->stat;
0669     int ret;
0670
0671     idx = (stat >> 11) & 0x1f;
0672
0673     while (left) {
0674         if (input->dma->cbuf == idx)
0675             return count - left;
0676         free = input->dma->size - input->dma->coff;
0677         if (free > left)
0678             free = left;
0679         if (alt_dma)
0680             dma_sync_single_for_cpu(
0681                 dev->dev,
0682                 input->dma->pbuf[input->dma->cbuf],
0683                 input->dma->size, DMA_FROM_DEVICE);
0684         ret = copy_to_user(buf, input->dma->vbuf[input->dma->cbuf] +
0685                    input->dma->coff, free);
0686         if (ret)
0687             return -EFAULT;
0688         input->dma->coff += free;
0689         if (input->dma->coff == input->dma->size) {
0690             input->dma->coff = 0;
0691             input->dma->cbuf = (input->dma->cbuf + 1) %
0692                 input->dma->num;
0693         }
0694         left -= free;
0695         buf += free;
0696         ddbwritel(dev,
0697               (input->dma->cbuf << 11) | (input->dma->coff >> 7),
0698               DMA_BUFFER_ACK(input->dma));
0699     }
0700     return count;
0701 }
0702
0703 /****************************************************************************/
0704 /****************************************************************************/
0705
0706 static ssize_t ts_write(struct file *file, const __user char *buf,
0707             size_t count, loff_t *ppos)
0708 {
0709     struct dvb_device *dvbdev = file->private_data;
0710     struct ddb_output *output = dvbdev->priv;
0711     struct ddb *dev = output->port->dev;
0712     size_t left = count;
0713     int stat;
0714
0715     if (!dev->has_dma)
0716         return -EINVAL;
0717     while (left) {
0718         if (ddb_output_free(output) < 188) {
0719             if (file->f_flags & O_NONBLOCK)
0720                 break;
0721             if (wait_event_interruptible(
0722                     output->dma->wq,
0723                     ddb_output_free(output) >= 188) < 0)
0724                 break;
0725         }
0726         stat = ddb_output_write(output, buf, left);
0727         if (stat < 0)
0728             return stat;
0729         buf += stat;
0730         left -= stat;
0731     }
0732     return (left == count) ? -EAGAIN : (count - left);
0733 }
0734
0735 static ssize_t ts_read(struct file *file, __user char *buf,
0736                size_t count, loff_t *ppos)
0737 {
0738     struct dvb_device *dvbdev = file->private_data;
0739     struct ddb_output *output = dvbdev->priv;
0740     struct ddb_input *input = output->port->input[0];
0741     struct ddb *dev = output->port->dev;
0742     size_t left = count;
0743     int stat;
0744
0745     if (!dev->has_dma)
0746         return -EINVAL;
0747     while (left) {
0748         if (ddb_input_avail(input) < 188) {
0749             if (file->f_flags & O_NONBLOCK)
0750                 break;
0751             if (wait_event_interruptible(
0752                     input->dma->wq,
0753                     ddb_input_avail(input) >= 188) < 0)
0754                 break;
0755         }
0756         stat = ddb_input_read(input, buf, left);
0757         if (stat < 0)
0758             return stat;
0759         left -= stat;
0760         buf += stat;
0761     }
0762     return (count && (left == count)) ? -EAGAIN : (count - left);
0763 }
0764
0765 static __poll_t ts_poll(struct file *file, poll_table *wait)
0766 {
0767     struct dvb_device *dvbdev = file->private_data;
0768     struct ddb_output *output = dvbdev->priv;
0769     struct ddb_input *input = output->port->input[0];
0770
0771     __poll_t mask = 0;
0772
0773     poll_wait(file, &input->dma->wq, wait);
0774     poll_wait(file, &output->dma->wq, wait);
0775     if (ddb_input_avail(input) >= 188)
0776         mask |= EPOLLIN | EPOLLRDNORM;
0777     if (ddb_output_free(output) >= 188)
0778         mask |= EPOLLOUT | EPOLLWRNORM;
0779     return mask;
0780 }
0781
0782 static int ts_release(struct inode *inode, struct file *file)
0783 {
0784     struct dvb_device *dvbdev = file->private_data;
0785     struct ddb_output *output = NULL;
0786     struct ddb_input *input = NULL;
0787
0788     if (dvbdev) {
0789         output = dvbdev->priv;
0790         input = output->port->input[0];
0791     }
0792
0793     if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
0794         if (!input)
0795             return -EINVAL;
0796         ddb_input_stop(input);
0797     } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
0798         if (!output)
0799             return -EINVAL;
0800         ddb_output_stop(output);
0801     }
0802     return dvb_generic_release(inode, file);
0803 }
0804
0805 static int ts_open(struct inode *inode, struct file *file)
0806 {
0807     int err;
0808     struct dvb_device *dvbdev = file->private_data;
0809     struct ddb_output *output = NULL;
0810     struct ddb_input *input = NULL;
0811
0812     if (dvbdev) {
0813         output = dvbdev->priv;
0814         input = output->port->input[0];
0815     }
0816
0817     if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
0818         if (!input)
0819             return -EINVAL;
0820         if (input->redo || input->redi)
0821             return -EBUSY;
0822     } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
0823         if (!output)
0824             return -EINVAL;
0825     } else {
0826         return -EINVAL;
0827     }
0828
0829     err = dvb_generic_open(inode, file);
0830     if (err < 0)
0831         return err;
0832     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
0833         ddb_input_start(input);
0834     else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
0835         ddb_output_start(output);
0836     return err;
0837 }
0838
0839 static const struct file_operations ci_fops = {
0840     .owner   = THIS_MODULE,
0841     .read    = ts_read,
0842     .write   = ts_write,
0843     .open    = ts_open,
0844     .release = ts_release,
0845     .poll    = ts_poll,
0846     .mmap    = NULL,
0847 };
0848
0849 static struct dvb_device dvbdev_ci = {
0850     .priv    = NULL,
0851     .readers = 1,
0852     .writers = 1,
0853     .users   = 2,
0854     .fops    = &ci_fops,
0855 };
0856
0857 /****************************************************************************/
0858 /****************************************************************************/
0859
0860 static int locked_gate_ctrl(struct dvb_frontend *fe, int enable)
0861 {
0862     struct ddb_input *input = fe->sec_priv;
0863     struct ddb_port *port = input->port;
0864     struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
0865     int status;
0866
0867     if (enable) {
0868         mutex_lock(&port->i2c_gate_lock);
0869         status = dvb->i2c_gate_ctrl(fe, 1);
0870     } else {
0871         status = dvb->i2c_gate_ctrl(fe, 0);
0872         mutex_unlock(&port->i2c_gate_lock);
0873     }
0874     return status;
0875 }
0876
0877 static int demod_attach_drxk(struct ddb_input *input)
0878 {
0879     struct i2c_adapter *i2c = &input->port->i2c->adap;
0880     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
0881     struct device *dev = input->port->dev->dev;
0882     struct drxk_config config;
0883
0884     memset(&config, 0, sizeof(config));
0885     config.adr = 0x29 + (input->nr & 1);
0886     config.microcode_name = "drxk_a3.mc";
0887
0888     dvb->fe = dvb_attach(drxk_attach, &config, i2c);
0889     if (!dvb->fe) {
0890         dev_err(dev, "No DRXK found!\n");
0891         return -ENODEV;
0892     }
0893     dvb->fe->sec_priv = input;
0894     dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
0895     dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
0896     return 0;
0897 }
0898
0899 static int tuner_attach_tda18271(struct ddb_input *input)
0900 {
0901     struct i2c_adapter *i2c = &input->port->i2c->adap;
0902     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
0903     struct device *dev = input->port->dev->dev;
0904     struct dvb_frontend *fe;
0905
0906     if (dvb->fe->ops.i2c_gate_ctrl)
0907         dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
0908     fe = dvb_attach(tda18271c2dd_attach, dvb->fe, i2c, 0x60);
0909     if (dvb->fe->ops.i2c_gate_ctrl)
0910         dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
0911     if (!fe) {
0912         dev_err(dev, "No TDA18271 found!\n");
0913         return -ENODEV;
0914     }
0915     return 0;
0916 }
0917
0918 /******************************************************************************/
0919 /******************************************************************************/
0920 /******************************************************************************/
0921
0922 static struct stv0367_config ddb_stv0367_config[] = {
0923     {
0924         .demod_address = 0x1f,
0925         .xtal = 27000000,
0926         .if_khz = 0,
0927         .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
0928         .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
0929         .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
0930     }, {
0931         .demod_address = 0x1e,
0932         .xtal = 27000000,
0933         .if_khz = 0,
0934         .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
0935         .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
0936         .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
0937     },
0938 };
0939
0940 static int demod_attach_stv0367(struct ddb_input *input)
0941 {
0942     struct i2c_adapter *i2c = &input->port->i2c->adap;
0943     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
0944     struct device *dev = input->port->dev->dev;
0945
0946     /* attach frontend */
0947     dvb->fe = dvb_attach(stv0367ddb_attach,
0948                  &ddb_stv0367_config[(input->nr & 1)], i2c);
0949
0950     if (!dvb->fe) {
0951         dev_err(dev, "No stv0367 found!\n");
0952         return -ENODEV;
0953     }
0954     dvb->fe->sec_priv = input;
0955     dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
0956     dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
0957     return 0;
0958 }
0959
0960 static int tuner_tda18212_ping(struct ddb_input *input, unsigned short adr)
0961 {
0962     struct i2c_adapter *adapter = &input->port->i2c->adap;
0963     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
0964     struct device *dev = input->port->dev->dev;
0965     u8 tda_id[2];
0966     u8 subaddr = 0x00;
0967
0968     dev_dbg(dev, "stv0367-tda18212 tuner ping\n");
0969     if (dvb->fe->ops.i2c_gate_ctrl)
0970         dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
0971
0972     if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
0973         dev_dbg(dev, "tda18212 ping 1 fail\n");
0974     if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
0975         dev_warn(dev, "tda18212 ping failed, expect problems\n");
0976
0977     if (dvb->fe->ops.i2c_gate_ctrl)
0978         dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
0979
0980     return 0;
0981 }
0982
0983 static int demod_attach_cxd28xx(struct ddb_input *input, int par, int osc24)
0984 {
0985     struct i2c_adapter *i2c = &input->port->i2c->adap;
0986     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
0987     struct device *dev = input->port->dev->dev;
0988     struct cxd2841er_config cfg;
0989
0990     /* the cxd2841er driver expects 8bit/shifted I2C addresses */
0991     cfg.i2c_addr = ((input->nr & 1) ? 0x6d : 0x6c) << 1;
0992
0993     cfg.xtal = osc24 ? SONY_XTAL_24000 : SONY_XTAL_20500;
0994     cfg.flags = CXD2841ER_AUTO_IFHZ | CXD2841ER_EARLY_TUNE |
0995         CXD2841ER_NO_WAIT_LOCK | CXD2841ER_NO_AGCNEG |
0996         CXD2841ER_TSBITS;
0997
0998     if (!par)
0999         cfg.flags |= CXD2841ER_TS_SERIAL;
1000
1001     /* attach frontend */
1002     dvb->fe = dvb_attach(cxd2841er_attach_t_c, &cfg, i2c);
1003
1004     if (!dvb->fe) {
1005         dev_err(dev, "No cxd2837/38/43/54 found!\n");
1006         return -ENODEV;
1007     }
1008     dvb->fe->sec_priv = input;
1009     dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
1010     dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
1011     return 0;
1012 }
1013
1014 static int tuner_attach_tda18212(struct ddb_input *input, u32 porttype)
1015 {
1016     struct i2c_adapter *adapter = &input->port->i2c->adap;
1017     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1018     struct device *dev = input->port->dev->dev;
1019     struct i2c_client *client;
1020     struct tda18212_config config = {
1021         .fe = dvb->fe,
1022         .if_dvbt_6 = 3550,
1023         .if_dvbt_7 = 3700,
1024         .if_dvbt_8 = 4150,
1025         .if_dvbt2_6 = 3250,
1026         .if_dvbt2_7 = 4000,
1027         .if_dvbt2_8 = 4000,
1028         .if_dvbc = 5000,
1029     };
1030     u8 addr = (input->nr & 1) ? 0x63 : 0x60;
1031
1032     /* due to a hardware quirk with the I2C gate on the stv0367+tda18212
1033      * combo, the tda18212 must be probed by reading it's id _twice_ when
1034      * cold started, or it very likely will fail.
1035      */
1036     if (porttype == DDB_TUNER_DVBCT_ST)
1037         tuner_tda18212_ping(input, addr);
1038
1039     /* perform tuner probe/init/attach */
1040     client = dvb_module_probe("tda18212", NULL, adapter, addr, &config);
1041     if (!client)
1042         goto err;
1043
1044     dvb->i2c_client[0] = client;
1045     return 0;
1046 err:
1047     dev_err(dev, "TDA18212 tuner not found. Device is not fully operational.\n");
1048     return -ENODEV;
1049 }
1050
1051 /****************************************************************************/
1052 /****************************************************************************/
1053 /****************************************************************************/
1054
1055 static struct stv090x_config stv0900 = {
1056     .device         = STV0900,
1057     .demod_mode     = STV090x_DUAL,
1058     .clk_mode       = STV090x_CLK_EXT,
1059
1060     .xtal           = 27000000,
1061     .address        = 0x69,
1062
1063     .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1064     .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1065
1066     .ts1_tei        = 1,
1067     .ts2_tei        = 1,
1068
1069     .repeater_level = STV090x_RPTLEVEL_16,
1070
1071     .adc1_range = STV090x_ADC_1Vpp,
1072     .adc2_range = STV090x_ADC_1Vpp,
1073
1074     .diseqc_envelope_mode = true,
1075 };
1076
1077 static struct stv090x_config stv0900_aa = {
1078     .device         = STV0900,
1079     .demod_mode     = STV090x_DUAL,
1080     .clk_mode       = STV090x_CLK_EXT,
1081
1082     .xtal           = 27000000,
1083     .address        = 0x68,
1084
1085     .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1086     .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1087
1088     .ts1_tei        = 1,
1089     .ts2_tei        = 1,
1090
1091     .repeater_level = STV090x_RPTLEVEL_16,
1092
1093     .adc1_range = STV090x_ADC_1Vpp,
1094     .adc2_range = STV090x_ADC_1Vpp,
1095
1096     .diseqc_envelope_mode = true,
1097 };
1098
1099 static struct stv6110x_config stv6110a = {
1100     .addr    = 0x60,
1101     .refclk  = 27000000,
1102     .clk_div = 1,
1103 };
1104
1105 static struct stv6110x_config stv6110b = {
1106     .addr    = 0x63,
1107     .refclk  = 27000000,
1108     .clk_div = 1,
1109 };
1110
1111 static int demod_attach_stv0900(struct ddb_input *input, int type)
1112 {
1113     struct i2c_adapter *i2c = &input->port->i2c->adap;
1114     struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1115     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1116     struct device *dev = input->port->dev->dev;
1117
1118     dvb->fe = dvb_attach(stv090x_attach, feconf, i2c,
1119                  (input->nr & 1) ? STV090x_DEMODULATOR_1
1120                  : STV090x_DEMODULATOR_0);
1121     if (!dvb->fe) {
1122         dev_err(dev, "No STV0900 found!\n");
1123         return -ENODEV;
1124     }
1125     if (!dvb_attach(lnbh24_attach, dvb->fe, i2c, 0,
1126             0, (input->nr & 1) ?
1127             (0x09 - type) : (0x0b - type))) {
1128         dev_err(dev, "No LNBH24 found!\n");
1129         dvb_frontend_detach(dvb->fe);
1130         return -ENODEV;
1131     }
1132     return 0;
1133 }
1134
1135 static int tuner_attach_stv6110(struct ddb_input *input, int type)
1136 {
1137     struct i2c_adapter *i2c = &input->port->i2c->adap;
1138     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1139     struct device *dev = input->port->dev->dev;
1140     struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1141     struct stv6110x_config *tunerconf = (input->nr & 1) ?
1142         &stv6110b : &stv6110a;
1143     const struct stv6110x_devctl *ctl;
1144
1145     ctl = dvb_attach(stv6110x_attach, dvb->fe, tunerconf, i2c);
1146     if (!ctl) {
1147         dev_err(dev, "No STV6110X found!\n");
1148         return -ENODEV;
1149     }
1150     dev_info(dev, "attach tuner input %d adr %02x\n",
1151          input->nr, tunerconf->addr);
1152
1153     feconf->tuner_init          = ctl->tuner_init;
1154     feconf->tuner_sleep         = ctl->tuner_sleep;
1155     feconf->tuner_set_mode      = ctl->tuner_set_mode;
1156     feconf->tuner_set_frequency = ctl->tuner_set_frequency;
1157     feconf->tuner_get_frequency = ctl->tuner_get_frequency;
1158     feconf->tuner_set_bandwidth = ctl->tuner_set_bandwidth;
1159     feconf->tuner_get_bandwidth = ctl->tuner_get_bandwidth;
1160     feconf->tuner_set_bbgain    = ctl->tuner_set_bbgain;
1161     feconf->tuner_get_bbgain    = ctl->tuner_get_bbgain;
1162     feconf->tuner_set_refclk    = ctl->tuner_set_refclk;
1163     feconf->tuner_get_status    = ctl->tuner_get_status;
1164
1165     return 0;
1166 }
1167
1168 static const struct stv0910_cfg stv0910_p = {
1169     .adr      = 0x68,
1170     .parallel = 1,
1171     .rptlvl   = 4,
1172     .clk      = 30000000,
1173     .tsspeed  = 0x28,
1174 };
1175
1176 static const struct lnbh25_config lnbh25_cfg = {
1177     .i2c_address = 0x0c << 1,
1178     .data2_config = LNBH25_TEN
1179 };
1180
1181 static int has_lnbh25(struct i2c_adapter *i2c, u8 adr)
1182 {
1183     u8 val;
1184
1185     return i2c_read_reg(i2c, adr, 0, &val) ? 0 : 1;
1186 }
1187
1188 static int demod_attach_stv0910(struct ddb_input *input, int type, int tsfast)
1189 {
1190     struct i2c_adapter *i2c = &input->port->i2c->adap;
1191     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1192     struct device *dev = input->port->dev->dev;
1193     struct stv0910_cfg cfg = stv0910_p;
1194     struct lnbh25_config lnbcfg = lnbh25_cfg;
1195
1196     if (stv0910_single)
1197         cfg.single = 1;
1198
1199     if (type)
1200         cfg.parallel = 2;
1201
1202     if (tsfast) {
1203         dev_info(dev, "Enabling stv0910 higher speed TS\n");
1204         cfg.tsspeed = 0x10;
1205     }
1206
1207     dvb->fe = dvb_attach(stv0910_attach, i2c, &cfg, (input->nr & 1));
1208     if (!dvb->fe) {
1209         cfg.adr = 0x6c;
1210         dvb->fe = dvb_attach(stv0910_attach, i2c,
1211                      &cfg, (input->nr & 1));
1212     }
1213     if (!dvb->fe) {
1214         dev_err(dev, "No STV0910 found!\n");
1215         return -ENODEV;
1216     }
1217
1218     /* attach lnbh25 - leftshift by one as the lnbh25 driver expects 8bit
1219      * i2c addresses
1220      */
1221     if (has_lnbh25(i2c, 0x0d))
1222         lnbcfg.i2c_address = (((input->nr & 1) ? 0x0d : 0x0c) << 1);
1223     else
1224         lnbcfg.i2c_address = (((input->nr & 1) ? 0x09 : 0x08) << 1);
1225
1226     if (!dvb_attach(lnbh25_attach, dvb->fe, &lnbcfg, i2c)) {
1227         dev_err(dev, "No LNBH25 found!\n");
1228         dvb_frontend_detach(dvb->fe);
1229         return -ENODEV;
1230     }
1231
1232     return 0;
1233 }
1234
1235 static int tuner_attach_stv6111(struct ddb_input *input, int type)
1236 {
1237     struct i2c_adapter *i2c = &input->port->i2c->adap;
1238     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1239     struct device *dev = input->port->dev->dev;
1240     struct dvb_frontend *fe;
1241     u8 adr = (type ? 0 : 4) + ((input->nr & 1) ? 0x63 : 0x60);
1242
1243     fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr);
1244     if (!fe) {
1245         fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr & ~4);
1246         if (!fe) {
1247             dev_err(dev, "No STV6111 found at 0x%02x!\n", adr);
1248             return -ENODEV;
1249         }
1250     }
1251     return 0;
1252 }
1253
1254 static int demod_attach_dummy(struct ddb_input *input)
1255 {
1256     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1257     struct device *dev = input->port->dev->dev;
1258
1259     dvb->fe = dvb_attach(ddbridge_dummy_fe_qam_attach);
1260     if (!dvb->fe) {
1261         dev_err(dev, "QAM dummy attach failed!\n");
1262         return -ENODEV;
1263     }
1264
1265     return 0;
1266 }
1267
1268 static int start_feed(struct dvb_demux_feed *dvbdmxfeed)
1269 {
1270     struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1271     struct ddb_input *input = dvbdmx->priv;
1272     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1273
1274     if (!dvb->users)
1275         ddb_input_start_all(input);
1276
1277     return ++dvb->users;
1278 }
1279
1280 static int stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1281 {
1282     struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1283     struct ddb_input *input = dvbdmx->priv;
1284     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1285
1286     if (--dvb->users)
1287         return dvb->users;
1288
1289     ddb_input_stop_all(input);
1290     return 0;
1291 }
1292
1293 static void dvb_input_detach(struct ddb_input *input)
1294 {
1295     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1296     struct dvb_demux *dvbdemux = &dvb->demux;
1297
1298     switch (dvb->attached) {
1299     case 0x31:
1300         if (dvb->fe2)
1301             dvb_unregister_frontend(dvb->fe2);
1302         if (dvb->fe)
1303             dvb_unregister_frontend(dvb->fe);
1304         fallthrough;
1305     case 0x30:
1306         dvb_module_release(dvb->i2c_client[0]);
1307         dvb->i2c_client[0] = NULL;
1308
1309         if (dvb->fe2)
1310             dvb_frontend_detach(dvb->fe2);
1311         if (dvb->fe)
1312             dvb_frontend_detach(dvb->fe);
1313         dvb->fe = NULL;
1314         dvb->fe2 = NULL;
1315         fallthrough;
1316     case 0x20:
1317         dvb_net_release(&dvb->dvbnet);
1318         fallthrough;
1319     case 0x12:
1320         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1321                           &dvb->hw_frontend);
1322         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1323                           &dvb->mem_frontend);
1324         fallthrough;
1325     case 0x11:
1326         dvb_dmxdev_release(&dvb->dmxdev);
1327         fallthrough;
1328     case 0x10:
1329         dvb_dmx_release(&dvb->demux);
1330         fallthrough;
1331     case 0x01:
1332         break;
1333     }
1334     dvb->attached = 0x00;
1335 }
1336
1337 static int dvb_register_adapters(struct ddb *dev)
1338 {
1339     int i, ret = 0;
1340     struct ddb_port *port;
1341     struct dvb_adapter *adap;
1342
1343     if (adapter_alloc == 3) {
1344         port = &dev->port[0];
1345         adap = port->dvb[0].adap;
1346         ret = dvb_register_adapter(adap, "DDBridge", THIS_MODULE,
1347                        port->dev->dev,
1348                        adapter_nr);
1349         if (ret < 0)
1350             return ret;
1351         port->dvb[0].adap_registered = 1;
1352         for (i = 0; i < dev->port_num; i++) {
1353             port = &dev->port[i];
1354             port->dvb[0].adap = adap;
1355             port->dvb[1].adap = adap;
1356         }
1357         return 0;
1358     }
1359
1360     for (i = 0; i < dev->port_num; i++) {
1361         port = &dev->port[i];
1362         switch (port->class) {
1363         case DDB_PORT_TUNER:
1364             adap = port->dvb[0].adap;
1365             ret = dvb_register_adapter(adap, "DDBridge",
1366                            THIS_MODULE,
1367                            port->dev->dev,
1368                            adapter_nr);
1369             if (ret < 0)
1370                 return ret;
1371             port->dvb[0].adap_registered = 1;
1372
1373             if (adapter_alloc > 0) {
1374                 port->dvb[1].adap = port->dvb[0].adap;
1375                 break;
1376             }
1377             adap = port->dvb[1].adap;
1378             ret = dvb_register_adapter(adap, "DDBridge",
1379                            THIS_MODULE,
1380                            port->dev->dev,
1381                            adapter_nr);
1382             if (ret < 0)
1383                 return ret;
1384             port->dvb[1].adap_registered = 1;
1385             break;
1386
1387         case DDB_PORT_CI:
1388         case DDB_PORT_LOOP:
1389             adap = port->dvb[0].adap;
1390             ret = dvb_register_adapter(adap, "DDBridge",
1391                            THIS_MODULE,
1392                            port->dev->dev,
1393                            adapter_nr);
1394             if (ret < 0)
1395                 return ret;
1396             port->dvb[0].adap_registered = 1;
1397             break;
1398         default:
1399             if (adapter_alloc < 2)
1400                 break;
1401             adap = port->dvb[0].adap;
1402             ret = dvb_register_adapter(adap, "DDBridge",
1403                            THIS_MODULE,
1404                            port->dev->dev,
1405                            adapter_nr);
1406             if (ret < 0)
1407                 return ret;
1408             port->dvb[0].adap_registered = 1;
1409             break;
1410         }
1411     }
1412     return ret;
1413 }
1414
1415 static void dvb_unregister_adapters(struct ddb *dev)
1416 {
1417     int i;
1418     struct ddb_port *port;
1419     struct ddb_dvb *dvb;
1420
1421     for (i = 0; i < dev->link[0].info->port_num; i++) {
1422         port = &dev->port[i];
1423
1424         dvb = &port->dvb[0];
1425         if (dvb->adap_registered)
1426             dvb_unregister_adapter(dvb->adap);
1427         dvb->adap_registered = 0;
1428
1429         dvb = &port->dvb[1];
1430         if (dvb->adap_registered)
1431             dvb_unregister_adapter(dvb->adap);
1432         dvb->adap_registered = 0;
1433     }
1434 }
1435
1436 static int dvb_input_attach(struct ddb_input *input)
1437 {
1438     int ret = 0;
1439     struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1440     struct ddb_port *port = input->port;
1441     struct dvb_adapter *adap = dvb->adap;
1442     struct dvb_demux *dvbdemux = &dvb->demux;
1443     struct ddb_ids *devids = &input->port->dev->link[input->port->lnr].ids;
1444     int par = 0, osc24 = 0, tsfast = 0;
1445
1446     /*
1447      * Determine if bridges with stv0910 demods can run with fast TS and
1448      * thus support high bandwidth transponders.
1449      * STV0910_PR and STV0910_P tuner types covers all relevant bridges,
1450      * namely the CineS2 V7(A) and the Octopus CI S2 Pro/Advanced. All
1451      * DuoFlex S2 V4(A) have type=DDB_TUNER_DVBS_STV0910 without any suffix
1452      * and are limited by the serial link to the bridge, thus won't work
1453      * in fast TS mode.
1454      */
1455     if (port->nr == 0 &&
1456         (port->type == DDB_TUNER_DVBS_STV0910_PR ||
1457          port->type == DDB_TUNER_DVBS_STV0910_P)) {
1458         /* fast TS on port 0 requires FPGA version >= 1.7 */
1459         if ((devids->hwid & 0x00ffffff) >= 0x00010007)
1460             tsfast = 1;
1461     }
1462
1463     dvb->attached = 0x01;
1464
1465     dvbdemux->priv = input;
1466     dvbdemux->dmx.capabilities = DMX_TS_FILTERING |
1467         DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
1468     dvbdemux->start_feed = start_feed;
1469     dvbdemux->stop_feed = stop_feed;
1470     dvbdemux->filternum = 256;
1471     dvbdemux->feednum = 256;
1472     ret = dvb_dmx_init(dvbdemux);
1473     if (ret < 0)
1474         return ret;
1475     dvb->attached = 0x10;
1476
1477     dvb->dmxdev.filternum = 256;
1478     dvb->dmxdev.demux = &dvbdemux->dmx;
1479     ret = dvb_dmxdev_init(&dvb->dmxdev, adap);
1480     if (ret < 0)
1481         goto err_detach;
1482     dvb->attached = 0x11;
1483
1484     dvb->mem_frontend.source = DMX_MEMORY_FE;
1485     dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->mem_frontend);
1486     dvb->hw_frontend.source = DMX_FRONTEND_0;
1487     dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->hw_frontend);
1488     ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, &dvb->hw_frontend);
1489     if (ret < 0)
1490         goto err_detach;
1491     dvb->attached = 0x12;
1492
1493     ret = dvb_net_init(adap, &dvb->dvbnet, dvb->dmxdev.demux);
1494     if (ret < 0)
1495         goto err_detach;
1496     dvb->attached = 0x20;
1497
1498     dvb->fe = NULL;
1499     dvb->fe2 = NULL;
1500     switch (port->type) {
1501     case DDB_TUNER_MXL5XX:
1502         if (ddb_fe_attach_mxl5xx(input) < 0)
1503             goto err_detach;
1504         break;
1505     case DDB_TUNER_DVBS_ST:
1506         if (demod_attach_stv0900(input, 0) < 0)
1507             goto err_detach;
1508         if (tuner_attach_stv6110(input, 0) < 0)
1509             goto err_tuner;
1510         break;
1511     case DDB_TUNER_DVBS_ST_AA:
1512         if (demod_attach_stv0900(input, 1) < 0)
1513             goto err_detach;
1514         if (tuner_attach_stv6110(input, 1) < 0)
1515             goto err_tuner;
1516         break;
1517     case DDB_TUNER_DVBS_STV0910:
1518         if (demod_attach_stv0910(input, 0, tsfast) < 0)
1519             goto err_detach;
1520         if (tuner_attach_stv6111(input, 0) < 0)
1521             goto err_tuner;
1522         break;
1523     case DDB_TUNER_DVBS_STV0910_PR:
1524         if (demod_attach_stv0910(input, 1, tsfast) < 0)
1525             goto err_detach;
1526         if (tuner_attach_stv6111(input, 1) < 0)
1527             goto err_tuner;
1528         break;
1529     case DDB_TUNER_DVBS_STV0910_P:
1530         if (demod_attach_stv0910(input, 0, tsfast) < 0)
1531             goto err_detach;
1532         if (tuner_attach_stv6111(input, 1) < 0)
1533             goto err_tuner;
1534         break;
1535     case DDB_TUNER_DVBCT_TR:
1536         if (demod_attach_drxk(input) < 0)
1537             goto err_detach;
1538         if (tuner_attach_tda18271(input) < 0)
1539             goto err_tuner;
1540         break;
1541     case DDB_TUNER_DVBCT_ST:
1542         if (demod_attach_stv0367(input) < 0)
1543             goto err_detach;
1544         if (tuner_attach_tda18212(input, port->type) < 0)
1545             goto err_tuner;
1546         break;
1547     case DDB_TUNER_DVBC2T2I_SONY_P:
1548         if (input->port->dev->link[input->port->lnr].info->ts_quirks &
1549             TS_QUIRK_ALT_OSC)
1550             osc24 = 0;
1551         else
1552             osc24 = 1;
1553         fallthrough;
1554     case DDB_TUNER_DVBCT2_SONY_P:
1555     case DDB_TUNER_DVBC2T2_SONY_P:
1556     case DDB_TUNER_ISDBT_SONY_P:
1557         if (input->port->dev->link[input->port->lnr].info->ts_quirks
1558             & TS_QUIRK_SERIAL)
1559             par = 0;
1560         else
1561             par = 1;
1562         if (demod_attach_cxd28xx(input, par, osc24) < 0)
1563             goto err_detach;
1564         if (tuner_attach_tda18212(input, port->type) < 0)
1565             goto err_tuner;
1566         break;
1567     case DDB_TUNER_DVBC2T2I_SONY:
1568         osc24 = 1;
1569         fallthrough;
1570     case DDB_TUNER_DVBCT2_SONY:
1571     case DDB_TUNER_DVBC2T2_SONY:
1572     case DDB_TUNER_ISDBT_SONY:
1573         if (demod_attach_cxd28xx(input, 0, osc24) < 0)
1574             goto err_detach;
1575         if (tuner_attach_tda18212(input, port->type) < 0)
1576             goto err_tuner;
1577         break;
1578     case DDB_TUNER_DUMMY:
1579         if (demod_attach_dummy(input) < 0)
1580             goto err_detach;
1581         break;
1582     case DDB_TUNER_MCI_SX8:
1583         if (ddb_fe_attach_mci(input, port->type) < 0)
1584             goto err_detach;
1585         break;
1586     default:
1587         return 0;
1588     }
1589     dvb->attached = 0x30;
1590
1591     if (dvb->fe) {
1592         if (dvb_register_frontend(adap, dvb->fe) < 0)
1593             goto err_detach;
1594
1595         if (dvb->fe2) {
1596             if (dvb_register_frontend(adap, dvb->fe2) < 0) {
1597                 dvb_unregister_frontend(dvb->fe);
1598                 goto err_detach;
1599             }
1600             dvb->fe2->tuner_priv = dvb->fe->tuner_priv;
1601             memcpy(&dvb->fe2->ops.tuner_ops,
1602                    &dvb->fe->ops.tuner_ops,
1603                    sizeof(struct dvb_tuner_ops));
1604         }
1605     }
1606
1607     dvb->attached = 0x31;
1608     return 0;
1609
1610 err_tuner:
1611     dev_err(port->dev->dev, "tuner attach failed!\n");
1612
1613     if (dvb->fe2)
1614         dvb_frontend_detach(dvb->fe2);
1615     if (dvb->fe)
1616         dvb_frontend_detach(dvb->fe);
1617 err_detach:
1618     dvb_input_detach(input);
1619
1620     /* return error from ret if set */
1621     if (ret < 0)
1622         return ret;
1623
1624     return -ENODEV;
1625 }
1626
1627 static int port_has_encti(struct ddb_port *port)
1628 {
1629     struct device *dev = port->dev->dev;
1630     u8 val;
1631     int ret = i2c_read_reg(&port->i2c->adap, 0x20, 0, &val);
1632
1633     if (!ret)
1634         dev_info(dev, "[0x20]=0x%02x\n", val);
1635     return ret ? 0 : 1;
1636 }
1637
1638 static int port_has_cxd(struct ddb_port *port, u8 *type)
1639 {
1640     u8 val;
1641     u8 probe[4] = { 0xe0, 0x00, 0x00, 0x00 }, data[4];
1642     struct i2c_msg msgs[2] = {{ .addr = 0x40,  .flags = 0,
1643                     .buf  = probe, .len   = 4 },
1644                   { .addr = 0x40,  .flags = I2C_M_RD,
1645                     .buf  = data,  .len   = 4 } };
1646     val = i2c_transfer(&port->i2c->adap, msgs, 2);
1647     if (val != 2)
1648         return 0;
1649
1650     if (data[0] == 0x02 && data[1] == 0x2b && data[3] == 0x43)
1651         *type = 2;
1652     else
1653         *type = 1;
1654     return 1;
1655 }
1656
1657 static int port_has_xo2(struct ddb_port *port, u8 *type, u8 *id)
1658 {
1659     u8 probe[1] = { 0x00 }, data[4];
1660
1661     if (i2c_io(&port->i2c->adap, 0x10, probe, 1, data, 4))
1662         return 0;
1663     if (data[0] == 'D' && data[1] == 'F') {
1664         *id = data[2];
1665         *type = 1;
1666         return 1;
1667     }
1668     if (data[0] == 'C' && data[1] == 'I') {
1669         *id = data[2];
1670         *type = 2;
1671         return 1;
1672     }
1673     return 0;
1674 }
1675
1676 static int port_has_stv0900(struct ddb_port *port)
1677 {
1678     u8 val;
1679
1680     if (i2c_read_reg16(&port->i2c->adap, 0x69, 0xf100, &val) < 0)
1681         return 0;
1682     return 1;
1683 }
1684
1685 static int port_has_stv0900_aa(struct ddb_port *port, u8 *id)
1686 {
1687     if (i2c_read_reg16(&port->i2c->adap, 0x68, 0xf100, id) < 0)
1688         return 0;
1689     return 1;
1690 }
1691
1692 static int port_has_drxks(struct ddb_port *port)
1693 {
1694     u8 val;
1695
1696     if (i2c_read(&port->i2c->adap, 0x29, &val) < 0)
1697         return 0;
1698     if (i2c_read(&port->i2c->adap, 0x2a, &val) < 0)
1699         return 0;
1700     return 1;
1701 }
1702
1703 static int port_has_stv0367(struct ddb_port *port)
1704 {
1705     u8 val;
1706
1707     if (i2c_read_reg16(&port->i2c->adap, 0x1e, 0xf000, &val) < 0)
1708         return 0;
1709     if (val != 0x60)
1710         return 0;
1711     if (i2c_read_reg16(&port->i2c->adap, 0x1f, 0xf000, &val) < 0)
1712         return 0;
1713     if (val != 0x60)
1714         return 0;
1715     return 1;
1716 }
1717
1718 static int init_xo2(struct ddb_port *port)
1719 {
1720     struct i2c_adapter *i2c = &port->i2c->adap;
1721     struct ddb *dev = port->dev;
1722     u8 val, data[2];
1723     int res;
1724
1725     res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1726     if (res < 0)
1727         return res;
1728
1729     if (data[0] != 0x01)  {
1730         dev_info(dev->dev, "Port %d: invalid XO2\n", port->nr);
1731         return -1;
1732     }
1733
1734     i2c_read_reg(i2c, 0x10, 0x08, &val);
1735     if (val != 0) {
1736         i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1737         msleep(100);
1738     }
1739     /* Enable tuner power, disable pll, reset demods */
1740     i2c_write_reg(i2c, 0x10, 0x08, 0x04);
1741     usleep_range(2000, 3000);
1742     /* Release demod resets */
1743     i2c_write_reg(i2c, 0x10, 0x08, 0x07);
1744
1745     /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1746     i2c_write_reg(i2c, 0x10, 0x09, xo2_speed);
1747
1748     if (dev->link[port->lnr].info->con_clock) {
1749         dev_info(dev->dev, "Setting continuous clock for XO2\n");
1750         i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1751         i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1752     } else {
1753         i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1754         i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1755     }
1756
1757     usleep_range(2000, 3000);
1758     /* Start XO2 PLL */
1759     i2c_write_reg(i2c, 0x10, 0x08, 0x87);
1760
1761     return 0;
1762 }
1763
1764 static int init_xo2_ci(struct ddb_port *port)
1765 {
1766     struct i2c_adapter *i2c = &port->i2c->adap;
1767     struct ddb *dev = port->dev;
1768     u8 val, data[2];
1769     int res;
1770
1771     res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1772     if (res < 0)
1773         return res;
1774
1775     if (data[0] > 1)  {
1776         dev_info(dev->dev, "Port %d: invalid XO2 CI %02x\n",
1777              port->nr, data[0]);
1778         return -1;
1779     }
1780     dev_info(dev->dev, "Port %d: DuoFlex CI %u.%u\n",
1781          port->nr, data[0], data[1]);
1782
1783     i2c_read_reg(i2c, 0x10, 0x08, &val);
1784     if (val != 0) {
1785         i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1786         msleep(100);
1787     }
1788     /* Enable both CI */
1789     i2c_write_reg(i2c, 0x10, 0x08, 3);
1790     usleep_range(2000, 3000);
1791
1792     /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1793     i2c_write_reg(i2c, 0x10, 0x09, 1);
1794
1795     i2c_write_reg(i2c, 0x10, 0x08, 0x83);
1796     usleep_range(2000, 3000);
1797
1798     if (dev->link[port->lnr].info->con_clock) {
1799         dev_info(dev->dev, "Setting continuous clock for DuoFlex CI\n");
1800         i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1801         i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1802     } else {
1803         i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1804         i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1805     }
1806     return 0;
1807 }
1808
1809 static int port_has_cxd28xx(struct ddb_port *port, u8 *id)
1810 {
1811     struct i2c_adapter *i2c = &port->i2c->adap;
1812     int status;
1813
1814     status = i2c_write_reg(&port->i2c->adap, 0x6e, 0, 0);
1815     if (status)
1816         return 0;
1817     status = i2c_read_reg(i2c, 0x6e, 0xfd, id);
1818     if (status)
1819         return 0;
1820     return 1;
1821 }
1822
1823 static char *xo2names[] = {
1824     "DUAL DVB-S2", "DUAL DVB-C/T/T2",
1825     "DUAL DVB-ISDBT", "DUAL DVB-C/C2/T/T2",
1826     "DUAL ATSC", "DUAL DVB-C/C2/T/T2,ISDB-T",
1827     "", ""
1828 };
1829
1830 static char *xo2types[] = {
1831     "DVBS_ST", "DVBCT2_SONY",
1832     "ISDBT_SONY", "DVBC2T2_SONY",
1833     "ATSC_ST", "DVBC2T2I_SONY"
1834 };
1835
1836 static void ddb_port_probe(struct ddb_port *port)
1837 {
1838     struct ddb *dev = port->dev;
1839     u32 l = port->lnr;
1840     struct ddb_link *link = &dev->link[l];
1841     u8 id, type;
1842
1843     port->name = "NO MODULE";
1844     port->type_name = "NONE";
1845     port->class = DDB_PORT_NONE;
1846
1847     /* Handle missing ports and ports without I2C */
1848
1849     if (dummy_tuner && !port->nr &&
1850         link->ids.device == 0x0005) {
1851         port->name = "DUMMY";
1852         port->class = DDB_PORT_TUNER;
1853         port->type = DDB_TUNER_DUMMY;
1854         port->type_name = "DUMMY";
1855         return;
1856     }
1857
1858     if (port->nr == ts_loop) {
1859         port->name = "TS LOOP";
1860         port->class = DDB_PORT_LOOP;
1861         return;
1862     }
1863
1864     if (port->nr == 1 && link->info->type == DDB_OCTOPUS_CI &&
1865         link->info->i2c_mask == 1) {
1866         port->name = "NO TAB";
1867         port->class = DDB_PORT_NONE;
1868         return;
1869     }
1870
1871     if (link->info->type == DDB_OCTOPUS_MAX) {
1872         port->name = "DUAL DVB-S2 MAX";
1873         port->type_name = "MXL5XX";
1874         port->class = DDB_PORT_TUNER;
1875         port->type = DDB_TUNER_MXL5XX;
1876         if (port->i2c)
1877             ddbwritel(dev, I2C_SPEED_400,
1878                   port->i2c->regs + I2C_TIMING);
1879         return;
1880     }
1881
1882     if (link->info->type == DDB_OCTOPUS_MCI) {
1883         if (port->nr >= link->info->mci_ports)
1884             return;
1885         port->name = "DUAL MCI";
1886         port->type_name = "MCI";
1887         port->class = DDB_PORT_TUNER;
1888         port->type = DDB_TUNER_MCI + link->info->mci_type;
1889         return;
1890     }
1891
1892     if (port->nr > 1 && link->info->type == DDB_OCTOPUS_CI) {
1893         port->name = "CI internal";
1894         port->type_name = "INTERNAL";
1895         port->class = DDB_PORT_CI;
1896         port->type = DDB_CI_INTERNAL;
1897     }
1898
1899     if (!port->i2c)
1900         return;
1901
1902     /* Probe ports with I2C */
1903
1904     if (port_has_cxd(port, &id)) {
1905         if (id == 1) {
1906             port->name = "CI";
1907             port->type_name = "CXD2099";
1908             port->class = DDB_PORT_CI;
1909             port->type = DDB_CI_EXTERNAL_SONY;
1910             ddbwritel(dev, I2C_SPEED_400,
1911                   port->i2c->regs + I2C_TIMING);
1912         } else {
1913             dev_info(dev->dev, "Port %d: Uninitialized DuoFlex\n",
1914                  port->nr);
1915             return;
1916         }
1917     } else if (port_has_xo2(port, &type, &id)) {
1918         ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1919         /*dev_info(dev->dev, "XO2 ID %02x\n", id);*/
1920         if (type == 2) {
1921             port->name = "DuoFlex CI";
1922             port->class = DDB_PORT_CI;
1923             port->type = DDB_CI_EXTERNAL_XO2;
1924             port->type_name = "CI_XO2";
1925             init_xo2_ci(port);
1926             return;
1927         }
1928         id >>= 2;
1929         if (id > 5) {
1930             port->name = "unknown XO2 DuoFlex";
1931             port->type_name = "UNKNOWN";
1932         } else {
1933             port->name = xo2names[id];
1934             port->class = DDB_PORT_TUNER;
1935             port->type = DDB_TUNER_XO2 + id;
1936             port->type_name = xo2types[id];
1937             init_xo2(port);
1938         }
1939     } else if (port_has_cxd28xx(port, &id)) {
1940         switch (id) {
1941         case 0xa4:
1942             port->name = "DUAL DVB-C2T2 CXD2843";
1943             port->type = DDB_TUNER_DVBC2T2_SONY_P;
1944             port->type_name = "DVBC2T2_SONY";
1945             break;
1946         case 0xb1:
1947             port->name = "DUAL DVB-CT2 CXD2837";
1948             port->type = DDB_TUNER_DVBCT2_SONY_P;
1949             port->type_name = "DVBCT2_SONY";
1950             break;
1951         case 0xb0:
1952             port->name = "DUAL ISDB-T CXD2838";
1953             port->type = DDB_TUNER_ISDBT_SONY_P;
1954             port->type_name = "ISDBT_SONY";
1955             break;
1956         case 0xc1:
1957             port->name = "DUAL DVB-C2T2 ISDB-T CXD2854";
1958             port->type = DDB_TUNER_DVBC2T2I_SONY_P;
1959             port->type_name = "DVBC2T2I_ISDBT_SONY";
1960             break;
1961         default:
1962             return;
1963         }
1964         port->class = DDB_PORT_TUNER;
1965         ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1966     } else if (port_has_stv0900(port)) {
1967         port->name = "DUAL DVB-S2";
1968         port->class = DDB_PORT_TUNER;
1969         port->type = DDB_TUNER_DVBS_ST;
1970         port->type_name = "DVBS_ST";
1971         ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1972     } else if (port_has_stv0900_aa(port, &id)) {
1973         port->name = "DUAL DVB-S2";
1974         port->class = DDB_PORT_TUNER;
1975         if (id == 0x51) {
1976             if (port->nr == 0 &&
1977                 link->info->ts_quirks & TS_QUIRK_REVERSED)
1978                 port->type = DDB_TUNER_DVBS_STV0910_PR;
1979             else
1980                 port->type = DDB_TUNER_DVBS_STV0910_P;
1981             port->type_name = "DVBS_ST_0910";
1982         } else {
1983             port->type = DDB_TUNER_DVBS_ST_AA;
1984             port->type_name = "DVBS_ST_AA";
1985         }
1986         ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1987     } else if (port_has_drxks(port)) {
1988         port->name = "DUAL DVB-C/T";
1989         port->class = DDB_PORT_TUNER;
1990         port->type = DDB_TUNER_DVBCT_TR;
1991         port->type_name = "DVBCT_TR";
1992         ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1993     } else if (port_has_stv0367(port)) {
1994         port->name = "DUAL DVB-C/T";
1995         port->class = DDB_PORT_TUNER;
1996         port->type = DDB_TUNER_DVBCT_ST;
1997         port->type_name = "DVBCT_ST";
1998         ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1999     } else if (port_has_encti(port)) {
2000         port->name = "ENCTI";
2001         port->class = DDB_PORT_LOOP;
2002     }
2003 }
2004
2005 /****************************************************************************/
2006 /****************************************************************************/
2007 /****************************************************************************/
2008
2009 static int ddb_port_attach(struct ddb_port *port)
2010 {
2011     int ret = 0;
2012
2013     switch (port->class) {
2014     case DDB_PORT_TUNER:
2015         ret = dvb_input_attach(port->input[0]);
2016         if (ret < 0)
2017             break;
2018         ret = dvb_input_attach(port->input[1]);
2019         if (ret < 0) {
2020             dvb_input_detach(port->input[0]);
2021             break;
2022         }
2023         port->input[0]->redi = port->input[0];
2024         port->input[1]->redi = port->input[1];
2025         break;
2026     case DDB_PORT_CI:
2027         ret = ddb_ci_attach(port, ci_bitrate);
2028         if (ret < 0)
2029             break;
2030         fallthrough;
2031     case DDB_PORT_LOOP:
2032         ret = dvb_register_device(port->dvb[0].adap,
2033                       &port->dvb[0].dev,
2034                       &dvbdev_ci, (void *)port->output,
2035                       DVB_DEVICE_SEC, 0);
2036         break;
2037     default:
2038         break;
2039     }
2040     if (ret < 0)
2041         dev_err(port->dev->dev, "port_attach on port %d failed\n",
2042             port->nr);
2043     return ret;
2044 }
2045
2046 int ddb_ports_attach(struct ddb *dev)
2047 {
2048     int i, numports, err_ports = 0, ret = 0;
2049     struct ddb_port *port;
2050
2051     if (dev->port_num) {
2052         ret = dvb_register_adapters(dev);
2053         if (ret < 0) {
2054             dev_err(dev->dev, "Registering adapters failed. Check DVB_MAX_ADAPTERS in config.\n");
2055             return ret;
2056         }
2057     }
2058
2059     numports = dev->port_num;
2060
2061     for (i = 0; i < dev->port_num; i++) {
2062         port = &dev->port[i];
2063         if (port->class != DDB_PORT_NONE) {
2064             ret = ddb_port_attach(port);
2065             if (ret)
2066                 err_ports++;
2067         } else {
2068             numports--;
2069         }
2070     }
2071
2072     if (err_ports) {
2073         if (err_ports == numports) {
2074             dev_err(dev->dev, "All connected ports failed to initialise!\n");
2075             return -ENODEV;
2076         }
2077
2078         dev_warn(dev->dev, "%d of %d connected ports failed to initialise!\n",
2079              err_ports, numports);
2080     }
2081
2082     return 0;
2083 }
2084
2085 void ddb_ports_detach(struct ddb *dev)
2086 {
2087     int i;
2088     struct ddb_port *port;
2089
2090     for (i = 0; i < dev->port_num; i++) {
2091         port = &dev->port[i];
2092
2093         switch (port->class) {
2094         case DDB_PORT_TUNER:
2095             dvb_input_detach(port->input[1]);
2096             dvb_input_detach(port->input[0]);
2097             break;
2098         case DDB_PORT_CI:
2099         case DDB_PORT_LOOP:
2100             ddb_ci_detach(port);
2101             break;
2102         }
2103     }
2104     dvb_unregister_adapters(dev);
2105 }
2106
2107 /* Copy input DMA pointers to output DMA and ACK. */
2108
2109 static void input_write_output(struct ddb_input *input,
2110                    struct ddb_output *output)
2111 {
2112     ddbwritel(output->port->dev,
2113           input->dma->stat, DMA_BUFFER_ACK(output->dma));
2114     output->dma->cbuf = (input->dma->stat >> 11) & 0x1f;
2115     output->dma->coff = (input->dma->stat & 0x7ff) << 7;
2116 }
2117
2118 static void output_ack_input(struct ddb_output *output,
2119                  struct ddb_input *input)
2120 {
2121     ddbwritel(input->port->dev,
2122           output->dma->stat, DMA_BUFFER_ACK(input->dma));
2123 }
2124
2125 static void input_write_dvb(struct ddb_input *input,
2126                 struct ddb_input *input2)
2127 {
2128     struct ddb_dvb *dvb = &input2->port->dvb[input2->nr & 1];
2129     struct ddb_dma *dma, *dma2;
2130     struct ddb *dev = input->port->dev;
2131     int ack = 1;
2132
2133     dma = input->dma;
2134     dma2 = input->dma;
2135     /*
2136      * if there also is an output connected, do not ACK.
2137      * input_write_output will ACK.
2138      */
2139     if (input->redo) {
2140         dma2 = input->redo->dma;
2141         ack = 0;
2142     }
2143     while (dma->cbuf != ((dma->stat >> 11) & 0x1f) ||
2144            (4 & dma->ctrl)) {
2145         if (4 & dma->ctrl) {
2146             /* dev_err(dev->dev, "Overflow dma %d\n", dma->nr); */
2147             ack = 1;
2148         }
2149         if (alt_dma)
2150             dma_sync_single_for_cpu(dev->dev, dma2->pbuf[dma->cbuf],
2151                         dma2->size, DMA_FROM_DEVICE);
2152         dvb_dmx_swfilter_packets(&dvb->demux,
2153                      dma2->vbuf[dma->cbuf],
2154                      dma2->size / 188);
2155         dma->cbuf = (dma->cbuf + 1) % dma2->num;
2156         if (ack)
2157             ddbwritel(dev, (dma->cbuf << 11),
2158                   DMA_BUFFER_ACK(dma));
2159         dma->stat = safe_ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2160         dma->ctrl = safe_ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2161     }
2162 }
2163
2164 static void input_work(struct work_struct *work)
2165 {
2166     struct ddb_dma *dma = container_of(work, struct ddb_dma, work);
2167     struct ddb_input *input = (struct ddb_input *)dma->io;
2168     struct ddb *dev = input->port->dev;
2169     unsigned long flags;
2170
2171     spin_lock_irqsave(&dma->lock, flags);
2172     if (!dma->running) {
2173         spin_unlock_irqrestore(&dma->lock, flags);
2174         return;
2175     }
2176     dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2177     dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2178
2179     if (input->redi)
2180         input_write_dvb(input, input->redi);
2181     if (input->redo)
2182         input_write_output(input, input->redo);
2183     wake_up(&dma->wq);
2184     spin_unlock_irqrestore(&dma->lock, flags);
2185 }
2186
2187 static void input_handler(void *data)
2188 {
2189     struct ddb_input *input = (struct ddb_input *)data;
2190     struct ddb_dma *dma = input->dma;
2191
2192     queue_work(ddb_wq, &dma->work);
2193 }
2194
2195 static void output_work(struct work_struct *work)
2196 {
2197     struct ddb_dma *dma = container_of(work, struct ddb_dma, work);
2198     struct ddb_output *output = (struct ddb_output *)dma->io;
2199     struct ddb *dev = output->port->dev;
2200     unsigned long flags;
2201
2202     spin_lock_irqsave(&dma->lock, flags);
2203     if (!dma->running)
2204         goto unlock_exit;
2205     dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2206     dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2207     if (output->redi)
2208         output_ack_input(output, output->redi);
2209     wake_up(&dma->wq);
2210 unlock_exit:
2211     spin_unlock_irqrestore(&dma->lock, flags);
2212 }
2213
2214 static void output_handler(void *data)
2215 {
2216     struct ddb_output *output = (struct ddb_output *)data;
2217     struct ddb_dma *dma = output->dma;
2218
2219     queue_work(ddb_wq, &dma->work);
2220 }
2221
2222 /****************************************************************************/
2223 /****************************************************************************/
2224
2225 static const struct ddb_regmap *io_regmap(struct ddb_io *io, int link)
2226 {
2227     const struct ddb_info *info;
2228
2229     if (link)
2230         info = io->port->dev->link[io->port->lnr].info;
2231     else
2232         info = io->port->dev->link[0].info;
2233
2234     if (!info)
2235         return NULL;
2236
2237     return info->regmap;
2238 }
2239
2240 static void ddb_dma_init(struct ddb_io *io, int nr, int out)
2241 {
2242     struct ddb_dma *dma;
2243     const struct ddb_regmap *rm = io_regmap(io, 0);
2244
2245     dma = out ? &io->port->dev->odma[nr] : &io->port->dev->idma[nr];
2246     io->dma = dma;
2247     dma->io = io;
2248
2249     spin_lock_init(&dma->lock);
2250     init_waitqueue_head(&dma->wq);
2251     if (out) {
2252         INIT_WORK(&dma->work, output_work);
2253         dma->regs = rm->odma->base + rm->odma->size * nr;
2254         dma->bufregs = rm->odma_buf->base + rm->odma_buf->size * nr;
2255         dma->num = dma_buf_num;
2256         dma->size = dma_buf_size * 128 * 47;
2257         dma->div = 1;
2258     } else {
2259         INIT_WORK(&dma->work, input_work);
2260         dma->regs = rm->idma->base + rm->idma->size * nr;
2261         dma->bufregs = rm->idma_buf->base + rm->idma_buf->size * nr;
2262         dma->num = dma_buf_num;
2263         dma->size = dma_buf_size * 128 * 47;
2264         dma->div = 1;
2265     }
2266     ddbwritel(io->port->dev, 0, DMA_BUFFER_ACK(dma));
2267     dev_dbg(io->port->dev->dev, "init link %u, io %u, dma %u, dmaregs %08x bufregs %08x\n",
2268         io->port->lnr, io->nr, nr, dma->regs, dma->bufregs);
2269 }
2270
2271 static void ddb_input_init(struct ddb_port *port, int nr, int pnr, int anr)
2272 {
2273     struct ddb *dev = port->dev;
2274     struct ddb_input *input = &dev->input[anr];
2275     const struct ddb_regmap *rm;
2276
2277     port->input[pnr] = input;
2278     input->nr = nr;
2279     input->port = port;
2280     rm = io_regmap(input, 1);
2281     input->regs = DDB_LINK_TAG(port->lnr) |
2282         (rm->input->base + rm->input->size * nr);
2283     dev_dbg(dev->dev, "init link %u, input %u, regs %08x\n",
2284         port->lnr, nr, input->regs);
2285
2286     if (dev->has_dma) {
2287         const struct ddb_regmap *rm0 = io_regmap(input, 0);
2288         u32 base = rm0->irq_base_idma;
2289         u32 dma_nr = nr;
2290
2291         if (port->lnr)
2292             dma_nr += 32 + (port->lnr - 1) * 8;
2293
2294         dev_dbg(dev->dev, "init link %u, input %u, handler %u\n",
2295             port->lnr, nr, dma_nr + base);
2296
2297         ddb_irq_set(dev, 0, dma_nr + base, &input_handler, input);
2298         ddb_dma_init(input, dma_nr, 0);
2299     }
2300 }
2301
2302 static void ddb_output_init(struct ddb_port *port, int nr)
2303 {
2304     struct ddb *dev = port->dev;
2305     struct ddb_output *output = &dev->output[nr];
2306     const struct ddb_regmap *rm;
2307
2308     port->output = output;
2309     output->nr = nr;
2310     output->port = port;
2311     rm = io_regmap(output, 1);
2312     output->regs = DDB_LINK_TAG(port->lnr) |
2313         (rm->output->base + rm->output->size * nr);
2314
2315     dev_dbg(dev->dev, "init link %u, output %u, regs %08x\n",
2316         port->lnr, nr, output->regs);
2317
2318     if (dev->has_dma) {
2319         const struct ddb_regmap *rm0 = io_regmap(output, 0);
2320         u32 base = rm0->irq_base_odma;
2321
2322         ddb_irq_set(dev, 0, nr + base, &output_handler, output);
2323         ddb_dma_init(output, nr, 1);
2324     }
2325 }
2326
2327 static int ddb_port_match_i2c(struct ddb_port *port)
2328 {
2329     struct ddb *dev = port->dev;
2330     u32 i;
2331
2332     for (i = 0; i < dev->i2c_num; i++) {
2333         if (dev->i2c[i].link == port->lnr &&
2334             dev->i2c[i].nr == port->nr) {
2335             port->i2c = &dev->i2c[i];
2336             return 1;
2337         }
2338     }
2339     return 0;
2340 }
2341
2342 static int ddb_port_match_link_i2c(struct ddb_port *port)
2343 {
2344     struct ddb *dev = port->dev;
2345     u32 i;
2346
2347     for (i = 0; i < dev->i2c_num; i++) {
2348         if (dev->i2c[i].link == port->lnr) {
2349             port->i2c = &dev->i2c[i];
2350             return 1;
2351         }
2352     }
2353     return 0;
2354 }
2355
2356 void ddb_ports_init(struct ddb *dev)
2357 {
2358     u32 i, l, p;
2359     struct ddb_port *port;
2360     const struct ddb_info *info;
2361     const struct ddb_regmap *rm;
2362
2363     for (p = l = 0; l < DDB_MAX_LINK; l++) {
2364         info = dev->link[l].info;
2365         if (!info)
2366             continue;
2367         rm = info->regmap;
2368         if (!rm)
2369             continue;
2370         for (i = 0; i < info->port_num; i++, p++) {
2371             port = &dev->port[p];
2372             port->dev = dev;
2373             port->nr = i;
2374             port->lnr = l;
2375             port->pnr = p;
2376             port->gap = 0xffffffff;
2377             port->obr = ci_bitrate;
2378             mutex_init(&port->i2c_gate_lock);
2379
2380             if (!ddb_port_match_i2c(port)) {
2381                 if (info->type == DDB_OCTOPUS_MAX)
2382                     ddb_port_match_link_i2c(port);
2383             }
2384
2385             ddb_port_probe(port);
2386
2387             port->dvb[0].adap = &dev->adap[2 * p];
2388             port->dvb[1].adap = &dev->adap[2 * p + 1];
2389
2390             if (port->class == DDB_PORT_NONE && i && p &&
2391                 dev->port[p - 1].type == DDB_CI_EXTERNAL_XO2) {
2392                 port->class = DDB_PORT_CI;
2393                 port->type = DDB_CI_EXTERNAL_XO2_B;
2394                 port->name = "DuoFlex CI_B";
2395                 port->i2c = dev->port[p - 1].i2c;
2396             }
2397
2398             dev_info(dev->dev, "Port %u: Link %u, Link Port %u (TAB %u): %s\n",
2399                  port->pnr, port->lnr, port->nr, port->nr + 1,
2400                  port->name);
2401
2402             if (port->class == DDB_PORT_CI &&
2403                 port->type == DDB_CI_EXTERNAL_XO2) {
2404                 ddb_input_init(port, 2 * i, 0, 2 * i);
2405                 ddb_output_init(port, i);
2406                 continue;
2407             }
2408
2409             if (port->class == DDB_PORT_CI &&
2410                 port->type == DDB_CI_EXTERNAL_XO2_B) {
2411                 ddb_input_init(port, 2 * i - 1, 0, 2 * i - 1);
2412                 ddb_output_init(port, i);
2413                 continue;
2414             }
2415
2416             if (port->class == DDB_PORT_NONE)
2417                 continue;
2418
2419             switch (dev->link[l].info->type) {
2420             case DDB_OCTOPUS_CI:
2421                 if (i >= 2) {
2422                     ddb_input_init(port, 2 + i, 0, 2 + i);
2423                     ddb_input_init(port, 4 + i, 1, 4 + i);
2424                     ddb_output_init(port, i);
2425                     break;
2426                 }
2427                 fallthrough;
2428             case DDB_OCTOPUS:
2429                 ddb_input_init(port, 2 * i, 0, 2 * i);
2430                 ddb_input_init(port, 2 * i + 1, 1, 2 * i + 1);
2431                 ddb_output_init(port, i);
2432                 break;
2433             case DDB_OCTOPUS_MAX:
2434             case DDB_OCTOPUS_MAX_CT:
2435             case DDB_OCTOPUS_MCI:
2436                 ddb_input_init(port, 2 * i, 0, 2 * p);
2437                 ddb_input_init(port, 2 * i + 1, 1, 2 * p + 1);
2438                 break;
2439             default:
2440                 break;
2441             }
2442         }
2443     }
2444     dev->port_num = p;
2445 }
2446
2447 void ddb_ports_release(struct ddb *dev)
2448 {
2449     int i;
2450     struct ddb_port *port;
2451
2452     for (i = 0; i < dev->port_num; i++) {
2453         port = &dev->port[i];
2454         if (port->input[0] && port->input[0]->dma)
2455             cancel_work_sync(&port->input[0]->dma->work);
2456         if (port->input[1] && port->input[1]->dma)
2457             cancel_work_sync(&port->input[1]->dma->work);
2458         if (port->output && port->output->dma)
2459             cancel_work_sync(&port->output->dma->work);
2460     }
2461 }
2462
2463 /****************************************************************************/
2464 /****************************************************************************/
2465 /****************************************************************************/
2466
2467 #define IRQ_HANDLE(_nr) \
2468     do { if ((s & (1UL << ((_nr) & 0x1f))) && \
2469          dev->link[0].irq[_nr].handler) \
2470         dev->link[0].irq[_nr].handler(dev->link[0].irq[_nr].data); } \
2471     while (0)
2472
2473 #define IRQ_HANDLE_NIBBLE(_shift) {          \
2474     if (s & (0x0000000f << ((_shift) & 0x1f))) { \
2475         IRQ_HANDLE(0 + (_shift));        \
2476         IRQ_HANDLE(1 + (_shift));        \
2477         IRQ_HANDLE(2 + (_shift));        \
2478         IRQ_HANDLE(3 + (_shift));        \
2479     }                        \
2480 }
2481
2482 #define IRQ_HANDLE_BYTE(_shift) {            \
2483     if (s & (0x000000ff << ((_shift) & 0x1f))) { \
2484         IRQ_HANDLE(0 + (_shift));        \
2485         IRQ_HANDLE(1 + (_shift));        \
2486         IRQ_HANDLE(2 + (_shift));        \
2487         IRQ_HANDLE(3 + (_shift));        \
2488         IRQ_HANDLE(4 + (_shift));        \
2489         IRQ_HANDLE(5 + (_shift));        \
2490         IRQ_HANDLE(6 + (_shift));        \
2491         IRQ_HANDLE(7 + (_shift));        \
2492     }                        \
2493 }
2494
2495 static void irq_handle_msg(struct ddb *dev, u32 s)
2496 {
2497     dev->i2c_irq++;
2498     IRQ_HANDLE_NIBBLE(0);
2499 }
2500
2501 static void irq_handle_io(struct ddb *dev, u32 s)
2502 {
2503     dev->ts_irq++;
2504     IRQ_HANDLE_NIBBLE(4);
2505     IRQ_HANDLE_BYTE(8);
2506     IRQ_HANDLE_BYTE(16);
2507     IRQ_HANDLE_BYTE(24);
2508 }
2509
2510 irqreturn_t ddb_irq_handler0(int irq, void *dev_id)
2511 {
2512     struct ddb *dev = (struct ddb *)dev_id;
2513     u32 mask = 0x8fffff00;
2514     u32 s = mask & ddbreadl(dev, INTERRUPT_STATUS);
2515
2516     if (!s)
2517         return IRQ_NONE;
2518     do {
2519         if (s & 0x80000000)
2520             return IRQ_NONE;
2521         ddbwritel(dev, s, INTERRUPT_ACK);
2522         irq_handle_io(dev, s);
2523     } while ((s = mask & ddbreadl(dev, INTERRUPT_STATUS)));
2524
2525     return IRQ_HANDLED;
2526 }
2527
2528 irqreturn_t ddb_irq_handler1(int irq, void *dev_id)
2529 {
2530     struct ddb *dev = (struct ddb *)dev_id;
2531     u32 mask = 0x8000000f;
2532     u32 s = mask & ddbreadl(dev, INTERRUPT_STATUS);
2533
2534     if (!s)
2535         return IRQ_NONE;
2536     do {
2537         if (s & 0x80000000)
2538             return IRQ_NONE;
2539         ddbwritel(dev, s, INTERRUPT_ACK);
2540         irq_handle_msg(dev, s);
2541     } while ((s = mask & ddbreadl(dev, INTERRUPT_STATUS)));
2542
2543     return IRQ_HANDLED;
2544 }
2545
2546 irqreturn_t ddb_irq_handler(int irq, void *dev_id)
2547 {
2548     struct ddb *dev = (struct ddb *)dev_id;
2549     u32 s = ddbreadl(dev, INTERRUPT_STATUS);
2550     int ret = IRQ_HANDLED;
2551
2552     if (!s)
2553         return IRQ_NONE;
2554     do {
2555         if (s & 0x80000000)
2556             return IRQ_NONE;
2557         ddbwritel(dev, s, INTERRUPT_ACK);
2558
2559         if (s & 0x0000000f)
2560             irq_handle_msg(dev, s);
2561         if (s & 0x0fffff00)
2562             irq_handle_io(dev, s);
2563     } while ((s = ddbreadl(dev, INTERRUPT_STATUS)));
2564
2565     return ret;
2566 }
2567
2568 /****************************************************************************/
2569 /****************************************************************************/
2570 /****************************************************************************/
2571
2572 static int reg_wait(struct ddb *dev, u32 reg, u32 bit)
2573 {
2574     u32 count = 0;
2575
2576     while (safe_ddbreadl(dev, reg) & bit) {
2577         ndelay(10);
2578         if (++count == 100)
2579             return -1;
2580     }
2581     return 0;
2582 }
2583
2584 static int flashio(struct ddb *dev, u32 lnr, u8 *wbuf, u32 wlen, u8 *rbuf,
2585            u32 rlen)
2586 {
2587     u32 data, shift;
2588     u32 tag = DDB_LINK_TAG(lnr);
2589     struct ddb_link *link = &dev->link[lnr];
2590
2591     mutex_lock(&link->flash_mutex);
2592     if (wlen > 4)
2593         ddbwritel(dev, 1, tag | SPI_CONTROL);
2594     while (wlen > 4) {
2595         /* FIXME: check for big-endian */
2596         data = swab32(*(u32 *)wbuf);
2597         wbuf += 4;
2598         wlen -= 4;
2599         ddbwritel(dev, data, tag | SPI_DATA);
2600         if (reg_wait(dev, tag | SPI_CONTROL, 4))
2601             goto fail;
2602     }
2603     if (rlen)
2604         ddbwritel(dev, 0x0001 | ((wlen << (8 + 3)) & 0x1f00),
2605               tag | SPI_CONTROL);
2606     else
2607         ddbwritel(dev, 0x0003 | ((wlen << (8 + 3)) & 0x1f00),
2608               tag | SPI_CONTROL);
2609
2610     data = 0;
2611     shift = ((4 - wlen) * 8);
2612     while (wlen) {
2613         data <<= 8;
2614         data |= *wbuf;
2615         wlen--;
2616         wbuf++;
2617     }
2618     if (shift)
2619         data <<= shift;
2620     ddbwritel(dev, data, tag | SPI_DATA);
2621     if (reg_wait(dev, tag | SPI_CONTROL, 4))
2622         goto fail;
2623
2624     if (!rlen) {
2625         ddbwritel(dev, 0, tag | SPI_CONTROL);
2626         goto exit;
2627     }
2628     if (rlen > 4)
2629         ddbwritel(dev, 1, tag | SPI_CONTROL);
2630
2631     while (rlen > 4) {
2632         ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2633         if (reg_wait(dev, tag | SPI_CONTROL, 4))
2634             goto fail;
2635         data = ddbreadl(dev, tag | SPI_DATA);
2636         *(u32 *)rbuf = swab32(data);
2637         rbuf += 4;
2638         rlen -= 4;
2639     }
2640     ddbwritel(dev, 0x0003 | ((rlen << (8 + 3)) & 0x1F00),
2641           tag | SPI_CONTROL);
2642     ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2643     if (reg_wait(dev, tag | SPI_CONTROL, 4))
2644         goto fail;
2645
2646     data = ddbreadl(dev, tag | SPI_DATA);
2647     ddbwritel(dev, 0, tag | SPI_CONTROL);
2648
2649     if (rlen < 4)
2650         data <<= ((4 - rlen) * 8);
2651
2652     while (rlen > 0) {
2653         *rbuf = ((data >> 24) & 0xff);
2654         data <<= 8;
2655         rbuf++;
2656         rlen--;
2657     }
2658 exit:
2659     mutex_unlock(&link->flash_mutex);
2660     return 0;
2661 fail:
2662     mutex_unlock(&link->flash_mutex);
2663     return -1;
2664 }
2665
2666 int ddbridge_flashread(struct ddb *dev, u32 link, u8 *buf, u32 addr, u32 len)
2667 {
2668     u8 cmd[4] = {0x03, (addr >> 16) & 0xff,
2669              (addr >> 8) & 0xff, addr & 0xff};
2670
2671     return flashio(dev, link, cmd, 4, buf, len);
2672 }
2673
2674 /*
2675  * TODO/FIXME: add/implement IOCTLs from upstream driver
2676  */
2677
2678 #define DDB_NAME "ddbridge"
2679
2680 static u32 ddb_num;
2681 static int ddb_major;
2682 static DEFINE_MUTEX(ddb_mutex);
2683
2684 static int ddb_release(struct inode *inode, struct file *file)
2685 {
2686     struct ddb *dev = file->private_data;
2687
2688     dev->ddb_dev_users--;
2689     return 0;
2690 }
2691
2692 static int ddb_open(struct inode *inode, struct file *file)
2693 {
2694     struct ddb *dev = ddbs[iminor(inode)];
2695
2696     if (dev->ddb_dev_users)
2697         return -EBUSY;
2698     dev->ddb_dev_users++;
2699     file->private_data = dev;
2700     return 0;
2701 }
2702
2703 static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2704 {
2705     struct ddb *dev = file->private_data;
2706
2707     dev_warn(dev->dev, "DDB IOCTLs unsupported (cmd: %d, arg: %lu)\n",
2708          cmd, arg);
2709
2710     return -ENOTTY;
2711 }
2712
2713 static const struct file_operations ddb_fops = {
2714     .unlocked_ioctl = ddb_ioctl,
2715     .open           = ddb_open,
2716     .release        = ddb_release,
2717 };
2718
2719 static char *ddb_devnode(struct device *device, umode_t *mode)
2720 {
2721     struct ddb *dev = dev_get_drvdata(device);
2722
2723     return kasprintf(GFP_KERNEL, "ddbridge/card%d", dev->nr);
2724 }
2725
2726 #define __ATTR_MRO(_name, _show) {              \
2727     .attr   = { .name = __stringify(_name), .mode = 0444 }, \
2728     .show   = _show,                    \
2729 }
2730
2731 #define __ATTR_MWO(_name, _store) {             \
2732     .attr   = { .name = __stringify(_name), .mode = 0222 }, \
2733     .store  = _store,                   \
2734 }
2735
2736 static ssize_t ports_show(struct device *device,
2737               struct device_attribute *attr, char *buf)
2738 {
2739     struct ddb *dev = dev_get_drvdata(device);
2740
2741     return sprintf(buf, "%d\n", dev->port_num);
2742 }
2743
2744 static ssize_t ts_irq_show(struct device *device,
2745                struct device_attribute *attr, char *buf)
2746 {
2747     struct ddb *dev = dev_get_drvdata(device);
2748
2749     return sprintf(buf, "%d\n", dev->ts_irq);
2750 }
2751
2752 static ssize_t i2c_irq_show(struct device *device,
2753                 struct device_attribute *attr, char *buf)
2754 {
2755     struct ddb *dev = dev_get_drvdata(device);
2756
2757     return sprintf(buf, "%d\n", dev->i2c_irq);
2758 }
2759
2760 static ssize_t fan_show(struct device *device,
2761             struct device_attribute *attr, char *buf)
2762 {
2763     struct ddb *dev = dev_get_drvdata(device);
2764     u32 val;
2765
2766     val = ddbreadl(dev, GPIO_OUTPUT) & 1;
2767     return sprintf(buf, "%d\n", val);
2768 }
2769
2770 static ssize_t fan_store(struct device *device, struct device_attribute *d,
2771              const char *buf, size_t count)
2772 {
2773     struct ddb *dev = dev_get_drvdata(device);
2774     u32 val;
2775
2776     if (sscanf(buf, "%u\n", &val) != 1)
2777         return -EINVAL;
2778     ddbwritel(dev, 1, GPIO_DIRECTION);
2779     ddbwritel(dev, val & 1, GPIO_OUTPUT);
2780     return count;
2781 }
2782
2783 static ssize_t fanspeed_show(struct device *device,
2784                  struct device_attribute *attr, char *buf)
2785 {
2786     struct ddb *dev = dev_get_drvdata(device);
2787     int num = attr->attr.name[8] - 0x30;
2788     struct ddb_link *link = &dev->link[num];
2789     u32 spd;
2790
2791     spd = ddblreadl(link, TEMPMON_FANCONTROL) & 0xff;
2792     return sprintf(buf, "%u\n", spd * 100);
2793 }
2794
2795 static ssize_t temp_show(struct device *device,
2796              struct device_attribute *attr, char *buf)
2797 {
2798     struct ddb *dev = dev_get_drvdata(device);
2799     struct ddb_link *link = &dev->link[0];
2800     struct i2c_adapter *adap;
2801     int temp, temp2;
2802     u8 tmp[2];
2803
2804     if (!link->info->temp_num)
2805         return sprintf(buf, "no sensor\n");
2806     adap = &dev->i2c[link->info->temp_bus].adap;
2807     if (i2c_read_regs(adap, 0x48, 0, tmp, 2) < 0)
2808         return sprintf(buf, "read_error\n");
2809     temp = (tmp[0] << 3) | (tmp[1] >> 5);
2810     temp *= 125;
2811     if (link->info->temp_num == 2) {
2812         if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
2813             return sprintf(buf, "read_error\n");
2814         temp2 = (tmp[0] << 3) | (tmp[1] >> 5);
2815         temp2 *= 125;
2816         return sprintf(buf, "%d %d\n", temp, temp2);
2817     }
2818     return sprintf(buf, "%d\n", temp);
2819 }
2820
2821 static ssize_t ctemp_show(struct device *device,
2822               struct device_attribute *attr, char *buf)
2823 {
2824     struct ddb *dev = dev_get_drvdata(device);
2825     struct i2c_adapter *adap;
2826     int temp;
2827     u8 tmp[2];
2828     int num = attr->attr.name[4] - 0x30;
2829
2830     adap = &dev->i2c[num].adap;
2831     if (!adap)
2832         return 0;
2833     if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
2834         if (i2c_read_regs(adap, 0x4d, 0, tmp, 2) < 0)
2835             return sprintf(buf, "no sensor\n");
2836     temp = tmp[0] * 1000;
2837     return sprintf(buf, "%d\n", temp);
2838 }
2839
2840 static ssize_t led_show(struct device *device,
2841             struct device_attribute *attr, char *buf)
2842 {
2843     struct ddb *dev = dev_get_drvdata(device);
2844     int num = attr->attr.name[3] - 0x30;
2845
2846     return sprintf(buf, "%d\n", dev->leds & (1 << num) ? 1 : 0);
2847 }
2848
2849 static void ddb_set_led(struct ddb *dev, int num, int val)
2850 {
2851     if (!dev->link[0].info->led_num)
2852         return;
2853     switch (dev->port[num].class) {
2854     case DDB_PORT_TUNER:
2855         switch (dev->port[num].type) {
2856         case DDB_TUNER_DVBS_ST:
2857             i2c_write_reg16(&dev->i2c[num].adap,
2858                     0x69, 0xf14c, val ? 2 : 0);
2859             break;
2860         case DDB_TUNER_DVBCT_ST:
2861             i2c_write_reg16(&dev->i2c[num].adap,
2862                     0x1f, 0xf00e, 0);
2863             i2c_write_reg16(&dev->i2c[num].adap,
2864                     0x1f, 0xf00f, val ? 1 : 0);
2865             break;
2866         case DDB_TUNER_XO2 ... DDB_TUNER_DVBC2T2I_SONY:
2867         {
2868             u8 v;
2869
2870             i2c_read_reg(&dev->i2c[num].adap, 0x10, 0x08, &v);
2871             v = (v & ~0x10) | (val ? 0x10 : 0);
2872             i2c_write_reg(&dev->i2c[num].adap, 0x10, 0x08, v);
2873             break;
2874         }
2875         default:
2876             break;
2877         }
2878         break;
2879     }
2880 }
2881
2882 static ssize_t led_store(struct device *device,
2883              struct device_attribute *attr,
2884              const char *buf, size_t count)
2885 {
2886     struct ddb *dev = dev_get_drvdata(device);
2887     int num = attr->attr.name[3] - 0x30;
2888     u32 val;
2889
2890     if (sscanf(buf, "%u\n", &val) != 1)
2891         return -EINVAL;
2892     if (val)
2893         dev->leds |= (1 << num);
2894     else
2895         dev->leds &= ~(1 << num);
2896     ddb_set_led(dev, num, val);
2897     return count;
2898 }
2899
2900 static ssize_t snr_show(struct device *device,
2901             struct device_attribute *attr, char *buf)
2902 {
2903     struct ddb *dev = dev_get_drvdata(device);
2904     char snr[32];
2905     int num = attr->attr.name[3] - 0x30;
2906
2907     if (dev->port[num].type >= DDB_TUNER_XO2) {
2908         if (i2c_read_regs(&dev->i2c[num].adap, 0x10, 0x10, snr, 16) < 0)
2909             return sprintf(buf, "NO SNR\n");
2910         snr[16] = 0;
2911     } else {
2912         /* serial number at 0x100-0x11f */
2913         if (i2c_read_regs16(&dev->i2c[num].adap,
2914                     0x57, 0x100, snr, 32) < 0)
2915             if (i2c_read_regs16(&dev->i2c[num].adap,
2916                         0x50, 0x100, snr, 32) < 0)
2917                 return sprintf(buf, "NO SNR\n");
2918         snr[31] = 0; /* in case it is not terminated on EEPROM */
2919     }
2920     return sprintf(buf, "%s\n", snr);
2921 }
2922
2923 static ssize_t bsnr_show(struct device *device,
2924              struct device_attribute *attr, char *buf)
2925 {
2926     struct ddb *dev = dev_get_drvdata(device);
2927     char snr[16];
2928
2929     ddbridge_flashread(dev, 0, snr, 0x10, 15);
2930     snr[15] = 0; /* in case it is not terminated on EEPROM */
2931     return sprintf(buf, "%s\n", snr);
2932 }
2933
2934 static ssize_t bpsnr_show(struct device *device,
2935               struct device_attribute *attr, char *buf)
2936 {
2937     struct ddb *dev = dev_get_drvdata(device);
2938     unsigned char snr[32];
2939
2940     if (!dev->i2c_num)
2941         return 0;
2942
2943     if (i2c_read_regs16(&dev->i2c[0].adap,
2944                 0x50, 0x0000, snr, 32) < 0 ||
2945         snr[0] == 0xff)
2946         return sprintf(buf, "NO SNR\n");
2947     snr[31] = 0; /* in case it is not terminated on EEPROM */
2948     return sprintf(buf, "%s\n", snr);
2949 }
2950
2951 static ssize_t redirect_show(struct device *device,
2952                  struct device_attribute *attr, char *buf)
2953 {
2954     return 0;
2955 }
2956
2957 static ssize_t redirect_store(struct device *device,
2958                   struct device_attribute *attr,
2959                   const char *buf, size_t count)
2960 {
2961     unsigned int i, p;
2962     int res;
2963
2964     if (sscanf(buf, "%x %x\n", &i, &p) != 2)
2965         return -EINVAL;
2966     res = ddb_redirect(i, p);
2967     if (res < 0)
2968         return res;
2969     dev_info(device, "redirect: %02x, %02x\n", i, p);
2970     return count;
2971 }
2972
2973 static ssize_t gap_show(struct device *device,
2974             struct device_attribute *attr, char *buf)
2975 {
2976     struct ddb *dev = dev_get_drvdata(device);
2977     int num = attr->attr.name[3] - 0x30;
2978
2979     return sprintf(buf, "%d\n", dev->port[num].gap);
2980 }
2981
2982 static ssize_t gap_store(struct device *device, struct device_attribute *attr,
2983              const char *buf, size_t count)
2984 {
2985     struct ddb *dev = dev_get_drvdata(device);
2986     int num = attr->attr.name[3] - 0x30;
2987     unsigned int val;
2988
2989     if (sscanf(buf, "%u\n", &val) != 1)
2990         return -EINVAL;
2991     if (val > 128)
2992         return -EINVAL;
2993     if (val == 128)
2994         val = 0xffffffff;
2995     dev->port[num].gap = val;
2996     return count;
2997 }
2998
2999 static ssize_t version_show(struct device *device,
3000                 struct device_attribute *attr, char *buf)
3001 {
3002     struct ddb *dev = dev_get_drvdata(device);
3003
3004     return sprintf(buf, "%08x %08x\n",
3005                dev->link[0].ids.hwid, dev->link[0].ids.regmapid);
3006 }
3007
3008 static ssize_t hwid_show(struct device *device,
3009              struct device_attribute *attr, char *buf)
3010 {
3011     struct ddb *dev = dev_get_drvdata(device);
3012
3013     return sprintf(buf, "0x%08X\n", dev->link[0].ids.hwid);
3014 }
3015
3016 static ssize_t regmap_show(struct device *device,
3017                struct device_attribute *attr, char *buf)
3018 {
3019     struct ddb *dev = dev_get_drvdata(device);
3020
3021     return sprintf(buf, "0x%08X\n", dev->link[0].ids.regmapid);
3022 }
3023
3024 static ssize_t fmode_show(struct device *device,
3025               struct device_attribute *attr, char *buf)
3026 {
3027     int num = attr->attr.name[5] - 0x30;
3028     struct ddb *dev = dev_get_drvdata(device);
3029
3030     return sprintf(buf, "%u\n", dev->link[num].lnb.fmode);
3031 }
3032
3033 static ssize_t devid_show(struct device *device,
3034               struct device_attribute *attr, char *buf)
3035 {
3036     int num = attr->attr.name[5] - 0x30;
3037     struct ddb *dev = dev_get_drvdata(device);
3038
3039     return sprintf(buf, "%08x\n", dev->link[num].ids.devid);
3040 }
3041
3042 static ssize_t fmode_store(struct device *device, struct device_attribute *attr,
3043                const char *buf, size_t count)
3044 {
3045     struct ddb *dev = dev_get_drvdata(device);
3046     int num = attr->attr.name[5] - 0x30;
3047     unsigned int val;
3048
3049     if (sscanf(buf, "%u\n", &val) != 1)
3050         return -EINVAL;
3051     if (val > 3)
3052         return -EINVAL;
3053     ddb_lnb_init_fmode(dev, &dev->link[num], val);
3054     return count;
3055 }
3056
3057 static struct device_attribute ddb_attrs[] = {
3058     __ATTR_RO(version),
3059     __ATTR_RO(ports),
3060     __ATTR_RO(ts_irq),
3061     __ATTR_RO(i2c_irq),
3062     __ATTR(gap0, 0664, gap_show, gap_store),
3063     __ATTR(gap1, 0664, gap_show, gap_store),
3064     __ATTR(gap2, 0664, gap_show, gap_store),
3065     __ATTR(gap3, 0664, gap_show, gap_store),
3066     __ATTR(fmode0, 0664, fmode_show, fmode_store),
3067     __ATTR(fmode1, 0664, fmode_show, fmode_store),
3068     __ATTR(fmode2, 0664, fmode_show, fmode_store),
3069     __ATTR(fmode3, 0664, fmode_show, fmode_store),
3070     __ATTR_MRO(devid0, devid_show),
3071     __ATTR_MRO(devid1, devid_show),
3072     __ATTR_MRO(devid2, devid_show),
3073     __ATTR_MRO(devid3, devid_show),
3074     __ATTR_RO(hwid),
3075     __ATTR_RO(regmap),
3076     __ATTR(redirect, 0664, redirect_show, redirect_store),
3077     __ATTR_MRO(snr,  bsnr_show),
3078     __ATTR_RO(bpsnr),
3079     __ATTR_NULL,
3080 };
3081
3082 static struct device_attribute ddb_attrs_temp[] = {
3083     __ATTR_RO(temp),
3084 };
3085
3086 static struct device_attribute ddb_attrs_fan[] = {
3087     __ATTR(fan, 0664, fan_show, fan_store),
3088 };
3089
3090 static struct device_attribute ddb_attrs_snr[] = {
3091     __ATTR_MRO(snr0, snr_show),
3092     __ATTR_MRO(snr1, snr_show),
3093     __ATTR_MRO(snr2, snr_show),
3094     __ATTR_MRO(snr3, snr_show),
3095 };
3096
3097 static struct device_attribute ddb_attrs_ctemp[] = {
3098     __ATTR_MRO(temp0, ctemp_show),
3099     __ATTR_MRO(temp1, ctemp_show),
3100     __ATTR_MRO(temp2, ctemp_show),
3101     __ATTR_MRO(temp3, ctemp_show),
3102 };
3103
3104 static struct device_attribute ddb_attrs_led[] = {
3105     __ATTR(led0, 0664, led_show, led_store),
3106     __ATTR(led1, 0664, led_show, led_store),
3107     __ATTR(led2, 0664, led_show, led_store),
3108     __ATTR(led3, 0664, led_show, led_store),
3109 };
3110
3111 static struct device_attribute ddb_attrs_fanspeed[] = {
3112     __ATTR_MRO(fanspeed0, fanspeed_show),
3113     __ATTR_MRO(fanspeed1, fanspeed_show),
3114     __ATTR_MRO(fanspeed2, fanspeed_show),
3115     __ATTR_MRO(fanspeed3, fanspeed_show),
3116 };
3117
3118 static struct class ddb_class = {
3119     .name       = "ddbridge",
3120     .owner          = THIS_MODULE,
3121     .devnode        = ddb_devnode,
3122 };
3123
3124 static int ddb_class_create(void)
3125 {
3126     ddb_major = register_chrdev(0, DDB_NAME, &ddb_fops);
3127     if (ddb_major < 0)
3128         return ddb_major;
3129     if (class_register(&ddb_class) < 0)
3130         return -1;
3131     return 0;
3132 }
3133
3134 static void ddb_class_destroy(void)
3135 {
3136     class_unregister(&ddb_class);
3137     unregister_chrdev(ddb_major, DDB_NAME);
3138 }
3139
3140 static void ddb_device_attrs_del(struct ddb *dev)
3141 {
3142     int i;
3143
3144     for (i = 0; i < 4; i++)
3145         if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3146             device_remove_file(dev->ddb_dev,
3147                        &ddb_attrs_fanspeed[i]);
3148     for (i = 0; i < dev->link[0].info->temp_num; i++)
3149         device_remove_file(dev->ddb_dev, &ddb_attrs_temp[i]);
3150     for (i = 0; i < dev->link[0].info->fan_num; i++)
3151         device_remove_file(dev->ddb_dev, &ddb_attrs_fan[i]);
3152     for (i = 0; i < dev->i2c_num && i < 4; i++) {
3153         if (dev->link[0].info->led_num)
3154             device_remove_file(dev->ddb_dev, &ddb_attrs_led[i]);
3155         device_remove_file(dev->ddb_dev, &ddb_attrs_snr[i]);
3156         device_remove_file(dev->ddb_dev, &ddb_attrs_ctemp[i]);
3157     }
3158     for (i = 0; ddb_attrs[i].attr.name; i++)
3159         device_remove_file(dev->ddb_dev, &ddb_attrs[i]);
3160 }
3161
3162 static int ddb_device_attrs_add(struct ddb *dev)
3163 {
3164     int i;
3165
3166     for (i = 0; ddb_attrs[i].attr.name; i++)
3167         if (device_create_file(dev->ddb_dev, &ddb_attrs[i]))
3168             goto fail;
3169     for (i = 0; i < dev->link[0].info->temp_num; i++)
3170         if (device_create_file(dev->ddb_dev, &ddb_attrs_temp[i]))
3171             goto fail;
3172     for (i = 0; i < dev->link[0].info->fan_num; i++)
3173         if (device_create_file(dev->ddb_dev, &ddb_attrs_fan[i]))
3174             goto fail;
3175     for (i = 0; (i < dev->i2c_num) && (i < 4); i++) {
3176         if (device_create_file(dev->ddb_dev, &ddb_attrs_snr[i]))
3177             goto fail;
3178         if (device_create_file(dev->ddb_dev, &ddb_attrs_ctemp[i]))
3179             goto fail;
3180         if (dev->link[0].info->led_num)
3181             if (device_create_file(dev->ddb_dev,
3182                            &ddb_attrs_led[i]))
3183                 goto fail;
3184     }
3185     for (i = 0; i < 4; i++)
3186         if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3187             if (device_create_file(dev->ddb_dev,
3188                            &ddb_attrs_fanspeed[i]))
3189                 goto fail;
3190     return 0;
3191 fail:
3192     return -1;
3193 }
3194
3195 int ddb_device_create(struct ddb *dev)
3196 {
3197     int res = 0;
3198
3199     if (ddb_num == DDB_MAX_ADAPTER)
3200         return -ENOMEM;
3201     mutex_lock(&ddb_mutex);
3202     dev->nr = ddb_num;
3203     ddbs[dev->nr] = dev;
3204     dev->ddb_dev = device_create(&ddb_class, dev->dev,
3205                      MKDEV(ddb_major, dev->nr),
3206                      dev, "ddbridge%d", dev->nr);
3207     if (IS_ERR(dev->ddb_dev)) {
3208         res = PTR_ERR(dev->ddb_dev);
3209         dev_info(dev->dev, "Could not create ddbridge%d\n", dev->nr);
3210         goto fail;
3211     }
3212     res = ddb_device_attrs_add(dev);
3213     if (res) {
3214         ddb_device_attrs_del(dev);
3215         device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3216         ddbs[dev->nr] = NULL;
3217         dev->ddb_dev = ERR_PTR(-ENODEV);
3218     } else {
3219         ddb_num++;
3220     }
3221 fail:
3222     mutex_unlock(&ddb_mutex);
3223     return res;
3224 }
3225
3226 void ddb_device_destroy(struct ddb *dev)
3227 {
3228     if (IS_ERR(dev->ddb_dev))
3229         return;
3230     ddb_device_attrs_del(dev);
3231     device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3232 }
3233
3234 /****************************************************************************/
3235 /****************************************************************************/
3236 /****************************************************************************/
3237
3238 static void tempmon_setfan(struct ddb_link *link)
3239 {
3240     u32 temp, temp2, pwm;
3241
3242     if ((ddblreadl(link, TEMPMON_CONTROL) &
3243         TEMPMON_CONTROL_OVERTEMP) != 0) {
3244         dev_info(link->dev->dev, "Over temperature condition\n");
3245         link->overtemperature_error = 1;
3246     }
3247     temp  = (ddblreadl(link, TEMPMON_SENSOR0) >> 8) & 0xFF;
3248     if (temp & 0x80)
3249         temp = 0;
3250     temp2  = (ddblreadl(link, TEMPMON_SENSOR1) >> 8) & 0xFF;
3251     if (temp2 & 0x80)
3252         temp2 = 0;
3253     if (temp2 > temp)
3254         temp = temp2;
3255
3256     pwm = (ddblreadl(link, TEMPMON_FANCONTROL) >> 8) & 0x0F;
3257     if (pwm > 10)
3258         pwm = 10;
3259
3260     if (temp >= link->temp_tab[pwm]) {
3261         while (pwm < 10 && temp >= link->temp_tab[pwm + 1])
3262             pwm += 1;
3263     } else {
3264         while (pwm > 1 && temp < link->temp_tab[pwm - 2])
3265             pwm -= 1;
3266     }
3267     ddblwritel(link, (pwm << 8), TEMPMON_FANCONTROL);
3268 }
3269
3270 static void temp_handler(void *data)
3271 {
3272     struct ddb_link *link = (struct ddb_link *)data;
3273
3274     spin_lock(&link->temp_lock);
3275     tempmon_setfan(link);
3276     spin_unlock(&link->temp_lock);
3277 }
3278
3279 static int tempmon_init(struct ddb_link *link, int first_time)
3280 {
3281     struct ddb *dev = link->dev;
3282     int status = 0;
3283     u32 l = link->nr;
3284
3285     spin_lock_irq(&link->temp_lock);
3286     if (first_time) {
3287         static u8 temperature_table[11] = {
3288             30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80 };
3289
3290         memcpy(link->temp_tab, temperature_table,
3291                sizeof(temperature_table));
3292     }
3293     ddb_irq_set(dev, l, link->info->tempmon_irq, temp_handler, link);
3294     ddblwritel(link, (TEMPMON_CONTROL_OVERTEMP | TEMPMON_CONTROL_AUTOSCAN |
3295               TEMPMON_CONTROL_INTENABLE),
3296            TEMPMON_CONTROL);
3297     ddblwritel(link, (3 << 8), TEMPMON_FANCONTROL);
3298
3299     link->overtemperature_error =
3300         ((ddblreadl(link, TEMPMON_CONTROL) &
3301             TEMPMON_CONTROL_OVERTEMP) != 0);
3302     if (link->overtemperature_error) {
3303         dev_info(link->dev->dev, "Over temperature condition\n");
3304         status = -1;
3305     }
3306     tempmon_setfan(link);
3307     spin_unlock_irq(&link->temp_lock);
3308     return status;
3309 }
3310
3311 static int ddb_init_tempmon(struct ddb_link *link)
3312 {
3313     const struct ddb_info *info = link->info;
3314
3315     if (!info->tempmon_irq)
3316         return 0;
3317     if (info->type == DDB_OCTOPUS_MAX_CT)
3318         if (link->ids.regmapid < 0x00010002)
3319             return 0;
3320     spin_lock_init(&link->temp_lock);
3321     dev_dbg(link->dev->dev, "init_tempmon\n");
3322     return tempmon_init(link, 1);
3323 }
3324
3325 /****************************************************************************/
3326 /****************************************************************************/
3327 /****************************************************************************/
3328
3329 static int ddb_init_boards(struct ddb *dev)
3330 {
3331     const struct ddb_info *info;
3332     struct ddb_link *link;
3333     u32 l;
3334
3335     for (l = 0; l < DDB_MAX_LINK; l++) {
3336         link = &dev->link[l];
3337         info = link->info;
3338
3339         if (!info)
3340             continue;
3341         if (info->board_control) {
3342             ddbwritel(dev, 0, DDB_LINK_TAG(l) | BOARD_CONTROL);
3343             msleep(100);
3344             ddbwritel(dev, info->board_control_2,
3345                   DDB_LINK_TAG(l) | BOARD_CONTROL);
3346             usleep_range(2000, 3000);
3347             ddbwritel(dev,
3348                   info->board_control_2 | info->board_control,
3349                   DDB_LINK_TAG(l) | BOARD_CONTROL);
3350             usleep_range(2000, 3000);
3351         }
3352         ddb_init_tempmon(link);
3353     }
3354     return 0;
3355 }
3356
3357 int ddb_init(struct ddb *dev)
3358 {
3359     mutex_init(&dev->link[0].lnb.lock);
3360     mutex_init(&dev->link[0].flash_mutex);
3361     if (no_init) {
3362         ddb_device_create(dev);
3363         return 0;
3364     }
3365
3366     ddb_init_boards(dev);
3367
3368     if (ddb_i2c_init(dev) < 0)
3369         goto fail1;
3370     ddb_ports_init(dev);
3371     if (ddb_buffers_alloc(dev) < 0) {
3372         dev_info(dev->dev, "Could not allocate buffer memory\n");
3373         goto fail2;
3374     }
3375     if (ddb_ports_attach(dev) < 0)
3376         goto fail3;
3377
3378     ddb_device_create(dev);
3379
3380     if (dev->link[0].info->fan_num) {
3381         ddbwritel(dev, 1, GPIO_DIRECTION);
3382         ddbwritel(dev, 1, GPIO_OUTPUT);
3383     }
3384     return 0;
3385
3386 fail3:
3387     dev_err(dev->dev, "fail3\n");
3388     ddb_ports_detach(dev);
3389     ddb_buffers_free(dev);
3390 fail2:
3391     dev_err(dev->dev, "fail2\n");
3392     ddb_ports_release(dev);
3393     ddb_i2c_release(dev);
3394 fail1:
3395     dev_err(dev->dev, "fail1\n");
3396     return -1;
3397 }
3398
3399 void ddb_unmap(struct ddb *dev)
3400 {
3401     if (dev->regs)
3402         iounmap(dev->regs);
3403     vfree(dev);
3404 }
3405
3406 int ddb_exit_ddbridge(int stage, int error)
3407 {
3408     switch (stage) {
3409     default:
3410     case 2:
3411         destroy_workqueue(ddb_wq);
3412         fallthrough;
3413     case 1:
3414         ddb_class_destroy();
3415         break;
3416     }
3417
3418     return error;
3419 }
3420
3421 int ddb_init_ddbridge(void)
3422 {
3423     if (dma_buf_num < 8)
3424         dma_buf_num = 8;
3425     if (dma_buf_num > 32)
3426         dma_buf_num = 32;
3427     if (dma_buf_size < 1)
3428         dma_buf_size = 1;
3429     if (dma_buf_size > 43)
3430         dma_buf_size = 43;
3431
3432     if (ddb_class_create() < 0)
3433         return -1;
3434     ddb_wq = alloc_workqueue("ddbridge", 0, 0);
3435     if (!ddb_wq)
3436         return ddb_exit_ddbridge(1, -1);
3437
3438     return 0;
3439 }