drivers/media/pci/ddbridge/ddbridge-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ddbridge-core.c: Digital Devices bridge core functions
   4  *
   5  * Copyright (C) 2010-2017 Digital Devices GmbH
   6  *                         Marcus Metzler <mocm@metzlerbros.de>
   7  *                         Ralph Metzler <rjkm@metzlerbros.de>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * version 2 only, as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/poll.h>
  25 #include <linux/io.h>
  26 #include <linux/pci.h>
  27 #include <linux/pci_ids.h>
  28 #include <linux/timer.h>
  29 #include <linux/i2c.h>
  30 #include <linux/swab.h>
  31 #include <linux/vmalloc.h>
  32
  33 #include "ddbridge.h"
  34 #include "ddbridge-i2c.h"
  35 #include "ddbridge-regs.h"
  36 #include "ddbridge-max.h"
  37 #include "ddbridge-ci.h"
  38 #include "ddbridge-io.h"
  39
  40 #include "tda18271c2dd.h"
  41 #include "stv6110x.h"
  42 #include "stv090x.h"
  43 #include "lnbh24.h"
  44 #include "drxk.h"
  45 #include "stv0367.h"
  46 #include "stv0367_priv.h"
  47 #include "cxd2841er.h"
  48 #include "tda18212.h"
  49 #include "stv0910.h"
  50 #include "stv6111.h"
  51 #include "lnbh25.h"
  52 #include "cxd2099.h"
  53 #include "dvb_dummy_fe.h"
  54
  55 /****************************************************************************/
  56
  57 #define DDB_MAX_ADAPTER 64
  58
  59 /****************************************************************************/
  60
  61 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  62
  63 static int adapter_alloc;
  64 module_param(adapter_alloc, int, 0444);
  65 MODULE_PARM_DESC(adapter_alloc,
  66                  "0-one adapter per io, 1-one per tab with io, 2-one per tab, 3-one for all");
  67
  68 static int ci_bitrate = 70000;
  69 module_param(ci_bitrate, int, 0444);
  70 MODULE_PARM_DESC(ci_bitrate, " Bitrate in KHz for output to CI.");
  71
  72 static int ts_loop = -1;
  73 module_param(ts_loop, int, 0444);
  74 MODULE_PARM_DESC(ts_loop, "TS in/out test loop on port ts_loop");
  75
  76 static int xo2_speed = 2;
  77 module_param(xo2_speed, int, 0444);
  78 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");
  79
  80 #ifdef __arm__
  81 static int alt_dma = 1;
  82 #else
  83 static int alt_dma;
  84 #endif
  85 module_param(alt_dma, int, 0444);
  86 MODULE_PARM_DESC(alt_dma, "use alternative DMA buffer handling");
  87
  88 static int no_init;
  89 module_param(no_init, int, 0444);
  90 MODULE_PARM_DESC(no_init, "do not initialize most devices");
  91
  92 static int stv0910_single;
  93 module_param(stv0910_single, int, 0444);
  94 MODULE_PARM_DESC(stv0910_single, "use stv0910 cards as single demods");
  95
  96 static int dma_buf_num = 8;
  97 module_param(dma_buf_num, int, 0444);
  98 MODULE_PARM_DESC(dma_buf_num, "Number of DMA buffers, possible values: 8-32");
  99
 100 static int dma_buf_size = 21;
 101 module_param(dma_buf_size, int, 0444);
 102 MODULE_PARM_DESC(dma_buf_size,
 103                  "DMA buffer size as multiple of 128*47, possible values: 1-43");
 104
 105 static int dummy_tuner;
 106 module_param(dummy_tuner, int, 0444);
 107 MODULE_PARM_DESC(dummy_tuner,
 108                  "attach dummy tuner to port 0 on Octopus V3 or Octopus Mini cards");
 109
 110 /****************************************************************************/
 111
 112 static DEFINE_MUTEX(redirect_lock);
 113
 114 static struct workqueue_struct *ddb_wq;
 115
 116 static struct ddb *ddbs[DDB_MAX_ADAPTER];
 117
 118 /****************************************************************************/
 119 /****************************************************************************/
 120 /****************************************************************************/
 121
 122 struct ddb_irq *ddb_irq_set(struct ddb *dev, u32 link, u32 nr,
 123                             void (*handler)(void *), void *data)
 124 {
 125         struct ddb_irq *irq = &dev->link[link].irq[nr];
 126
 127         irq->handler = handler;
 128         irq->data = data;
 129         return irq;
 130 }
 131
 132 static void ddb_set_dma_table(struct ddb_io *io)
 133 {
 134         struct ddb *dev = io->port->dev;
 135         struct ddb_dma *dma = io->dma;
 136         u32 i;
 137         u64 mem;
 138
 139         if (!dma)
 140                 return;
 141         for (i = 0; i < dma->num; i++) {
 142                 mem = dma->pbuf[i];
 143                 ddbwritel(dev, mem & 0xffffffff, dma->bufregs + i * 8);
 144                 ddbwritel(dev, mem >> 32, dma->bufregs + i * 8 + 4);
 145         }
 146         dma->bufval = ((dma->div & 0x0f) << 16) |
 147                 ((dma->num & 0x1f) << 11) |
 148                 ((dma->size >> 7) & 0x7ff);
 149 }
 150
 151 static void ddb_set_dma_tables(struct ddb *dev)
 152 {
 153         u32 i;
 154
 155         for (i = 0; i < DDB_MAX_PORT; i++) {
 156                 if (dev->port[i].input[0])
 157                         ddb_set_dma_table(dev->port[i].input[0]);
 158                 if (dev->port[i].input[1])
 159                         ddb_set_dma_table(dev->port[i].input[1]);
 160                 if (dev->port[i].output)
 161                         ddb_set_dma_table(dev->port[i].output);
 162         }
 163 }
 164
 165 /****************************************************************************/
 166 /****************************************************************************/
 167 /****************************************************************************/
 168
 169 static void ddb_redirect_dma(struct ddb *dev,
 170                              struct ddb_dma *sdma,
 171                              struct ddb_dma *ddma)
 172 {
 173         u32 i, base;
 174         u64 mem;
 175
 176         sdma->bufval = ddma->bufval;
 177         base = sdma->bufregs;
 178         for (i = 0; i < ddma->num; i++) {
 179                 mem = ddma->pbuf[i];
 180                 ddbwritel(dev, mem & 0xffffffff, base + i * 8);
 181                 ddbwritel(dev, mem >> 32, base + i * 8 + 4);
 182         }
 183 }
 184
 185 static int ddb_unredirect(struct ddb_port *port)
 186 {
 187         struct ddb_input *oredi, *iredi = NULL;
 188         struct ddb_output *iredo = NULL;
 189
 190         /* dev_info(port->dev->dev,
 191          * "unredirect %d.%d\n", port->dev->nr, port->nr);
 192          */
 193         mutex_lock(&redirect_lock);
 194         if (port->output->dma->running) {
 195                 mutex_unlock(&redirect_lock);
 196                 return -EBUSY;
 197         }
 198         oredi = port->output->redi;
 199         if (!oredi)
 200                 goto done;
 201         if (port->input[0]) {
 202                 iredi = port->input[0]->redi;
 203                 iredo = port->input[0]->redo;
 204
 205                 if (iredo) {
 206                         iredo->port->output->redi = oredi;
 207                         if (iredo->port->input[0]) {
 208                                 iredo->port->input[0]->redi = iredi;
 209                                 ddb_redirect_dma(oredi->port->dev,
 210                                                  oredi->dma, iredo->dma);
 211                         }
 212                         port->input[0]->redo = NULL;
 213                         ddb_set_dma_table(port->input[0]);
 214                 }
 215                 oredi->redi = iredi;
 216                 port->input[0]->redi = NULL;
 217         }
 218         oredi->redo = NULL;
 219         port->output->redi = NULL;
 220
 221         ddb_set_dma_table(oredi);
 222 done:
 223         mutex_unlock(&redirect_lock);
 224         return 0;
 225 }
 226
 227 static int ddb_redirect(u32 i, u32 p)
 228 {
 229         struct ddb *idev = ddbs[(i >> 4) & 0x3f];
 230         struct ddb_input *input, *input2;
 231         struct ddb *pdev = ddbs[(p >> 4) & 0x3f];
 232         struct ddb_port *port;
 233
 234         if (!idev || !pdev)
 235                 return -EINVAL;
 236         if (!idev->has_dma || !pdev->has_dma)
 237                 return -EINVAL;
 238
 239         port = &pdev->port[p & 0x0f];
 240         if (!port->output)
 241                 return -EINVAL;
 242         if (ddb_unredirect(port))
 243                 return -EBUSY;
 244
 245         if (i == 8)
 246                 return 0;
 247
 248         input = &idev->input[i & 7];
 249         if (!input)
 250                 return -EINVAL;
 251
 252         mutex_lock(&redirect_lock);
 253         if (port->output->dma->running || input->dma->running) {
 254                 mutex_unlock(&redirect_lock);
 255                 return -EBUSY;
 256         }
 257         input2 = port->input[0];
 258         if (input2) {
 259                 if (input->redi) {
 260                         input2->redi = input->redi;
 261                         input->redi = NULL;
 262                 } else {
 263                         input2->redi = input;
 264                 }
 265         }
 266         input->redo = port->output;
 267         port->output->redi = input;
 268
 269         ddb_redirect_dma(input->port->dev, input->dma, port->output->dma);
 270         mutex_unlock(&redirect_lock);
 271         return 0;
 272 }
 273
 274 /****************************************************************************/
 275 /****************************************************************************/
 276 /****************************************************************************/
 277
 278 static void dma_free(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
 279 {
 280         int i;
 281
 282         if (!dma)
 283                 return;
 284         for (i = 0; i < dma->num; i++) {
 285                 if (dma->vbuf[i]) {
 286                         if (alt_dma) {
 287                                 dma_unmap_single(&pdev->dev, dma->pbuf[i],
 288                                                  dma->size,
 289                                                  dir ? DMA_TO_DEVICE :
 290                                                  DMA_FROM_DEVICE);
 291                                 kfree(dma->vbuf[i]);
 292                                 dma->vbuf[i] = NULL;
 293                         } else {
 294                                 dma_free_coherent(&pdev->dev, dma->size,
 295                                                   dma->vbuf[i], dma->pbuf[i]);
 296                         }
 297
 298                         dma->vbuf[i] = NULL;
 299                 }
 300         }
 301 }
 302
 303 static int dma_alloc(struct pci_dev *pdev, struct ddb_dma *dma, int dir)
 304 {
 305         int i;
 306
 307         if (!dma)
 308                 return 0;
 309         for (i = 0; i < dma->num; i++) {
 310                 if (alt_dma) {
 311                         dma->vbuf[i] = kmalloc(dma->size, __GFP_RETRY_MAYFAIL);
 312                         if (!dma->vbuf[i])
 313                                 return -ENOMEM;
 314                         dma->pbuf[i] = dma_map_single(&pdev->dev,
 315                                                       dma->vbuf[i],
 316                                                       dma->size,
 317                                                       dir ? DMA_TO_DEVICE :
 318                                                       DMA_FROM_DEVICE);
 319                         if (dma_mapping_error(&pdev->dev, dma->pbuf[i])) {
 320                                 kfree(dma->vbuf[i]);
 321                                 dma->vbuf[i] = NULL;
 322                                 return -ENOMEM;
 323                         }
 324                 } else {
 325                         dma->vbuf[i] = dma_alloc_coherent(&pdev->dev,
 326                                                           dma->size,
 327                                                           &dma->pbuf[i],
 328                                                           GFP_KERNEL);
 329                         if (!dma->vbuf[i])
 330                                 return -ENOMEM;
 331                 }
 332         }
 333         return 0;
 334 }
 335
 336 int ddb_buffers_alloc(struct ddb *dev)
 337 {
 338         int i;
 339         struct ddb_port *port;
 340
 341         for (i = 0; i < dev->port_num; i++) {
 342                 port = &dev->port[i];
 343                 switch (port->class) {
 344                 case DDB_PORT_TUNER:
 345                         if (port->input[0]->dma)
 346                                 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
 347                                         < 0)
 348                                         return -1;
 349                         if (port->input[1]->dma)
 350                                 if (dma_alloc(dev->pdev, port->input[1]->dma, 0)
 351                                         < 0)
 352                                         return -1;
 353                         break;
 354                 case DDB_PORT_CI:
 355                 case DDB_PORT_LOOP:
 356                         if (port->input[0]->dma)
 357                                 if (dma_alloc(dev->pdev, port->input[0]->dma, 0)
 358                                         < 0)
 359                                         return -1;
 360                         if (port->output->dma)
 361                                 if (dma_alloc(dev->pdev, port->output->dma, 1)
 362                                         < 0)
 363                                         return -1;
 364                         break;
 365                 default:
 366                         break;
 367                 }
 368         }
 369         ddb_set_dma_tables(dev);
 370         return 0;
 371 }
 372
 373 void ddb_buffers_free(struct ddb *dev)
 374 {
 375         int i;
 376         struct ddb_port *port;
 377
 378         for (i = 0; i < dev->port_num; i++) {
 379                 port = &dev->port[i];
 380
 381                 if (port->input[0] && port->input[0]->dma)
 382                         dma_free(dev->pdev, port->input[0]->dma, 0);
 383                 if (port->input[1] && port->input[1]->dma)
 384                         dma_free(dev->pdev, port->input[1]->dma, 0);
 385                 if (port->output && port->output->dma)
 386                         dma_free(dev->pdev, port->output->dma, 1);
 387         }
 388 }
 389
 390 static void calc_con(struct ddb_output *output, u32 *con, u32 *con2, u32 flags)
 391 {
 392         struct ddb *dev = output->port->dev;
 393         u32 bitrate = output->port->obr, max_bitrate = 72000;
 394         u32 gap = 4, nco = 0;
 395
 396         *con = 0x1c;
 397         if (output->port->gap != 0xffffffff) {
 398                 flags |= 1;
 399                 gap = output->port->gap;
 400                 max_bitrate = 0;
 401         }
 402         if (dev->link[0].info->type == DDB_OCTOPUS_CI && output->port->nr > 1) {
 403                 *con = 0x10c;
 404                 if (dev->link[0].ids.regmapid >= 0x10003 && !(flags & 1)) {
 405                         if (!(flags & 2)) {
 406                                 /* NCO */
 407                                 max_bitrate = 0;
 408                                 gap = 0;
 409                                 if (bitrate != 72000) {
 410                                         if (bitrate >= 96000) {
 411                                                 *con |= 0x800;
 412                                         } else {
 413                                                 *con |= 0x1000;
 414                                                 nco = (bitrate * 8192 + 71999)
 415                                                         / 72000;
 416                                         }
 417                                 }
 418                         } else {
 419                                 /* Divider and gap */
 420                                 *con |= 0x1810;
 421                                 if (bitrate <= 64000) {
 422                                         max_bitrate = 64000;
 423                                         nco = 8;
 424                                 } else if (bitrate <= 72000) {
 425                                         max_bitrate = 72000;
 426                                         nco = 7;
 427                                 } else {
 428                                         max_bitrate = 96000;
 429                                         nco = 5;
 430                                 }
 431                         }
 432                 } else {
 433                         if (bitrate > 72000) {
 434                                 *con |= 0x810; /* 96 MBit/s and gap */
 435                                 max_bitrate = 96000;
 436                         }
 437                         *con |= 0x10; /* enable gap */
 438                 }
 439         }
 440         if (max_bitrate > 0) {
 441                 if (bitrate > max_bitrate)
 442                         bitrate = max_bitrate;
 443                 if (bitrate < 31000)
 444                         bitrate = 31000;
 445                 gap = ((max_bitrate - bitrate) * 94) / bitrate;
 446                 if (gap < 2)
 447                         *con &= ~0x10; /* Disable gap */
 448                 else
 449                         gap -= 2;
 450                 if (gap > 127)
 451                         gap = 127;
 452         }
 453
 454         *con2 = (nco << 16) | gap;
 455 }
 456
 457 static void ddb_output_start(struct ddb_output *output)
 458 {
 459         struct ddb *dev = output->port->dev;
 460         u32 con = 0x11c, con2 = 0;
 461
 462         spin_lock_irq(&output->dma->lock);
 463         output->dma->cbuf = 0;
 464         output->dma->coff = 0;
 465         output->dma->stat = 0;
 466         ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
 467
 468         if (output->port->input[0]->port->class == DDB_PORT_LOOP)
 469                 con = (1UL << 13) | 0x14;
 470         else
 471                 calc_con(output, &con, &con2, 0);
 472
 473         ddbwritel(dev, 0, TS_CONTROL(output));
 474         ddbwritel(dev, 2, TS_CONTROL(output));
 475         ddbwritel(dev, 0, TS_CONTROL(output));
 476         ddbwritel(dev, con, TS_CONTROL(output));
 477         ddbwritel(dev, con2, TS_CONTROL2(output));
 478
 479         ddbwritel(dev, output->dma->bufval,
 480                   DMA_BUFFER_SIZE(output->dma));
 481         ddbwritel(dev, 0, DMA_BUFFER_ACK(output->dma));
 482         ddbwritel(dev, 1, DMA_BASE_READ);
 483         ddbwritel(dev, 7, DMA_BUFFER_CONTROL(output->dma));
 484
 485         ddbwritel(dev, con | 1, TS_CONTROL(output));
 486
 487         output->dma->running = 1;
 488         spin_unlock_irq(&output->dma->lock);
 489 }
 490
 491 static void ddb_output_stop(struct ddb_output *output)
 492 {
 493         struct ddb *dev = output->port->dev;
 494
 495         spin_lock_irq(&output->dma->lock);
 496
 497         ddbwritel(dev, 0, TS_CONTROL(output));
 498
 499         ddbwritel(dev, 0, DMA_BUFFER_CONTROL(output->dma));
 500         output->dma->running = 0;
 501         spin_unlock_irq(&output->dma->lock);
 502 }
 503
 504 static void ddb_input_stop(struct ddb_input *input)
 505 {
 506         struct ddb *dev = input->port->dev;
 507         u32 tag = DDB_LINK_TAG(input->port->lnr);
 508
 509         spin_lock_irq(&input->dma->lock);
 510
 511         ddbwritel(dev, 0, tag | TS_CONTROL(input));
 512
 513         ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
 514         input->dma->running = 0;
 515         spin_unlock_irq(&input->dma->lock);
 516 }
 517
 518 static void ddb_input_start(struct ddb_input *input)
 519 {
 520         struct ddb *dev = input->port->dev;
 521
 522         spin_lock_irq(&input->dma->lock);
 523         input->dma->cbuf = 0;
 524         input->dma->coff = 0;
 525         input->dma->stat = 0;
 526         ddbwritel(dev, 0, DMA_BUFFER_CONTROL(input->dma));
 527
 528         ddbwritel(dev, 0, TS_CONTROL(input));
 529         ddbwritel(dev, 2, TS_CONTROL(input));
 530         ddbwritel(dev, 0, TS_CONTROL(input));
 531
 532         ddbwritel(dev, input->dma->bufval,
 533                   DMA_BUFFER_SIZE(input->dma));
 534         ddbwritel(dev, 0, DMA_BUFFER_ACK(input->dma));
 535         ddbwritel(dev, 1, DMA_BASE_WRITE);
 536         ddbwritel(dev, 3, DMA_BUFFER_CONTROL(input->dma));
 537
 538         ddbwritel(dev, 0x09, TS_CONTROL(input));
 539
 540         if (input->port->type == DDB_TUNER_DUMMY)
 541                 ddbwritel(dev, 0x000fff01, TS_CONTROL2(input));
 542
 543         input->dma->running = 1;
 544         spin_unlock_irq(&input->dma->lock);
 545 }
 546
 547 static void ddb_input_start_all(struct ddb_input *input)
 548 {
 549         struct ddb_input *i = input;
 550         struct ddb_output *o;
 551
 552         mutex_lock(&redirect_lock);
 553         while (i && (o = i->redo)) {
 554                 ddb_output_start(o);
 555                 i = o->port->input[0];
 556                 if (i)
 557                         ddb_input_start(i);
 558         }
 559         ddb_input_start(input);
 560         mutex_unlock(&redirect_lock);
 561 }
 562
 563 static void ddb_input_stop_all(struct ddb_input *input)
 564 {
 565         struct ddb_input *i = input;
 566         struct ddb_output *o;
 567
 568         mutex_lock(&redirect_lock);
 569         ddb_input_stop(input);
 570         while (i && (o = i->redo)) {
 571                 ddb_output_stop(o);
 572                 i = o->port->input[0];
 573                 if (i)
 574                         ddb_input_stop(i);
 575         }
 576         mutex_unlock(&redirect_lock);
 577 }
 578
 579 static u32 ddb_output_free(struct ddb_output *output)
 580 {
 581         u32 idx, off, stat = output->dma->stat;
 582         s32 diff;
 583
 584         idx = (stat >> 11) & 0x1f;
 585         off = (stat & 0x7ff) << 7;
 586
 587         if (output->dma->cbuf != idx) {
 588                 if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
 589                     (output->dma->size - output->dma->coff <= (2 * 188)))
 590                         return 0;
 591                 return 188;
 592         }
 593         diff = off - output->dma->coff;
 594         if (diff <= 0 || diff > (2 * 188))
 595                 return 188;
 596         return 0;
 597 }
 598
 599 static ssize_t ddb_output_write(struct ddb_output *output,
 600                                 const __user u8 *buf, size_t count)
 601 {
 602         struct ddb *dev = output->port->dev;
 603         u32 idx, off, stat = output->dma->stat;
 604         u32 left = count, len;
 605
 606         idx = (stat >> 11) & 0x1f;
 607         off = (stat & 0x7ff) << 7;
 608
 609         while (left) {
 610                 len = output->dma->size - output->dma->coff;
 611                 if ((((output->dma->cbuf + 1) % output->dma->num) == idx) &&
 612                     off == 0) {
 613                         if (len <= 188)
 614                                 break;
 615                         len -= 188;
 616                 }
 617                 if (output->dma->cbuf == idx) {
 618                         if (off > output->dma->coff) {
 619                                 len = off - output->dma->coff;
 620                                 len -= (len % 188);
 621                                 if (len <= 188)
 622                                         break;
 623                                 len -= 188;
 624                         }
 625                 }
 626                 if (len > left)
 627                         len = left;
 628                 if (copy_from_user(output->dma->vbuf[output->dma->cbuf] +
 629                                    output->dma->coff,
 630                                    buf, len))
 631                         return -EIO;
 632                 if (alt_dma)
 633                         dma_sync_single_for_device(
 634                                 dev->dev,
 635                                 output->dma->pbuf[output->dma->cbuf],
 636                                 output->dma->size, DMA_TO_DEVICE);
 637                 left -= len;
 638                 buf += len;
 639                 output->dma->coff += len;
 640                 if (output->dma->coff == output->dma->size) {
 641                         output->dma->coff = 0;
 642                         output->dma->cbuf = ((output->dma->cbuf + 1) %
 643                                              output->dma->num);
 644                 }
 645                 ddbwritel(dev,
 646                           (output->dma->cbuf << 11) |
 647                           (output->dma->coff >> 7),
 648                           DMA_BUFFER_ACK(output->dma));
 649         }
 650         return count - left;
 651 }
 652
 653 static u32 ddb_input_avail(struct ddb_input *input)
 654 {
 655         struct ddb *dev = input->port->dev;
 656         u32 idx, off, stat = input->dma->stat;
 657         u32 ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(input->dma));
 658
 659         idx = (stat >> 11) & 0x1f;
 660         off = (stat & 0x7ff) << 7;
 661
 662         if (ctrl & 4) {
 663                 dev_err(dev->dev, "IA %d %d %08x\n", idx, off, ctrl);
 664                 ddbwritel(dev, stat, DMA_BUFFER_ACK(input->dma));
 665                 return 0;
 666         }
 667         if (input->dma->cbuf != idx)
 668                 return 188;
 669         return 0;
 670 }
 671
 672 static ssize_t ddb_input_read(struct ddb_input *input,
 673                               __user u8 *buf, size_t count)
 674 {
 675         struct ddb *dev = input->port->dev;
 676         u32 left = count;
 677         u32 idx, free, stat = input->dma->stat;
 678         int ret;
 679
 680         idx = (stat >> 11) & 0x1f;
 681
 682         while (left) {
 683                 if (input->dma->cbuf == idx)
 684                         return count - left;
 685                 free = input->dma->size - input->dma->coff;
 686                 if (free > left)
 687                         free = left;
 688                 if (alt_dma)
 689                         dma_sync_single_for_cpu(
 690                                 dev->dev,
 691                                 input->dma->pbuf[input->dma->cbuf],
 692                                 input->dma->size, DMA_FROM_DEVICE);
 693                 ret = copy_to_user(buf, input->dma->vbuf[input->dma->cbuf] +
 694                                    input->dma->coff, free);
 695                 if (ret)
 696                         return -EFAULT;
 697                 input->dma->coff += free;
 698                 if (input->dma->coff == input->dma->size) {
 699                         input->dma->coff = 0;
 700                         input->dma->cbuf = (input->dma->cbuf + 1) %
 701                                 input->dma->num;
 702                 }
 703                 left -= free;
 704                 buf += free;
 705                 ddbwritel(dev,
 706                           (input->dma->cbuf << 11) | (input->dma->coff >> 7),
 707                           DMA_BUFFER_ACK(input->dma));
 708         }
 709         return count;
 710 }
 711
 712 /****************************************************************************/
 713 /****************************************************************************/
 714
 715 static ssize_t ts_write(struct file *file, const __user char *buf,
 716                         size_t count, loff_t *ppos)
 717 {
 718         struct dvb_device *dvbdev = file->private_data;
 719         struct ddb_output *output = dvbdev->priv;
 720         struct ddb *dev = output->port->dev;
 721         size_t left = count;
 722         int stat;
 723
 724         if (!dev->has_dma)
 725                 return -EINVAL;
 726         while (left) {
 727                 if (ddb_output_free(output) < 188) {
 728                         if (file->f_flags & O_NONBLOCK)
 729                                 break;
 730                         if (wait_event_interruptible(
 731                                     output->dma->wq,
 732                                     ddb_output_free(output) >= 188) < 0)
 733                                 break;
 734                 }
 735                 stat = ddb_output_write(output, buf, left);
 736                 if (stat < 0)
 737                         return stat;
 738                 buf += stat;
 739                 left -= stat;
 740         }
 741         return (left == count) ? -EAGAIN : (count - left);
 742 }
 743
 744 static ssize_t ts_read(struct file *file, __user char *buf,
 745                        size_t count, loff_t *ppos)
 746 {
 747         struct dvb_device *dvbdev = file->private_data;
 748         struct ddb_output *output = dvbdev->priv;
 749         struct ddb_input *input = output->port->input[0];
 750         struct ddb *dev = output->port->dev;
 751         size_t left = count;
 752         int stat;
 753
 754         if (!dev->has_dma)
 755                 return -EINVAL;
 756         while (left) {
 757                 if (ddb_input_avail(input) < 188) {
 758                         if (file->f_flags & O_NONBLOCK)
 759                                 break;
 760                         if (wait_event_interruptible(
 761                                     input->dma->wq,
 762                                     ddb_input_avail(input) >= 188) < 0)
 763                                 break;
 764                 }
 765                 stat = ddb_input_read(input, buf, left);
 766                 if (stat < 0)
 767                         return stat;
 768                 left -= stat;
 769                 buf += stat;
 770         }
 771         return (count && (left == count)) ? -EAGAIN : (count - left);
 772 }
 773
 774 static __poll_t ts_poll(struct file *file, poll_table *wait)
 775 {
 776         struct dvb_device *dvbdev = file->private_data;
 777         struct ddb_output *output = dvbdev->priv;
 778         struct ddb_input *input = output->port->input[0];
 779
 780         __poll_t mask = 0;
 781
 782         poll_wait(file, &input->dma->wq, wait);
 783         poll_wait(file, &output->dma->wq, wait);
 784         if (ddb_input_avail(input) >= 188)
 785                 mask |= EPOLLIN | EPOLLRDNORM;
 786         if (ddb_output_free(output) >= 188)
 787                 mask |= EPOLLOUT | EPOLLWRNORM;
 788         return mask;
 789 }
 790
 791 static int ts_release(struct inode *inode, struct file *file)
 792 {
 793         struct dvb_device *dvbdev = file->private_data;
 794         struct ddb_output *output = NULL;
 795         struct ddb_input *input = NULL;
 796
 797         if (dvbdev) {
 798                 output = dvbdev->priv;
 799                 input = output->port->input[0];
 800         }
 801
 802         if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
 803                 if (!input)
 804                         return -EINVAL;
 805                 ddb_input_stop(input);
 806         } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
 807                 if (!output)
 808                         return -EINVAL;
 809                 ddb_output_stop(output);
 810         }
 811         return dvb_generic_release(inode, file);
 812 }
 813
 814 static int ts_open(struct inode *inode, struct file *file)
 815 {
 816         int err;
 817         struct dvb_device *dvbdev = file->private_data;
 818         struct ddb_output *output = NULL;
 819         struct ddb_input *input = NULL;
 820
 821         if (dvbdev) {
 822                 output = dvbdev->priv;
 823                 input = output->port->input[0];
 824         }
 825
 826         if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
 827                 if (!input)
 828                         return -EINVAL;
 829                 if (input->redo || input->redi)
 830                         return -EBUSY;
 831         } else if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
 832                 if (!output)
 833                         return -EINVAL;
 834         } else {
 835                 return -EINVAL;
 836         }
 837
 838         err = dvb_generic_open(inode, file);
 839         if (err < 0)
 840                 return err;
 841         if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 842                 ddb_input_start(input);
 843         else if ((file->f_flags & O_ACCMODE) == O_WRONLY)
 844                 ddb_output_start(output);
 845         return err;
 846 }
 847
 848 static const struct file_operations ci_fops = {
 849         .owner   = THIS_MODULE,
 850         .read    = ts_read,
 851         .write   = ts_write,
 852         .open    = ts_open,
 853         .release = ts_release,
 854         .poll    = ts_poll,
 855         .mmap    = NULL,
 856 };
 857
 858 static struct dvb_device dvbdev_ci = {
 859         .priv    = NULL,
 860         .readers = 1,
 861         .writers = 1,
 862         .users   = 2,
 863         .fops    = &ci_fops,
 864 };
 865
 866 /****************************************************************************/
 867 /****************************************************************************/
 868
 869 static int locked_gate_ctrl(struct dvb_frontend *fe, int enable)
 870 {
 871         struct ddb_input *input = fe->sec_priv;
 872         struct ddb_port *port = input->port;
 873         struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
 874         int status;
 875
 876         if (enable) {
 877                 mutex_lock(&port->i2c_gate_lock);
 878                 status = dvb->i2c_gate_ctrl(fe, 1);
 879         } else {
 880                 status = dvb->i2c_gate_ctrl(fe, 0);
 881                 mutex_unlock(&port->i2c_gate_lock);
 882         }
 883         return status;
 884 }
 885
 886 static int demod_attach_drxk(struct ddb_input *input)
 887 {
 888         struct i2c_adapter *i2c = &input->port->i2c->adap;
 889         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 890         struct device *dev = input->port->dev->dev;
 891         struct drxk_config config;
 892
 893         memset(&config, 0, sizeof(config));
 894         config.adr = 0x29 + (input->nr & 1);
 895         config.microcode_name = "drxk_a3.mc";
 896
 897         dvb->fe = dvb_attach(drxk_attach, &config, i2c);
 898         if (!dvb->fe) {
 899                 dev_err(dev, "No DRXK found!\n");
 900                 return -ENODEV;
 901         }
 902         dvb->fe->sec_priv = input;
 903         dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
 904         dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
 905         return 0;
 906 }
 907
 908 static int tuner_attach_tda18271(struct ddb_input *input)
 909 {
 910         struct i2c_adapter *i2c = &input->port->i2c->adap;
 911         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 912         struct device *dev = input->port->dev->dev;
 913         struct dvb_frontend *fe;
 914
 915         if (dvb->fe->ops.i2c_gate_ctrl)
 916                 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
 917         fe = dvb_attach(tda18271c2dd_attach, dvb->fe, i2c, 0x60);
 918         if (dvb->fe->ops.i2c_gate_ctrl)
 919                 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
 920         if (!fe) {
 921                 dev_err(dev, "No TDA18271 found!\n");
 922                 return -ENODEV;
 923         }
 924         return 0;
 925 }
 926
 927 /******************************************************************************/
 928 /******************************************************************************/
 929 /******************************************************************************/
 930
 931 static struct stv0367_config ddb_stv0367_config[] = {
 932         {
 933                 .demod_address = 0x1f,
 934                 .xtal = 27000000,
 935                 .if_khz = 0,
 936                 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
 937                 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
 938                 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
 939         }, {
 940                 .demod_address = 0x1e,
 941                 .xtal = 27000000,
 942                 .if_khz = 0,
 943                 .if_iq_mode = FE_TER_NORMAL_IF_TUNER,
 944                 .ts_mode = STV0367_SERIAL_PUNCT_CLOCK,
 945                 .clk_pol = STV0367_CLOCKPOLARITY_DEFAULT,
 946         },
 947 };
 948
 949 static int demod_attach_stv0367(struct ddb_input *input)
 950 {
 951         struct i2c_adapter *i2c = &input->port->i2c->adap;
 952         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 953         struct device *dev = input->port->dev->dev;
 954
 955         /* attach frontend */
 956         dvb->fe = dvb_attach(stv0367ddb_attach,
 957                              &ddb_stv0367_config[(input->nr & 1)], i2c);
 958
 959         if (!dvb->fe) {
 960                 dev_err(dev, "No stv0367 found!\n");
 961                 return -ENODEV;
 962         }
 963         dvb->fe->sec_priv = input;
 964         dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
 965         dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
 966         return 0;
 967 }
 968
 969 static int tuner_tda18212_ping(struct ddb_input *input, unsigned short adr)
 970 {
 971         struct i2c_adapter *adapter = &input->port->i2c->adap;
 972         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 973         struct device *dev = input->port->dev->dev;
 974         u8 tda_id[2];
 975         u8 subaddr = 0x00;
 976
 977         dev_dbg(dev, "stv0367-tda18212 tuner ping\n");
 978         if (dvb->fe->ops.i2c_gate_ctrl)
 979                 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 1);
 980
 981         if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
 982                 dev_dbg(dev, "tda18212 ping 1 fail\n");
 983         if (i2c_read_regs(adapter, adr, subaddr, tda_id, sizeof(tda_id)) < 0)
 984                 dev_warn(dev, "tda18212 ping failed, expect problems\n");
 985
 986         if (dvb->fe->ops.i2c_gate_ctrl)
 987                 dvb->fe->ops.i2c_gate_ctrl(dvb->fe, 0);
 988
 989         return 0;
 990 }
 991
 992 static int demod_attach_cxd28xx(struct ddb_input *input, int par, int osc24)
 993 {
 994         struct i2c_adapter *i2c = &input->port->i2c->adap;
 995         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 996         struct device *dev = input->port->dev->dev;
 997         struct cxd2841er_config cfg;
 998
 999         /* the cxd2841er driver expects 8bit/shifted I2C addresses */
1000         cfg.i2c_addr = ((input->nr & 1) ? 0x6d : 0x6c) << 1;
1001
1002         cfg.xtal = osc24 ? SONY_XTAL_24000 : SONY_XTAL_20500;
1003         cfg.flags = CXD2841ER_AUTO_IFHZ | CXD2841ER_EARLY_TUNE |
1004                 CXD2841ER_NO_WAIT_LOCK | CXD2841ER_NO_AGCNEG |
1005                 CXD2841ER_TSBITS;
1006
1007         if (!par)
1008                 cfg.flags |= CXD2841ER_TS_SERIAL;
1009
1010         /* attach frontend */
1011         dvb->fe = dvb_attach(cxd2841er_attach_t_c, &cfg, i2c);
1012
1013         if (!dvb->fe) {
1014                 dev_err(dev, "No cxd2837/38/43/54 found!\n");
1015                 return -ENODEV;
1016         }
1017         dvb->fe->sec_priv = input;
1018         dvb->i2c_gate_ctrl = dvb->fe->ops.i2c_gate_ctrl;
1019         dvb->fe->ops.i2c_gate_ctrl = locked_gate_ctrl;
1020         return 0;
1021 }
1022
1023 static int tuner_attach_tda18212(struct ddb_input *input, u32 porttype)
1024 {
1025         struct i2c_adapter *adapter = &input->port->i2c->adap;
1026         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1027         struct device *dev = input->port->dev->dev;
1028         struct i2c_client *client;
1029         struct tda18212_config config = {
1030                 .fe = dvb->fe,
1031                 .if_dvbt_6 = 3550,
1032                 .if_dvbt_7 = 3700,
1033                 .if_dvbt_8 = 4150,
1034                 .if_dvbt2_6 = 3250,
1035                 .if_dvbt2_7 = 4000,
1036                 .if_dvbt2_8 = 4000,
1037                 .if_dvbc = 5000,
1038         };
1039         u8 addr = (input->nr & 1) ? 0x63 : 0x60;
1040
1041         /* due to a hardware quirk with the I2C gate on the stv0367+tda18212
1042          * combo, the tda18212 must be probed by reading it's id _twice_ when
1043          * cold started, or it very likely will fail.
1044          */
1045         if (porttype == DDB_TUNER_DVBCT_ST)
1046                 tuner_tda18212_ping(input, addr);
1047
1048         /* perform tuner probe/init/attach */
1049         client = dvb_module_probe("tda18212", NULL, adapter, addr, &config);
1050         if (!client)
1051                 goto err;
1052
1053         dvb->i2c_client[0] = client;
1054         return 0;
1055 err:
1056         dev_err(dev, "TDA18212 tuner not found. Device is not fully operational.\n");
1057         return -ENODEV;
1058 }
1059
1060 /****************************************************************************/
1061 /****************************************************************************/
1062 /****************************************************************************/
1063
1064 static struct stv090x_config stv0900 = {
1065         .device         = STV0900,
1066         .demod_mode     = STV090x_DUAL,
1067         .clk_mode       = STV090x_CLK_EXT,
1068
1069         .xtal           = 27000000,
1070         .address        = 0x69,
1071
1072         .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1073         .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1074
1075         .ts1_tei        = 1,
1076         .ts2_tei        = 1,
1077
1078         .repeater_level = STV090x_RPTLEVEL_16,
1079
1080         .adc1_range     = STV090x_ADC_1Vpp,
1081         .adc2_range     = STV090x_ADC_1Vpp,
1082
1083         .diseqc_envelope_mode = true,
1084 };
1085
1086 static struct stv090x_config stv0900_aa = {
1087         .device         = STV0900,
1088         .demod_mode     = STV090x_DUAL,
1089         .clk_mode       = STV090x_CLK_EXT,
1090
1091         .xtal           = 27000000,
1092         .address        = 0x68,
1093
1094         .ts1_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1095         .ts2_mode       = STV090x_TSMODE_SERIAL_PUNCTURED,
1096
1097         .ts1_tei        = 1,
1098         .ts2_tei        = 1,
1099
1100         .repeater_level = STV090x_RPTLEVEL_16,
1101
1102         .adc1_range     = STV090x_ADC_1Vpp,
1103         .adc2_range     = STV090x_ADC_1Vpp,
1104
1105         .diseqc_envelope_mode = true,
1106 };
1107
1108 static struct stv6110x_config stv6110a = {
1109         .addr    = 0x60,
1110         .refclk  = 27000000,
1111         .clk_div = 1,
1112 };
1113
1114 static struct stv6110x_config stv6110b = {
1115         .addr    = 0x63,
1116         .refclk  = 27000000,
1117         .clk_div = 1,
1118 };
1119
1120 static int demod_attach_stv0900(struct ddb_input *input, int type)
1121 {
1122         struct i2c_adapter *i2c = &input->port->i2c->adap;
1123         struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1124         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1125         struct device *dev = input->port->dev->dev;
1126
1127         dvb->fe = dvb_attach(stv090x_attach, feconf, i2c,
1128                              (input->nr & 1) ? STV090x_DEMODULATOR_1
1129                              : STV090x_DEMODULATOR_0);
1130         if (!dvb->fe) {
1131                 dev_err(dev, "No STV0900 found!\n");
1132                 return -ENODEV;
1133         }
1134         if (!dvb_attach(lnbh24_attach, dvb->fe, i2c, 0,
1135                         0, (input->nr & 1) ?
1136                         (0x09 - type) : (0x0b - type))) {
1137                 dev_err(dev, "No LNBH24 found!\n");
1138                 dvb_frontend_detach(dvb->fe);
1139                 return -ENODEV;
1140         }
1141         return 0;
1142 }
1143
1144 static int tuner_attach_stv6110(struct ddb_input *input, int type)
1145 {
1146         struct i2c_adapter *i2c = &input->port->i2c->adap;
1147         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1148         struct device *dev = input->port->dev->dev;
1149         struct stv090x_config *feconf = type ? &stv0900_aa : &stv0900;
1150         struct stv6110x_config *tunerconf = (input->nr & 1) ?
1151                 &stv6110b : &stv6110a;
1152         const struct stv6110x_devctl *ctl;
1153
1154         ctl = dvb_attach(stv6110x_attach, dvb->fe, tunerconf, i2c);
1155         if (!ctl) {
1156                 dev_err(dev, "No STV6110X found!\n");
1157                 return -ENODEV;
1158         }
1159         dev_info(dev, "attach tuner input %d adr %02x\n",
1160                  input->nr, tunerconf->addr);
1161
1162         feconf->tuner_init          = ctl->tuner_init;
1163         feconf->tuner_sleep         = ctl->tuner_sleep;
1164         feconf->tuner_set_mode      = ctl->tuner_set_mode;
1165         feconf->tuner_set_frequency = ctl->tuner_set_frequency;
1166         feconf->tuner_get_frequency = ctl->tuner_get_frequency;
1167         feconf->tuner_set_bandwidth = ctl->tuner_set_bandwidth;
1168         feconf->tuner_get_bandwidth = ctl->tuner_get_bandwidth;
1169         feconf->tuner_set_bbgain    = ctl->tuner_set_bbgain;
1170         feconf->tuner_get_bbgain    = ctl->tuner_get_bbgain;
1171         feconf->tuner_set_refclk    = ctl->tuner_set_refclk;
1172         feconf->tuner_get_status    = ctl->tuner_get_status;
1173
1174         return 0;
1175 }
1176
1177 static const struct stv0910_cfg stv0910_p = {
1178         .adr      = 0x68,
1179         .parallel = 1,
1180         .rptlvl   = 4,
1181         .clk      = 30000000,
1182         .tsspeed  = 0x28,
1183 };
1184
1185 static const struct lnbh25_config lnbh25_cfg = {
1186         .i2c_address = 0x0c << 1,
1187         .data2_config = LNBH25_TEN
1188 };
1189
1190 static int has_lnbh25(struct i2c_adapter *i2c, u8 adr)
1191 {
1192         u8 val;
1193
1194         return i2c_read_reg(i2c, adr, 0, &val) ? 0 : 1;
1195 }
1196
1197 static int demod_attach_stv0910(struct ddb_input *input, int type, int tsfast)
1198 {
1199         struct i2c_adapter *i2c = &input->port->i2c->adap;
1200         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1201         struct device *dev = input->port->dev->dev;
1202         struct stv0910_cfg cfg = stv0910_p;
1203         struct lnbh25_config lnbcfg = lnbh25_cfg;
1204
1205         if (stv0910_single)
1206                 cfg.single = 1;
1207
1208         if (type)
1209                 cfg.parallel = 2;
1210
1211         if (tsfast) {
1212                 dev_info(dev, "Enabling stv0910 higher speed TS\n");
1213                 cfg.tsspeed = 0x10;
1214         }
1215
1216         dvb->fe = dvb_attach(stv0910_attach, i2c, &cfg, (input->nr & 1));
1217         if (!dvb->fe) {
1218                 cfg.adr = 0x6c;
1219                 dvb->fe = dvb_attach(stv0910_attach, i2c,
1220                                      &cfg, (input->nr & 1));
1221         }
1222         if (!dvb->fe) {
1223                 dev_err(dev, "No STV0910 found!\n");
1224                 return -ENODEV;
1225         }
1226
1227         /* attach lnbh25 - leftshift by one as the lnbh25 driver expects 8bit
1228          * i2c addresses
1229          */
1230         if (has_lnbh25(i2c, 0x0d))
1231                 lnbcfg.i2c_address = (((input->nr & 1) ? 0x0d : 0x0c) << 1);
1232         else
1233                 lnbcfg.i2c_address = (((input->nr & 1) ? 0x09 : 0x08) << 1);
1234
1235         if (!dvb_attach(lnbh25_attach, dvb->fe, &lnbcfg, i2c)) {
1236                 dev_err(dev, "No LNBH25 found!\n");
1237                 dvb_frontend_detach(dvb->fe);
1238                 return -ENODEV;
1239         }
1240
1241         return 0;
1242 }
1243
1244 static int tuner_attach_stv6111(struct ddb_input *input, int type)
1245 {
1246         struct i2c_adapter *i2c = &input->port->i2c->adap;
1247         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1248         struct device *dev = input->port->dev->dev;
1249         struct dvb_frontend *fe;
1250         u8 adr = (type ? 0 : 4) + ((input->nr & 1) ? 0x63 : 0x60);
1251
1252         fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr);
1253         if (!fe) {
1254                 fe = dvb_attach(stv6111_attach, dvb->fe, i2c, adr & ~4);
1255                 if (!fe) {
1256                         dev_err(dev, "No STV6111 found at 0x%02x!\n", adr);
1257                         return -ENODEV;
1258                 }
1259         }
1260         return 0;
1261 }
1262
1263 static int demod_attach_dummy(struct ddb_input *input)
1264 {
1265         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1266         struct device *dev = input->port->dev->dev;
1267
1268         dvb->fe = dvb_attach(dvb_dummy_fe_qam_attach);
1269         if (!dvb->fe) {
1270                 dev_err(dev, "QAM dummy attach failed!\n");
1271                 return -ENODEV;
1272         }
1273
1274         return 0;
1275 }
1276
1277 static int start_feed(struct dvb_demux_feed *dvbdmxfeed)
1278 {
1279         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1280         struct ddb_input *input = dvbdmx->priv;
1281         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1282
1283         if (!dvb->users)
1284                 ddb_input_start_all(input);
1285
1286         return ++dvb->users;
1287 }
1288
1289 static int stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1290 {
1291         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1292         struct ddb_input *input = dvbdmx->priv;
1293         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1294
1295         if (--dvb->users)
1296                 return dvb->users;
1297
1298         ddb_input_stop_all(input);
1299         return 0;
1300 }
1301
1302 static void dvb_input_detach(struct ddb_input *input)
1303 {
1304         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1305         struct dvb_demux *dvbdemux = &dvb->demux;
1306
1307         switch (dvb->attached) {
1308         case 0x31:
1309                 if (dvb->fe2)
1310                         dvb_unregister_frontend(dvb->fe2);
1311                 if (dvb->fe)
1312                         dvb_unregister_frontend(dvb->fe);
1313                 /* fallthrough */
1314         case 0x30:
1315                 dvb_module_release(dvb->i2c_client[0]);
1316                 dvb->i2c_client[0] = NULL;
1317
1318                 if (dvb->fe2)
1319                         dvb_frontend_detach(dvb->fe2);
1320                 if (dvb->fe)
1321                         dvb_frontend_detach(dvb->fe);
1322                 dvb->fe = NULL;
1323                 dvb->fe2 = NULL;
1324                 /* fallthrough */
1325         case 0x20:
1326                 dvb_net_release(&dvb->dvbnet);
1327                 /* fallthrough */
1328         case 0x12:
1329                 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1330                                               &dvb->hw_frontend);
1331                 dvbdemux->dmx.remove_frontend(&dvbdemux->dmx,
1332                                               &dvb->mem_frontend);
1333                 /* fallthrough */
1334         case 0x11:
1335                 dvb_dmxdev_release(&dvb->dmxdev);
1336                 /* fallthrough */
1337         case 0x10:
1338                 dvb_dmx_release(&dvb->demux);
1339                 /* fallthrough */
1340         case 0x01:
1341                 break;
1342         }
1343         dvb->attached = 0x00;
1344 }
1345
1346 static int dvb_register_adapters(struct ddb *dev)
1347 {
1348         int i, ret = 0;
1349         struct ddb_port *port;
1350         struct dvb_adapter *adap;
1351
1352         if (adapter_alloc == 3) {
1353                 port = &dev->port[0];
1354                 adap = port->dvb[0].adap;
1355                 ret = dvb_register_adapter(adap, "DDBridge", THIS_MODULE,
1356                                            port->dev->dev,
1357                                            adapter_nr);
1358                 if (ret < 0)
1359                         return ret;
1360                 port->dvb[0].adap_registered = 1;
1361                 for (i = 0; i < dev->port_num; i++) {
1362                         port = &dev->port[i];
1363                         port->dvb[0].adap = adap;
1364                         port->dvb[1].adap = adap;
1365                 }
1366                 return 0;
1367         }
1368
1369         for (i = 0; i < dev->port_num; i++) {
1370                 port = &dev->port[i];
1371                 switch (port->class) {
1372                 case DDB_PORT_TUNER:
1373                         adap = port->dvb[0].adap;
1374                         ret = dvb_register_adapter(adap, "DDBridge",
1375                                                    THIS_MODULE,
1376                                                    port->dev->dev,
1377                                                    adapter_nr);
1378                         if (ret < 0)
1379                                 return ret;
1380                         port->dvb[0].adap_registered = 1;
1381
1382                         if (adapter_alloc > 0) {
1383                                 port->dvb[1].adap = port->dvb[0].adap;
1384                                 break;
1385                         }
1386                         adap = port->dvb[1].adap;
1387                         ret = dvb_register_adapter(adap, "DDBridge",
1388                                                    THIS_MODULE,
1389                                                    port->dev->dev,
1390                                                    adapter_nr);
1391                         if (ret < 0)
1392                                 return ret;
1393                         port->dvb[1].adap_registered = 1;
1394                         break;
1395
1396                 case DDB_PORT_CI:
1397                 case DDB_PORT_LOOP:
1398                         adap = port->dvb[0].adap;
1399                         ret = dvb_register_adapter(adap, "DDBridge",
1400                                                    THIS_MODULE,
1401                                                    port->dev->dev,
1402                                                    adapter_nr);
1403                         if (ret < 0)
1404                                 return ret;
1405                         port->dvb[0].adap_registered = 1;
1406                         break;
1407                 default:
1408                         if (adapter_alloc < 2)
1409                                 break;
1410                         adap = port->dvb[0].adap;
1411                         ret = dvb_register_adapter(adap, "DDBridge",
1412                                                    THIS_MODULE,
1413                                                    port->dev->dev,
1414                                                    adapter_nr);
1415                         if (ret < 0)
1416                                 return ret;
1417                         port->dvb[0].adap_registered = 1;
1418                         break;
1419                 }
1420         }
1421         return ret;
1422 }
1423
1424 static void dvb_unregister_adapters(struct ddb *dev)
1425 {
1426         int i;
1427         struct ddb_port *port;
1428         struct ddb_dvb *dvb;
1429
1430         for (i = 0; i < dev->link[0].info->port_num; i++) {
1431                 port = &dev->port[i];
1432
1433                 dvb = &port->dvb[0];
1434                 if (dvb->adap_registered)
1435                         dvb_unregister_adapter(dvb->adap);
1436                 dvb->adap_registered = 0;
1437
1438                 dvb = &port->dvb[1];
1439                 if (dvb->adap_registered)
1440                         dvb_unregister_adapter(dvb->adap);
1441                 dvb->adap_registered = 0;
1442         }
1443 }
1444
1445 static int dvb_input_attach(struct ddb_input *input)
1446 {
1447         int ret = 0;
1448         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
1449         struct ddb_port *port = input->port;
1450         struct dvb_adapter *adap = dvb->adap;
1451         struct dvb_demux *dvbdemux = &dvb->demux;
1452         struct ddb_ids *devids = &input->port->dev->link[input->port->lnr].ids;
1453         int par = 0, osc24 = 0, tsfast = 0;
1454
1455         /*
1456          * Determine if bridges with stv0910 demods can run with fast TS and
1457          * thus support high bandwidth transponders.
1458          * STV0910_PR and STV0910_P tuner types covers all relevant bridges,
1459          * namely the CineS2 V7(A) and the Octopus CI S2 Pro/Advanced. All
1460          * DuoFlex S2 V4(A) have type=DDB_TUNER_DVBS_STV0910 without any suffix
1461          * and are limited by the serial link to the bridge, thus won't work
1462          * in fast TS mode.
1463          */
1464         if (port->nr == 0 &&
1465             (port->type == DDB_TUNER_DVBS_STV0910_PR ||
1466              port->type == DDB_TUNER_DVBS_STV0910_P)) {
1467                 /* fast TS on port 0 requires FPGA version >= 1.7 */
1468                 if ((devids->hwid & 0x00ffffff) >= 0x00010007)
1469                         tsfast = 1;
1470         }
1471
1472         dvb->attached = 0x01;
1473
1474         dvbdemux->priv = input;
1475         dvbdemux->dmx.capabilities = DMX_TS_FILTERING |
1476                 DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
1477         dvbdemux->start_feed = start_feed;
1478         dvbdemux->stop_feed = stop_feed;
1479         dvbdemux->filternum = 256;
1480         dvbdemux->feednum = 256;
1481         ret = dvb_dmx_init(dvbdemux);
1482         if (ret < 0)
1483                 return ret;
1484         dvb->attached = 0x10;
1485
1486         dvb->dmxdev.filternum = 256;
1487         dvb->dmxdev.demux = &dvbdemux->dmx;
1488         ret = dvb_dmxdev_init(&dvb->dmxdev, adap);
1489         if (ret < 0)
1490                 goto err_detach;
1491         dvb->attached = 0x11;
1492
1493         dvb->mem_frontend.source = DMX_MEMORY_FE;
1494         dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->mem_frontend);
1495         dvb->hw_frontend.source = DMX_FRONTEND_0;
1496         dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->hw_frontend);
1497         ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, &dvb->hw_frontend);
1498         if (ret < 0)
1499                 goto err_detach;
1500         dvb->attached = 0x12;
1501
1502         ret = dvb_net_init(adap, &dvb->dvbnet, dvb->dmxdev.demux);
1503         if (ret < 0)
1504                 goto err_detach;
1505         dvb->attached = 0x20;
1506
1507         dvb->fe = NULL;
1508         dvb->fe2 = NULL;
1509         switch (port->type) {
1510         case DDB_TUNER_MXL5XX:
1511                 if (ddb_fe_attach_mxl5xx(input) < 0)
1512                         goto err_detach;
1513                 break;
1514         case DDB_TUNER_DVBS_ST:
1515                 if (demod_attach_stv0900(input, 0) < 0)
1516                         goto err_detach;
1517                 if (tuner_attach_stv6110(input, 0) < 0)
1518                         goto err_tuner;
1519                 break;
1520         case DDB_TUNER_DVBS_ST_AA:
1521                 if (demod_attach_stv0900(input, 1) < 0)
1522                         goto err_detach;
1523                 if (tuner_attach_stv6110(input, 1) < 0)
1524                         goto err_tuner;
1525                 break;
1526         case DDB_TUNER_DVBS_STV0910:
1527                 if (demod_attach_stv0910(input, 0, tsfast) < 0)
1528                         goto err_detach;
1529                 if (tuner_attach_stv6111(input, 0) < 0)
1530                         goto err_tuner;
1531                 break;
1532         case DDB_TUNER_DVBS_STV0910_PR:
1533                 if (demod_attach_stv0910(input, 1, tsfast) < 0)
1534                         goto err_detach;
1535                 if (tuner_attach_stv6111(input, 1) < 0)
1536                         goto err_tuner;
1537                 break;
1538         case DDB_TUNER_DVBS_STV0910_P:
1539                 if (demod_attach_stv0910(input, 0, tsfast) < 0)
1540                         goto err_detach;
1541                 if (tuner_attach_stv6111(input, 1) < 0)
1542                         goto err_tuner;
1543                 break;
1544         case DDB_TUNER_DVBCT_TR:
1545                 if (demod_attach_drxk(input) < 0)
1546                         goto err_detach;
1547                 if (tuner_attach_tda18271(input) < 0)
1548                         goto err_tuner;
1549                 break;
1550         case DDB_TUNER_DVBCT_ST:
1551                 if (demod_attach_stv0367(input) < 0)
1552                         goto err_detach;
1553                 if (tuner_attach_tda18212(input, port->type) < 0)
1554                         goto err_tuner;
1555                 break;
1556         case DDB_TUNER_DVBC2T2I_SONY_P:
1557                 if (input->port->dev->link[input->port->lnr].info->ts_quirks &
1558                     TS_QUIRK_ALT_OSC)
1559                         osc24 = 0;
1560                 else
1561                         osc24 = 1;
1562                 /* fall-through */
1563         case DDB_TUNER_DVBCT2_SONY_P:
1564         case DDB_TUNER_DVBC2T2_SONY_P:
1565         case DDB_TUNER_ISDBT_SONY_P:
1566                 if (input->port->dev->link[input->port->lnr].info->ts_quirks
1567                         & TS_QUIRK_SERIAL)
1568                         par = 0;
1569                 else
1570                         par = 1;
1571                 if (demod_attach_cxd28xx(input, par, osc24) < 0)
1572                         goto err_detach;
1573                 if (tuner_attach_tda18212(input, port->type) < 0)
1574                         goto err_tuner;
1575                 break;
1576         case DDB_TUNER_DVBC2T2I_SONY:
1577                 osc24 = 1;
1578                 /* fall-through */
1579         case DDB_TUNER_DVBCT2_SONY:
1580         case DDB_TUNER_DVBC2T2_SONY:
1581         case DDB_TUNER_ISDBT_SONY:
1582                 if (demod_attach_cxd28xx(input, 0, osc24) < 0)
1583                         goto err_detach;
1584                 if (tuner_attach_tda18212(input, port->type) < 0)
1585                         goto err_tuner;
1586                 break;
1587         case DDB_TUNER_DUMMY:
1588                 if (demod_attach_dummy(input) < 0)
1589                         goto err_detach;
1590                 break;
1591         case DDB_TUNER_MCI_SX8:
1592                 if (ddb_fe_attach_mci(input, port->type) < 0)
1593                         goto err_detach;
1594                 break;
1595         default:
1596                 return 0;
1597         }
1598         dvb->attached = 0x30;
1599
1600         if (dvb->fe) {
1601                 if (dvb_register_frontend(adap, dvb->fe) < 0)
1602                         goto err_detach;
1603
1604                 if (dvb->fe2) {
1605                         if (dvb_register_frontend(adap, dvb->fe2) < 0) {
1606                                 dvb_unregister_frontend(dvb->fe);
1607                                 goto err_detach;
1608                         }
1609                         dvb->fe2->tuner_priv = dvb->fe->tuner_priv;
1610                         memcpy(&dvb->fe2->ops.tuner_ops,
1611                                &dvb->fe->ops.tuner_ops,
1612                                sizeof(struct dvb_tuner_ops));
1613                 }
1614         }
1615
1616         dvb->attached = 0x31;
1617         return 0;
1618
1619 err_tuner:
1620         dev_err(port->dev->dev, "tuner attach failed!\n");
1621
1622         if (dvb->fe2)
1623                 dvb_frontend_detach(dvb->fe2);
1624         if (dvb->fe)
1625                 dvb_frontend_detach(dvb->fe);
1626 err_detach:
1627         dvb_input_detach(input);
1628
1629         /* return error from ret if set */
1630         if (ret < 0)
1631                 return ret;
1632
1633         return -ENODEV;
1634 }
1635
1636 static int port_has_encti(struct ddb_port *port)
1637 {
1638         struct device *dev = port->dev->dev;
1639         u8 val;
1640         int ret = i2c_read_reg(&port->i2c->adap, 0x20, 0, &val);
1641
1642         if (!ret)
1643                 dev_info(dev, "[0x20]=0x%02x\n", val);
1644         return ret ? 0 : 1;
1645 }
1646
1647 static int port_has_cxd(struct ddb_port *port, u8 *type)
1648 {
1649         u8 val;
1650         u8 probe[4] = { 0xe0, 0x00, 0x00, 0x00 }, data[4];
1651         struct i2c_msg msgs[2] = {{ .addr = 0x40,  .flags = 0,
1652                                     .buf  = probe, .len   = 4 },
1653                                   { .addr = 0x40,  .flags = I2C_M_RD,
1654                                     .buf  = data,  .len   = 4 } };
1655         val = i2c_transfer(&port->i2c->adap, msgs, 2);
1656         if (val != 2)
1657                 return 0;
1658
1659         if (data[0] == 0x02 && data[1] == 0x2b && data[3] == 0x43)
1660                 *type = 2;
1661         else
1662                 *type = 1;
1663         return 1;
1664 }
1665
1666 static int port_has_xo2(struct ddb_port *port, u8 *type, u8 *id)
1667 {
1668         u8 probe[1] = { 0x00 }, data[4];
1669
1670         if (i2c_io(&port->i2c->adap, 0x10, probe, 1, data, 4))
1671                 return 0;
1672         if (data[0] == 'D' && data[1] == 'F') {
1673                 *id = data[2];
1674                 *type = 1;
1675                 return 1;
1676         }
1677         if (data[0] == 'C' && data[1] == 'I') {
1678                 *id = data[2];
1679                 *type = 2;
1680                 return 1;
1681         }
1682         return 0;
1683 }
1684
1685 static int port_has_stv0900(struct ddb_port *port)
1686 {
1687         u8 val;
1688
1689         if (i2c_read_reg16(&port->i2c->adap, 0x69, 0xf100, &val) < 0)
1690                 return 0;
1691         return 1;
1692 }
1693
1694 static int port_has_stv0900_aa(struct ddb_port *port, u8 *id)
1695 {
1696         if (i2c_read_reg16(&port->i2c->adap, 0x68, 0xf100, id) < 0)
1697                 return 0;
1698         return 1;
1699 }
1700
1701 static int port_has_drxks(struct ddb_port *port)
1702 {
1703         u8 val;
1704
1705         if (i2c_read(&port->i2c->adap, 0x29, &val) < 0)
1706                 return 0;
1707         if (i2c_read(&port->i2c->adap, 0x2a, &val) < 0)
1708                 return 0;
1709         return 1;
1710 }
1711
1712 static int port_has_stv0367(struct ddb_port *port)
1713 {
1714         u8 val;
1715
1716         if (i2c_read_reg16(&port->i2c->adap, 0x1e, 0xf000, &val) < 0)
1717                 return 0;
1718         if (val != 0x60)
1719                 return 0;
1720         if (i2c_read_reg16(&port->i2c->adap, 0x1f, 0xf000, &val) < 0)
1721                 return 0;
1722         if (val != 0x60)
1723                 return 0;
1724         return 1;
1725 }
1726
1727 static int init_xo2(struct ddb_port *port)
1728 {
1729         struct i2c_adapter *i2c = &port->i2c->adap;
1730         struct ddb *dev = port->dev;
1731         u8 val, data[2];
1732         int res;
1733
1734         res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1735         if (res < 0)
1736                 return res;
1737
1738         if (data[0] != 0x01)  {
1739                 dev_info(dev->dev, "Port %d: invalid XO2\n", port->nr);
1740                 return -1;
1741         }
1742
1743         i2c_read_reg(i2c, 0x10, 0x08, &val);
1744         if (val != 0) {
1745                 i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1746                 msleep(100);
1747         }
1748         /* Enable tuner power, disable pll, reset demods */
1749         i2c_write_reg(i2c, 0x10, 0x08, 0x04);
1750         usleep_range(2000, 3000);
1751         /* Release demod resets */
1752         i2c_write_reg(i2c, 0x10, 0x08, 0x07);
1753
1754         /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1755         i2c_write_reg(i2c, 0x10, 0x09, xo2_speed);
1756
1757         if (dev->link[port->lnr].info->con_clock) {
1758                 dev_info(dev->dev, "Setting continuous clock for XO2\n");
1759                 i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1760                 i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1761         } else {
1762                 i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1763                 i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1764         }
1765
1766         usleep_range(2000, 3000);
1767         /* Start XO2 PLL */
1768         i2c_write_reg(i2c, 0x10, 0x08, 0x87);
1769
1770         return 0;
1771 }
1772
1773 static int init_xo2_ci(struct ddb_port *port)
1774 {
1775         struct i2c_adapter *i2c = &port->i2c->adap;
1776         struct ddb *dev = port->dev;
1777         u8 val, data[2];
1778         int res;
1779
1780         res = i2c_read_regs(i2c, 0x10, 0x04, data, 2);
1781         if (res < 0)
1782                 return res;
1783
1784         if (data[0] > 1)  {
1785                 dev_info(dev->dev, "Port %d: invalid XO2 CI %02x\n",
1786                          port->nr, data[0]);
1787                 return -1;
1788         }
1789         dev_info(dev->dev, "Port %d: DuoFlex CI %u.%u\n",
1790                  port->nr, data[0], data[1]);
1791
1792         i2c_read_reg(i2c, 0x10, 0x08, &val);
1793         if (val != 0) {
1794                 i2c_write_reg(i2c, 0x10, 0x08, 0x00);
1795                 msleep(100);
1796         }
1797         /* Enable both CI */
1798         i2c_write_reg(i2c, 0x10, 0x08, 3);
1799         usleep_range(2000, 3000);
1800
1801         /* speed: 0=55,1=75,2=90,3=104 MBit/s */
1802         i2c_write_reg(i2c, 0x10, 0x09, 1);
1803
1804         i2c_write_reg(i2c, 0x10, 0x08, 0x83);
1805         usleep_range(2000, 3000);
1806
1807         if (dev->link[port->lnr].info->con_clock) {
1808                 dev_info(dev->dev, "Setting continuous clock for DuoFlex CI\n");
1809                 i2c_write_reg(i2c, 0x10, 0x0a, 0x03);
1810                 i2c_write_reg(i2c, 0x10, 0x0b, 0x03);
1811         } else {
1812                 i2c_write_reg(i2c, 0x10, 0x0a, 0x01);
1813                 i2c_write_reg(i2c, 0x10, 0x0b, 0x01);
1814         }
1815         return 0;
1816 }
1817
1818 static int port_has_cxd28xx(struct ddb_port *port, u8 *id)
1819 {
1820         struct i2c_adapter *i2c = &port->i2c->adap;
1821         int status;
1822
1823         status = i2c_write_reg(&port->i2c->adap, 0x6e, 0, 0);
1824         if (status)
1825                 return 0;
1826         status = i2c_read_reg(i2c, 0x6e, 0xfd, id);
1827         if (status)
1828                 return 0;
1829         return 1;
1830 }
1831
1832 static char *xo2names[] = {
1833         "DUAL DVB-S2", "DUAL DVB-C/T/T2",
1834         "DUAL DVB-ISDBT", "DUAL DVB-C/C2/T/T2",
1835         "DUAL ATSC", "DUAL DVB-C/C2/T/T2,ISDB-T",
1836         "", ""
1837 };
1838
1839 static char *xo2types[] = {
1840         "DVBS_ST", "DVBCT2_SONY",
1841         "ISDBT_SONY", "DVBC2T2_SONY",
1842         "ATSC_ST", "DVBC2T2I_SONY"
1843 };
1844
1845 static void ddb_port_probe(struct ddb_port *port)
1846 {
1847         struct ddb *dev = port->dev;
1848         u32 l = port->lnr;
1849         struct ddb_link *link = &dev->link[l];
1850         u8 id, type;
1851
1852         port->name = "NO MODULE";
1853         port->type_name = "NONE";
1854         port->class = DDB_PORT_NONE;
1855
1856         /* Handle missing ports and ports without I2C */
1857
1858         if (dummy_tuner && !port->nr &&
1859             link->ids.device == 0x0005) {
1860                 port->name = "DUMMY";
1861                 port->class = DDB_PORT_TUNER;
1862                 port->type = DDB_TUNER_DUMMY;
1863                 port->type_name = "DUMMY";
1864                 return;
1865         }
1866
1867         if (port->nr == ts_loop) {
1868                 port->name = "TS LOOP";
1869                 port->class = DDB_PORT_LOOP;
1870                 return;
1871         }
1872
1873         if (port->nr == 1 && link->info->type == DDB_OCTOPUS_CI &&
1874             link->info->i2c_mask == 1) {
1875                 port->name = "NO TAB";
1876                 port->class = DDB_PORT_NONE;
1877                 return;
1878         }
1879
1880         if (link->info->type == DDB_OCTOPUS_MAX) {
1881                 port->name = "DUAL DVB-S2 MAX";
1882                 port->type_name = "MXL5XX";
1883                 port->class = DDB_PORT_TUNER;
1884                 port->type = DDB_TUNER_MXL5XX;
1885                 if (port->i2c)
1886                         ddbwritel(dev, I2C_SPEED_400,
1887                                   port->i2c->regs + I2C_TIMING);
1888                 return;
1889         }
1890
1891         if (link->info->type == DDB_OCTOPUS_MCI) {
1892                 if (port->nr >= link->info->mci_ports)
1893                         return;
1894                 port->name = "DUAL MCI";
1895                 port->type_name = "MCI";
1896                 port->class = DDB_PORT_TUNER;
1897                 port->type = DDB_TUNER_MCI + link->info->mci_type;
1898                 return;
1899         }
1900
1901         if (port->nr > 1 && link->info->type == DDB_OCTOPUS_CI) {
1902                 port->name = "CI internal";
1903                 port->type_name = "INTERNAL";
1904                 port->class = DDB_PORT_CI;
1905                 port->type = DDB_CI_INTERNAL;
1906         }
1907
1908         if (!port->i2c)
1909                 return;
1910
1911         /* Probe ports with I2C */
1912
1913         if (port_has_cxd(port, &id)) {
1914                 if (id == 1) {
1915                         port->name = "CI";
1916                         port->type_name = "CXD2099";
1917                         port->class = DDB_PORT_CI;
1918                         port->type = DDB_CI_EXTERNAL_SONY;
1919                         ddbwritel(dev, I2C_SPEED_400,
1920                                   port->i2c->regs + I2C_TIMING);
1921                 } else {
1922                         dev_info(dev->dev, "Port %d: Uninitialized DuoFlex\n",
1923                                  port->nr);
1924                         return;
1925                 }
1926         } else if (port_has_xo2(port, &type, &id)) {
1927                 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1928                 /*dev_info(dev->dev, "XO2 ID %02x\n", id);*/
1929                 if (type == 2) {
1930                         port->name = "DuoFlex CI";
1931                         port->class = DDB_PORT_CI;
1932                         port->type = DDB_CI_EXTERNAL_XO2;
1933                         port->type_name = "CI_XO2";
1934                         init_xo2_ci(port);
1935                         return;
1936                 }
1937                 id >>= 2;
1938                 if (id > 5) {
1939                         port->name = "unknown XO2 DuoFlex";
1940                         port->type_name = "UNKNOWN";
1941                 } else {
1942                         port->name = xo2names[id];
1943                         port->class = DDB_PORT_TUNER;
1944                         port->type = DDB_TUNER_XO2 + id;
1945                         port->type_name = xo2types[id];
1946                         init_xo2(port);
1947                 }
1948         } else if (port_has_cxd28xx(port, &id)) {
1949                 switch (id) {
1950                 case 0xa4:
1951                         port->name = "DUAL DVB-C2T2 CXD2843";
1952                         port->type = DDB_TUNER_DVBC2T2_SONY_P;
1953                         port->type_name = "DVBC2T2_SONY";
1954                         break;
1955                 case 0xb1:
1956                         port->name = "DUAL DVB-CT2 CXD2837";
1957                         port->type = DDB_TUNER_DVBCT2_SONY_P;
1958                         port->type_name = "DVBCT2_SONY";
1959                         break;
1960                 case 0xb0:
1961                         port->name = "DUAL ISDB-T CXD2838";
1962                         port->type = DDB_TUNER_ISDBT_SONY_P;
1963                         port->type_name = "ISDBT_SONY";
1964                         break;
1965                 case 0xc1:
1966                         port->name = "DUAL DVB-C2T2 ISDB-T CXD2854";
1967                         port->type = DDB_TUNER_DVBC2T2I_SONY_P;
1968                         port->type_name = "DVBC2T2I_ISDBT_SONY";
1969                         break;
1970                 default:
1971                         return;
1972                 }
1973                 port->class = DDB_PORT_TUNER;
1974                 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
1975         } else if (port_has_stv0900(port)) {
1976                 port->name = "DUAL DVB-S2";
1977                 port->class = DDB_PORT_TUNER;
1978                 port->type = DDB_TUNER_DVBS_ST;
1979                 port->type_name = "DVBS_ST";
1980                 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1981         } else if (port_has_stv0900_aa(port, &id)) {
1982                 port->name = "DUAL DVB-S2";
1983                 port->class = DDB_PORT_TUNER;
1984                 if (id == 0x51) {
1985                         if (port->nr == 0 &&
1986                             link->info->ts_quirks & TS_QUIRK_REVERSED)
1987                                 port->type = DDB_TUNER_DVBS_STV0910_PR;
1988                         else
1989                                 port->type = DDB_TUNER_DVBS_STV0910_P;
1990                         port->type_name = "DVBS_ST_0910";
1991                 } else {
1992                         port->type = DDB_TUNER_DVBS_ST_AA;
1993                         port->type_name = "DVBS_ST_AA";
1994                 }
1995                 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
1996         } else if (port_has_drxks(port)) {
1997                 port->name = "DUAL DVB-C/T";
1998                 port->class = DDB_PORT_TUNER;
1999                 port->type = DDB_TUNER_DVBCT_TR;
2000                 port->type_name = "DVBCT_TR";
2001                 ddbwritel(dev, I2C_SPEED_400, port->i2c->regs + I2C_TIMING);
2002         } else if (port_has_stv0367(port)) {
2003                 port->name = "DUAL DVB-C/T";
2004                 port->class = DDB_PORT_TUNER;
2005                 port->type = DDB_TUNER_DVBCT_ST;
2006                 port->type_name = "DVBCT_ST";
2007                 ddbwritel(dev, I2C_SPEED_100, port->i2c->regs + I2C_TIMING);
2008         } else if (port_has_encti(port)) {
2009                 port->name = "ENCTI";
2010                 port->class = DDB_PORT_LOOP;
2011         }
2012 }
2013
2014 /****************************************************************************/
2015 /****************************************************************************/
2016 /****************************************************************************/
2017
2018 static int ddb_port_attach(struct ddb_port *port)
2019 {
2020         int ret = 0;
2021
2022         switch (port->class) {
2023         case DDB_PORT_TUNER:
2024                 ret = dvb_input_attach(port->input[0]);
2025                 if (ret < 0)
2026                         break;
2027                 ret = dvb_input_attach(port->input[1]);
2028                 if (ret < 0) {
2029                         dvb_input_detach(port->input[0]);
2030                         break;
2031                 }
2032                 port->input[0]->redi = port->input[0];
2033                 port->input[1]->redi = port->input[1];
2034                 break;
2035         case DDB_PORT_CI:
2036                 ret = ddb_ci_attach(port, ci_bitrate);
2037                 if (ret < 0)
2038                         break;
2039                 /* fall-through */
2040         case DDB_PORT_LOOP:
2041                 ret = dvb_register_device(port->dvb[0].adap,
2042                                           &port->dvb[0].dev,
2043                                           &dvbdev_ci, (void *)port->output,
2044                                           DVB_DEVICE_SEC, 0);
2045                 break;
2046         default:
2047                 break;
2048         }
2049         if (ret < 0)
2050                 dev_err(port->dev->dev, "port_attach on port %d failed\n",
2051                         port->nr);
2052         return ret;
2053 }
2054
2055 int ddb_ports_attach(struct ddb *dev)
2056 {
2057         int i, numports, err_ports = 0, ret = 0;
2058         struct ddb_port *port;
2059
2060         if (dev->port_num) {
2061                 ret = dvb_register_adapters(dev);
2062                 if (ret < 0) {
2063                         dev_err(dev->dev, "Registering adapters failed. Check DVB_MAX_ADAPTERS in config.\n");
2064                         return ret;
2065                 }
2066         }
2067
2068         numports = dev->port_num;
2069
2070         for (i = 0; i < dev->port_num; i++) {
2071                 port = &dev->port[i];
2072                 if (port->class != DDB_PORT_NONE) {
2073                         ret = ddb_port_attach(port);
2074                         if (ret)
2075                                 err_ports++;
2076                 } else {
2077                         numports--;
2078                 }
2079         }
2080
2081         if (err_ports) {
2082                 if (err_ports == numports) {
2083                         dev_err(dev->dev, "All connected ports failed to initialise!\n");
2084                         return -ENODEV;
2085                 }
2086
2087                 dev_warn(dev->dev, "%d of %d connected ports failed to initialise!\n",
2088                          err_ports, numports);
2089         }
2090
2091         return 0;
2092 }
2093
2094 void ddb_ports_detach(struct ddb *dev)
2095 {
2096         int i;
2097         struct ddb_port *port;
2098
2099         for (i = 0; i < dev->port_num; i++) {
2100                 port = &dev->port[i];
2101
2102                 switch (port->class) {
2103                 case DDB_PORT_TUNER:
2104                         dvb_input_detach(port->input[1]);
2105                         dvb_input_detach(port->input[0]);
2106                         break;
2107                 case DDB_PORT_CI:
2108                 case DDB_PORT_LOOP:
2109                         ddb_ci_detach(port);
2110                         break;
2111                 }
2112         }
2113         dvb_unregister_adapters(dev);
2114 }
2115
2116 /* Copy input DMA pointers to output DMA and ACK. */
2117
2118 static void input_write_output(struct ddb_input *input,
2119                                struct ddb_output *output)
2120 {
2121         ddbwritel(output->port->dev,
2122                   input->dma->stat, DMA_BUFFER_ACK(output->dma));
2123         output->dma->cbuf = (input->dma->stat >> 11) & 0x1f;
2124         output->dma->coff = (input->dma->stat & 0x7ff) << 7;
2125 }
2126
2127 static void output_ack_input(struct ddb_output *output,
2128                              struct ddb_input *input)
2129 {
2130         ddbwritel(input->port->dev,
2131                   output->dma->stat, DMA_BUFFER_ACK(input->dma));
2132 }
2133
2134 static void input_write_dvb(struct ddb_input *input,
2135                             struct ddb_input *input2)
2136 {
2137         struct ddb_dvb *dvb = &input2->port->dvb[input2->nr & 1];
2138         struct ddb_dma *dma, *dma2;
2139         struct ddb *dev = input->port->dev;
2140         int ack = 1;
2141
2142         dma = input->dma;
2143         dma2 = input->dma;
2144         /*
2145          * if there also is an output connected, do not ACK.
2146          * input_write_output will ACK.
2147          */
2148         if (input->redo) {
2149                 dma2 = input->redo->dma;
2150                 ack = 0;
2151         }
2152         while (dma->cbuf != ((dma->stat >> 11) & 0x1f) ||
2153                (4 & dma->ctrl)) {
2154                 if (4 & dma->ctrl) {
2155                         /* dev_err(dev->dev, "Overflow dma %d\n", dma->nr); */
2156                         ack = 1;
2157                 }
2158                 if (alt_dma)
2159                         dma_sync_single_for_cpu(dev->dev, dma2->pbuf[dma->cbuf],
2160                                                 dma2->size, DMA_FROM_DEVICE);
2161                 dvb_dmx_swfilter_packets(&dvb->demux,
2162                                          dma2->vbuf[dma->cbuf],
2163                                          dma2->size / 188);
2164                 dma->cbuf = (dma->cbuf + 1) % dma2->num;
2165                 if (ack)
2166                         ddbwritel(dev, (dma->cbuf << 11),
2167                                   DMA_BUFFER_ACK(dma));
2168                 dma->stat = safe_ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2169                 dma->ctrl = safe_ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2170         }
2171 }
2172
2173 static void input_work(struct work_struct *work)
2174 {
2175         struct ddb_dma *dma = container_of(work, struct ddb_dma, work);
2176         struct ddb_input *input = (struct ddb_input *)dma->io;
2177         struct ddb *dev = input->port->dev;
2178         unsigned long flags;
2179
2180         spin_lock_irqsave(&dma->lock, flags);
2181         if (!dma->running) {
2182                 spin_unlock_irqrestore(&dma->lock, flags);
2183                 return;
2184         }
2185         dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2186         dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2187
2188         if (input->redi)
2189                 input_write_dvb(input, input->redi);
2190         if (input->redo)
2191                 input_write_output(input, input->redo);
2192         wake_up(&dma->wq);
2193         spin_unlock_irqrestore(&dma->lock, flags);
2194 }
2195
2196 static void input_handler(void *data)
2197 {
2198         struct ddb_input *input = (struct ddb_input *)data;
2199         struct ddb_dma *dma = input->dma;
2200
2201         queue_work(ddb_wq, &dma->work);
2202 }
2203
2204 static void output_work(struct work_struct *work)
2205 {
2206         struct ddb_dma *dma = container_of(work, struct ddb_dma, work);
2207         struct ddb_output *output = (struct ddb_output *)dma->io;
2208         struct ddb *dev = output->port->dev;
2209         unsigned long flags;
2210
2211         spin_lock_irqsave(&dma->lock, flags);
2212         if (!dma->running)
2213                 goto unlock_exit;
2214         dma->stat = ddbreadl(dev, DMA_BUFFER_CURRENT(dma));
2215         dma->ctrl = ddbreadl(dev, DMA_BUFFER_CONTROL(dma));
2216         if (output->redi)
2217                 output_ack_input(output, output->redi);
2218         wake_up(&dma->wq);
2219 unlock_exit:
2220         spin_unlock_irqrestore(&dma->lock, flags);
2221 }
2222
2223 static void output_handler(void *data)
2224 {
2225         struct ddb_output *output = (struct ddb_output *)data;
2226         struct ddb_dma *dma = output->dma;
2227
2228         queue_work(ddb_wq, &dma->work);
2229 }
2230
2231 /****************************************************************************/
2232 /****************************************************************************/
2233
2234 static const struct ddb_regmap *io_regmap(struct ddb_io *io, int link)
2235 {
2236         const struct ddb_info *info;
2237
2238         if (link)
2239                 info = io->port->dev->link[io->port->lnr].info;
2240         else
2241                 info = io->port->dev->link[0].info;
2242
2243         if (!info)
2244                 return NULL;
2245
2246         return info->regmap;
2247 }
2248
2249 static void ddb_dma_init(struct ddb_io *io, int nr, int out)
2250 {
2251         struct ddb_dma *dma;
2252         const struct ddb_regmap *rm = io_regmap(io, 0);
2253
2254         dma = out ? &io->port->dev->odma[nr] : &io->port->dev->idma[nr];
2255         io->dma = dma;
2256         dma->io = io;
2257
2258         spin_lock_init(&dma->lock);
2259         init_waitqueue_head(&dma->wq);
2260         if (out) {
2261                 INIT_WORK(&dma->work, output_work);
2262                 dma->regs = rm->odma->base + rm->odma->size * nr;
2263                 dma->bufregs = rm->odma_buf->base + rm->odma_buf->size * nr;
2264                 dma->num = dma_buf_num;
2265                 dma->size = dma_buf_size * 128 * 47;
2266                 dma->div = 1;
2267         } else {
2268                 INIT_WORK(&dma->work, input_work);
2269                 dma->regs = rm->idma->base + rm->idma->size * nr;
2270                 dma->bufregs = rm->idma_buf->base + rm->idma_buf->size * nr;
2271                 dma->num = dma_buf_num;
2272                 dma->size = dma_buf_size * 128 * 47;
2273                 dma->div = 1;
2274         }
2275         ddbwritel(io->port->dev, 0, DMA_BUFFER_ACK(dma));
2276         dev_dbg(io->port->dev->dev, "init link %u, io %u, dma %u, dmaregs %08x bufregs %08x\n",
2277                 io->port->lnr, io->nr, nr, dma->regs, dma->bufregs);
2278 }
2279
2280 static void ddb_input_init(struct ddb_port *port, int nr, int pnr, int anr)
2281 {
2282         struct ddb *dev = port->dev;
2283         struct ddb_input *input = &dev->input[anr];
2284         const struct ddb_regmap *rm;
2285
2286         port->input[pnr] = input;
2287         input->nr = nr;
2288         input->port = port;
2289         rm = io_regmap(input, 1);
2290         input->regs = DDB_LINK_TAG(port->lnr) |
2291                 (rm->input->base + rm->input->size * nr);
2292         dev_dbg(dev->dev, "init link %u, input %u, regs %08x\n",
2293                 port->lnr, nr, input->regs);
2294
2295         if (dev->has_dma) {
2296                 const struct ddb_regmap *rm0 = io_regmap(input, 0);
2297                 u32 base = rm0->irq_base_idma;
2298                 u32 dma_nr = nr;
2299
2300                 if (port->lnr)
2301                         dma_nr += 32 + (port->lnr - 1) * 8;
2302
2303                 dev_dbg(dev->dev, "init link %u, input %u, handler %u\n",
2304                         port->lnr, nr, dma_nr + base);
2305
2306                 ddb_irq_set(dev, 0, dma_nr + base, &input_handler, input);
2307                 ddb_dma_init(input, dma_nr, 0);
2308         }
2309 }
2310
2311 static void ddb_output_init(struct ddb_port *port, int nr)
2312 {
2313         struct ddb *dev = port->dev;
2314         struct ddb_output *output = &dev->output[nr];
2315         const struct ddb_regmap *rm;
2316
2317         port->output = output;
2318         output->nr = nr;
2319         output->port = port;
2320         rm = io_regmap(output, 1);
2321         output->regs = DDB_LINK_TAG(port->lnr) |
2322                 (rm->output->base + rm->output->size * nr);
2323
2324         dev_dbg(dev->dev, "init link %u, output %u, regs %08x\n",
2325                 port->lnr, nr, output->regs);
2326
2327         if (dev->has_dma) {
2328                 const struct ddb_regmap *rm0 = io_regmap(output, 0);
2329                 u32 base = rm0->irq_base_odma;
2330
2331                 ddb_irq_set(dev, 0, nr + base, &output_handler, output);
2332                 ddb_dma_init(output, nr, 1);
2333         }
2334 }
2335
2336 static int ddb_port_match_i2c(struct ddb_port *port)
2337 {
2338         struct ddb *dev = port->dev;
2339         u32 i;
2340
2341         for (i = 0; i < dev->i2c_num; i++) {
2342                 if (dev->i2c[i].link == port->lnr &&
2343                     dev->i2c[i].nr == port->nr) {
2344                         port->i2c = &dev->i2c[i];
2345                         return 1;
2346                 }
2347         }
2348         return 0;
2349 }
2350
2351 static int ddb_port_match_link_i2c(struct ddb_port *port)
2352 {
2353         struct ddb *dev = port->dev;
2354         u32 i;
2355
2356         for (i = 0; i < dev->i2c_num; i++) {
2357                 if (dev->i2c[i].link == port->lnr) {
2358                         port->i2c = &dev->i2c[i];
2359                         return 1;
2360                 }
2361         }
2362         return 0;
2363 }
2364
2365 void ddb_ports_init(struct ddb *dev)
2366 {
2367         u32 i, l, p;
2368         struct ddb_port *port;
2369         const struct ddb_info *info;
2370         const struct ddb_regmap *rm;
2371
2372         for (p = l = 0; l < DDB_MAX_LINK; l++) {
2373                 info = dev->link[l].info;
2374                 if (!info)
2375                         continue;
2376                 rm = info->regmap;
2377                 if (!rm)
2378                         continue;
2379                 for (i = 0; i < info->port_num; i++, p++) {
2380                         port = &dev->port[p];
2381                         port->dev = dev;
2382                         port->nr = i;
2383                         port->lnr = l;
2384                         port->pnr = p;
2385                         port->gap = 0xffffffff;
2386                         port->obr = ci_bitrate;
2387                         mutex_init(&port->i2c_gate_lock);
2388
2389                         if (!ddb_port_match_i2c(port)) {
2390                                 if (info->type == DDB_OCTOPUS_MAX)
2391                                         ddb_port_match_link_i2c(port);
2392                         }
2393
2394                         ddb_port_probe(port);
2395
2396                         port->dvb[0].adap = &dev->adap[2 * p];
2397                         port->dvb[1].adap = &dev->adap[2 * p + 1];
2398
2399                         if (port->class == DDB_PORT_NONE && i && p &&
2400                             dev->port[p - 1].type == DDB_CI_EXTERNAL_XO2) {
2401                                 port->class = DDB_PORT_CI;
2402                                 port->type = DDB_CI_EXTERNAL_XO2_B;
2403                                 port->name = "DuoFlex CI_B";
2404                                 port->i2c = dev->port[p - 1].i2c;
2405                         }
2406
2407                         dev_info(dev->dev, "Port %u: Link %u, Link Port %u (TAB %u): %s\n",
2408                                  port->pnr, port->lnr, port->nr, port->nr + 1,
2409                                  port->name);
2410
2411                         if (port->class == DDB_PORT_CI &&
2412                             port->type == DDB_CI_EXTERNAL_XO2) {
2413                                 ddb_input_init(port, 2 * i, 0, 2 * i);
2414                                 ddb_output_init(port, i);
2415                                 continue;
2416                         }
2417
2418                         if (port->class == DDB_PORT_CI &&
2419                             port->type == DDB_CI_EXTERNAL_XO2_B) {
2420                                 ddb_input_init(port, 2 * i - 1, 0, 2 * i - 1);
2421                                 ddb_output_init(port, i);
2422                                 continue;
2423                         }
2424
2425                         if (port->class == DDB_PORT_NONE)
2426                                 continue;
2427
2428                         switch (dev->link[l].info->type) {
2429                         case DDB_OCTOPUS_CI:
2430                                 if (i >= 2) {
2431                                         ddb_input_init(port, 2 + i, 0, 2 + i);
2432                                         ddb_input_init(port, 4 + i, 1, 4 + i);
2433                                         ddb_output_init(port, i);
2434                                         break;
2435                                 } /* fallthrough */
2436                         case DDB_OCTOPUS:
2437                                 ddb_input_init(port, 2 * i, 0, 2 * i);
2438                                 ddb_input_init(port, 2 * i + 1, 1, 2 * i + 1);
2439                                 ddb_output_init(port, i);
2440                                 break;
2441                         case DDB_OCTOPUS_MAX:
2442                         case DDB_OCTOPUS_MAX_CT:
2443                         case DDB_OCTOPUS_MCI:
2444                                 ddb_input_init(port, 2 * i, 0, 2 * p);
2445                                 ddb_input_init(port, 2 * i + 1, 1, 2 * p + 1);
2446                                 break;
2447                         default:
2448                                 break;
2449                         }
2450                 }
2451         }
2452         dev->port_num = p;
2453 }
2454
2455 void ddb_ports_release(struct ddb *dev)
2456 {
2457         int i;
2458         struct ddb_port *port;
2459
2460         for (i = 0; i < dev->port_num; i++) {
2461                 port = &dev->port[i];
2462                 if (port->input[0] && port->input[0]->dma)
2463                         cancel_work_sync(&port->input[0]->dma->work);
2464                 if (port->input[1] && port->input[1]->dma)
2465                         cancel_work_sync(&port->input[1]->dma->work);
2466                 if (port->output && port->output->dma)
2467                         cancel_work_sync(&port->output->dma->work);
2468         }
2469 }
2470
2471 /****************************************************************************/
2472 /****************************************************************************/
2473 /****************************************************************************/
2474
2475 #define IRQ_HANDLE(_nr) \
2476         do { if ((s & (1UL << ((_nr) & 0x1f))) && \
2477                  dev->link[0].irq[_nr].handler) \
2478                 dev->link[0].irq[_nr].handler(dev->link[0].irq[_nr].data); } \
2479         while (0)
2480
2481 #define IRQ_HANDLE_NIBBLE(_shift) {                  \
2482         if (s & (0x0000000f << ((_shift) & 0x1f))) { \
2483                 IRQ_HANDLE(0 + (_shift));            \
2484                 IRQ_HANDLE(1 + (_shift));            \
2485                 IRQ_HANDLE(2 + (_shift));            \
2486                 IRQ_HANDLE(3 + (_shift));            \
2487         }                                            \
2488 }
2489
2490 #define IRQ_HANDLE_BYTE(_shift) {                    \
2491         if (s & (0x000000ff << ((_shift) & 0x1f))) { \
2492                 IRQ_HANDLE(0 + (_shift));            \
2493                 IRQ_HANDLE(1 + (_shift));            \
2494                 IRQ_HANDLE(2 + (_shift));            \
2495                 IRQ_HANDLE(3 + (_shift));            \
2496                 IRQ_HANDLE(4 + (_shift));            \
2497                 IRQ_HANDLE(5 + (_shift));            \
2498                 IRQ_HANDLE(6 + (_shift));            \
2499                 IRQ_HANDLE(7 + (_shift));            \
2500         }                                            \
2501 }
2502
2503 static void irq_handle_msg(struct ddb *dev, u32 s)
2504 {
2505         dev->i2c_irq++;
2506         IRQ_HANDLE_NIBBLE(0);
2507 }
2508
2509 static void irq_handle_io(struct ddb *dev, u32 s)
2510 {
2511         dev->ts_irq++;
2512         IRQ_HANDLE_NIBBLE(4);
2513         IRQ_HANDLE_BYTE(8);
2514         IRQ_HANDLE_BYTE(16);
2515         IRQ_HANDLE_BYTE(24);
2516 }
2517
2518 irqreturn_t ddb_irq_handler0(int irq, void *dev_id)
2519 {
2520         struct ddb *dev = (struct ddb *)dev_id;
2521         u32 mask = 0x8fffff00;
2522         u32 s = mask & ddbreadl(dev, INTERRUPT_STATUS);
2523
2524         if (!s)
2525                 return IRQ_NONE;
2526         do {
2527                 if (s & 0x80000000)
2528                         return IRQ_NONE;
2529                 ddbwritel(dev, s, INTERRUPT_ACK);
2530                 irq_handle_io(dev, s);
2531         } while ((s = mask & ddbreadl(dev, INTERRUPT_STATUS)));
2532
2533         return IRQ_HANDLED;
2534 }
2535
2536 irqreturn_t ddb_irq_handler1(int irq, void *dev_id)
2537 {
2538         struct ddb *dev = (struct ddb *)dev_id;
2539         u32 mask = 0x8000000f;
2540         u32 s = mask & ddbreadl(dev, INTERRUPT_STATUS);
2541
2542         if (!s)
2543                 return IRQ_NONE;
2544         do {
2545                 if (s & 0x80000000)
2546                         return IRQ_NONE;
2547                 ddbwritel(dev, s, INTERRUPT_ACK);
2548                 irq_handle_msg(dev, s);
2549         } while ((s = mask & ddbreadl(dev, INTERRUPT_STATUS)));
2550
2551         return IRQ_HANDLED;
2552 }
2553
2554 irqreturn_t ddb_irq_handler(int irq, void *dev_id)
2555 {
2556         struct ddb *dev = (struct ddb *)dev_id;
2557         u32 s = ddbreadl(dev, INTERRUPT_STATUS);
2558         int ret = IRQ_HANDLED;
2559
2560         if (!s)
2561                 return IRQ_NONE;
2562         do {
2563                 if (s & 0x80000000)
2564                         return IRQ_NONE;
2565                 ddbwritel(dev, s, INTERRUPT_ACK);
2566
2567                 if (s & 0x0000000f)
2568                         irq_handle_msg(dev, s);
2569                 if (s & 0x0fffff00)
2570                         irq_handle_io(dev, s);
2571         } while ((s = ddbreadl(dev, INTERRUPT_STATUS)));
2572
2573         return ret;
2574 }
2575
2576 /****************************************************************************/
2577 /****************************************************************************/
2578 /****************************************************************************/
2579
2580 static int reg_wait(struct ddb *dev, u32 reg, u32 bit)
2581 {
2582         u32 count = 0;
2583
2584         while (safe_ddbreadl(dev, reg) & bit) {
2585                 ndelay(10);
2586                 if (++count == 100)
2587                         return -1;
2588         }
2589         return 0;
2590 }
2591
2592 static int flashio(struct ddb *dev, u32 lnr, u8 *wbuf, u32 wlen, u8 *rbuf,
2593                    u32 rlen)
2594 {
2595         u32 data, shift;
2596         u32 tag = DDB_LINK_TAG(lnr);
2597         struct ddb_link *link = &dev->link[lnr];
2598
2599         mutex_lock(&link->flash_mutex);
2600         if (wlen > 4)
2601                 ddbwritel(dev, 1, tag | SPI_CONTROL);
2602         while (wlen > 4) {
2603                 /* FIXME: check for big-endian */
2604                 data = swab32(*(u32 *)wbuf);
2605                 wbuf += 4;
2606                 wlen -= 4;
2607                 ddbwritel(dev, data, tag | SPI_DATA);
2608                 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2609                         goto fail;
2610         }
2611         if (rlen)
2612                 ddbwritel(dev, 0x0001 | ((wlen << (8 + 3)) & 0x1f00),
2613                           tag | SPI_CONTROL);
2614         else
2615                 ddbwritel(dev, 0x0003 | ((wlen << (8 + 3)) & 0x1f00),
2616                           tag | SPI_CONTROL);
2617
2618         data = 0;
2619         shift = ((4 - wlen) * 8);
2620         while (wlen) {
2621                 data <<= 8;
2622                 data |= *wbuf;
2623                 wlen--;
2624                 wbuf++;
2625         }
2626         if (shift)
2627                 data <<= shift;
2628         ddbwritel(dev, data, tag | SPI_DATA);
2629         if (reg_wait(dev, tag | SPI_CONTROL, 4))
2630                 goto fail;
2631
2632         if (!rlen) {
2633                 ddbwritel(dev, 0, tag | SPI_CONTROL);
2634                 goto exit;
2635         }
2636         if (rlen > 4)
2637                 ddbwritel(dev, 1, tag | SPI_CONTROL);
2638
2639         while (rlen > 4) {
2640                 ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2641                 if (reg_wait(dev, tag | SPI_CONTROL, 4))
2642                         goto fail;
2643                 data = ddbreadl(dev, tag | SPI_DATA);
2644                 *(u32 *)rbuf = swab32(data);
2645                 rbuf += 4;
2646                 rlen -= 4;
2647         }
2648         ddbwritel(dev, 0x0003 | ((rlen << (8 + 3)) & 0x1F00),
2649                   tag | SPI_CONTROL);
2650         ddbwritel(dev, 0xffffffff, tag | SPI_DATA);
2651         if (reg_wait(dev, tag | SPI_CONTROL, 4))
2652                 goto fail;
2653
2654         data = ddbreadl(dev, tag | SPI_DATA);
2655         ddbwritel(dev, 0, tag | SPI_CONTROL);
2656
2657         if (rlen < 4)
2658                 data <<= ((4 - rlen) * 8);
2659
2660         while (rlen > 0) {
2661                 *rbuf = ((data >> 24) & 0xff);
2662                 data <<= 8;
2663                 rbuf++;
2664                 rlen--;
2665         }
2666 exit:
2667         mutex_unlock(&link->flash_mutex);
2668         return 0;
2669 fail:
2670         mutex_unlock(&link->flash_mutex);
2671         return -1;
2672 }
2673
2674 int ddbridge_flashread(struct ddb *dev, u32 link, u8 *buf, u32 addr, u32 len)
2675 {
2676         u8 cmd[4] = {0x03, (addr >> 16) & 0xff,
2677                      (addr >> 8) & 0xff, addr & 0xff};
2678
2679         return flashio(dev, link, cmd, 4, buf, len);
2680 }
2681
2682 /*
2683  * TODO/FIXME: add/implement IOCTLs from upstream driver
2684  */
2685
2686 #define DDB_NAME "ddbridge"
2687
2688 static u32 ddb_num;
2689 static int ddb_major;
2690 static DEFINE_MUTEX(ddb_mutex);
2691
2692 static int ddb_release(struct inode *inode, struct file *file)
2693 {
2694         struct ddb *dev = file->private_data;
2695
2696         dev->ddb_dev_users--;
2697         return 0;
2698 }
2699
2700 static int ddb_open(struct inode *inode, struct file *file)
2701 {
2702         struct ddb *dev = ddbs[iminor(inode)];
2703
2704         if (dev->ddb_dev_users)
2705                 return -EBUSY;
2706         dev->ddb_dev_users++;
2707         file->private_data = dev;
2708         return 0;
2709 }
2710
2711 static long ddb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2712 {
2713         struct ddb *dev = file->private_data;
2714
2715         dev_warn(dev->dev, "DDB IOCTLs unsupported (cmd: %d, arg: %lu)\n",
2716                  cmd, arg);
2717
2718         return -ENOTTY;
2719 }
2720
2721 static const struct file_operations ddb_fops = {
2722         .unlocked_ioctl = ddb_ioctl,
2723         .open           = ddb_open,
2724         .release        = ddb_release,
2725 };
2726
2727 static char *ddb_devnode(struct device *device, umode_t *mode)
2728 {
2729         struct ddb *dev = dev_get_drvdata(device);
2730
2731         return kasprintf(GFP_KERNEL, "ddbridge/card%d", dev->nr);
2732 }
2733
2734 #define __ATTR_MRO(_name, _show) {                              \
2735         .attr   = { .name = __stringify(_name), .mode = 0444 }, \
2736         .show   = _show,                                        \
2737 }
2738
2739 #define __ATTR_MWO(_name, _store) {                             \
2740         .attr   = { .name = __stringify(_name), .mode = 0222 }, \
2741         .store  = _store,                                       \
2742 }
2743
2744 static ssize_t ports_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->port_num);
2750 }
2751
2752 static ssize_t ts_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->ts_irq);
2758 }
2759
2760 static ssize_t i2c_irq_show(struct device *device,
2761                             struct device_attribute *attr, char *buf)
2762 {
2763         struct ddb *dev = dev_get_drvdata(device);
2764
2765         return sprintf(buf, "%d\n", dev->i2c_irq);
2766 }
2767
2768 static ssize_t fan_show(struct device *device,
2769                         struct device_attribute *attr, char *buf)
2770 {
2771         struct ddb *dev = dev_get_drvdata(device);
2772         u32 val;
2773
2774         val = ddbreadl(dev, GPIO_OUTPUT) & 1;
2775         return sprintf(buf, "%d\n", val);
2776 }
2777
2778 static ssize_t fan_store(struct device *device, struct device_attribute *d,
2779                          const char *buf, size_t count)
2780 {
2781         struct ddb *dev = dev_get_drvdata(device);
2782         u32 val;
2783
2784         if (sscanf(buf, "%u\n", &val) != 1)
2785                 return -EINVAL;
2786         ddbwritel(dev, 1, GPIO_DIRECTION);
2787         ddbwritel(dev, val & 1, GPIO_OUTPUT);
2788         return count;
2789 }
2790
2791 static ssize_t fanspeed_show(struct device *device,
2792                              struct device_attribute *attr, char *buf)
2793 {
2794         struct ddb *dev = dev_get_drvdata(device);
2795         int num = attr->attr.name[8] - 0x30;
2796         struct ddb_link *link = &dev->link[num];
2797         u32 spd;
2798
2799         spd = ddblreadl(link, TEMPMON_FANCONTROL) & 0xff;
2800         return sprintf(buf, "%u\n", spd * 100);
2801 }
2802
2803 static ssize_t temp_show(struct device *device,
2804                          struct device_attribute *attr, char *buf)
2805 {
2806         struct ddb *dev = dev_get_drvdata(device);
2807         struct ddb_link *link = &dev->link[0];
2808         struct i2c_adapter *adap;
2809         int temp, temp2;
2810         u8 tmp[2];
2811
2812         if (!link->info->temp_num)
2813                 return sprintf(buf, "no sensor\n");
2814         adap = &dev->i2c[link->info->temp_bus].adap;
2815         if (i2c_read_regs(adap, 0x48, 0, tmp, 2) < 0)
2816                 return sprintf(buf, "read_error\n");
2817         temp = (tmp[0] << 3) | (tmp[1] >> 5);
2818         temp *= 125;
2819         if (link->info->temp_num == 2) {
2820                 if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
2821                         return sprintf(buf, "read_error\n");
2822                 temp2 = (tmp[0] << 3) | (tmp[1] >> 5);
2823                 temp2 *= 125;
2824                 return sprintf(buf, "%d %d\n", temp, temp2);
2825         }
2826         return sprintf(buf, "%d\n", temp);
2827 }
2828
2829 static ssize_t ctemp_show(struct device *device,
2830                           struct device_attribute *attr, char *buf)
2831 {
2832         struct ddb *dev = dev_get_drvdata(device);
2833         struct i2c_adapter *adap;
2834         int temp;
2835         u8 tmp[2];
2836         int num = attr->attr.name[4] - 0x30;
2837
2838         adap = &dev->i2c[num].adap;
2839         if (!adap)
2840                 return 0;
2841         if (i2c_read_regs(adap, 0x49, 0, tmp, 2) < 0)
2842                 if (i2c_read_regs(adap, 0x4d, 0, tmp, 2) < 0)
2843                         return sprintf(buf, "no sensor\n");
2844         temp = tmp[0] * 1000;
2845         return sprintf(buf, "%d\n", temp);
2846 }
2847
2848 static ssize_t led_show(struct device *device,
2849                         struct device_attribute *attr, char *buf)
2850 {
2851         struct ddb *dev = dev_get_drvdata(device);
2852         int num = attr->attr.name[3] - 0x30;
2853
2854         return sprintf(buf, "%d\n", dev->leds & (1 << num) ? 1 : 0);
2855 }
2856
2857 static void ddb_set_led(struct ddb *dev, int num, int val)
2858 {
2859         if (!dev->link[0].info->led_num)
2860                 return;
2861         switch (dev->port[num].class) {
2862         case DDB_PORT_TUNER:
2863                 switch (dev->port[num].type) {
2864                 case DDB_TUNER_DVBS_ST:
2865                         i2c_write_reg16(&dev->i2c[num].adap,
2866                                         0x69, 0xf14c, val ? 2 : 0);
2867                         break;
2868                 case DDB_TUNER_DVBCT_ST:
2869                         i2c_write_reg16(&dev->i2c[num].adap,
2870                                         0x1f, 0xf00e, 0);
2871                         i2c_write_reg16(&dev->i2c[num].adap,
2872                                         0x1f, 0xf00f, val ? 1 : 0);
2873                         break;
2874                 case DDB_TUNER_XO2 ... DDB_TUNER_DVBC2T2I_SONY:
2875                 {
2876                         u8 v;
2877
2878                         i2c_read_reg(&dev->i2c[num].adap, 0x10, 0x08, &v);
2879                         v = (v & ~0x10) | (val ? 0x10 : 0);
2880                         i2c_write_reg(&dev->i2c[num].adap, 0x10, 0x08, v);
2881                         break;
2882                 }
2883                 default:
2884                         break;
2885                 }
2886                 break;
2887         }
2888 }
2889
2890 static ssize_t led_store(struct device *device,
2891                          struct device_attribute *attr,
2892                          const char *buf, size_t count)
2893 {
2894         struct ddb *dev = dev_get_drvdata(device);
2895         int num = attr->attr.name[3] - 0x30;
2896         u32 val;
2897
2898         if (sscanf(buf, "%u\n", &val) != 1)
2899                 return -EINVAL;
2900         if (val)
2901                 dev->leds |= (1 << num);
2902         else
2903                 dev->leds &= ~(1 << num);
2904         ddb_set_led(dev, num, val);
2905         return count;
2906 }
2907
2908 static ssize_t snr_show(struct device *device,
2909                         struct device_attribute *attr, char *buf)
2910 {
2911         struct ddb *dev = dev_get_drvdata(device);
2912         char snr[32];
2913         int num = attr->attr.name[3] - 0x30;
2914
2915         if (dev->port[num].type >= DDB_TUNER_XO2) {
2916                 if (i2c_read_regs(&dev->i2c[num].adap, 0x10, 0x10, snr, 16) < 0)
2917                         return sprintf(buf, "NO SNR\n");
2918                 snr[16] = 0;
2919         } else {
2920                 /* serial number at 0x100-0x11f */
2921                 if (i2c_read_regs16(&dev->i2c[num].adap,
2922                                     0x57, 0x100, snr, 32) < 0)
2923                         if (i2c_read_regs16(&dev->i2c[num].adap,
2924                                             0x50, 0x100, snr, 32) < 0)
2925                                 return sprintf(buf, "NO SNR\n");
2926                 snr[31] = 0; /* in case it is not terminated on EEPROM */
2927         }
2928         return sprintf(buf, "%s\n", snr);
2929 }
2930
2931 static ssize_t bsnr_show(struct device *device,
2932                          struct device_attribute *attr, char *buf)
2933 {
2934         struct ddb *dev = dev_get_drvdata(device);
2935         char snr[16];
2936
2937         ddbridge_flashread(dev, 0, snr, 0x10, 15);
2938         snr[15] = 0; /* in case it is not terminated on EEPROM */
2939         return sprintf(buf, "%s\n", snr);
2940 }
2941
2942 static ssize_t bpsnr_show(struct device *device,
2943                           struct device_attribute *attr, char *buf)
2944 {
2945         struct ddb *dev = dev_get_drvdata(device);
2946         unsigned char snr[32];
2947
2948         if (!dev->i2c_num)
2949                 return 0;
2950
2951         if (i2c_read_regs16(&dev->i2c[0].adap,
2952                             0x50, 0x0000, snr, 32) < 0 ||
2953             snr[0] == 0xff)
2954                 return sprintf(buf, "NO SNR\n");
2955         snr[31] = 0; /* in case it is not terminated on EEPROM */
2956         return sprintf(buf, "%s\n", snr);
2957 }
2958
2959 static ssize_t redirect_show(struct device *device,
2960                              struct device_attribute *attr, char *buf)
2961 {
2962         return 0;
2963 }
2964
2965 static ssize_t redirect_store(struct device *device,
2966                               struct device_attribute *attr,
2967                               const char *buf, size_t count)
2968 {
2969         unsigned int i, p;
2970         int res;
2971
2972         if (sscanf(buf, "%x %x\n", &i, &p) != 2)
2973                 return -EINVAL;
2974         res = ddb_redirect(i, p);
2975         if (res < 0)
2976                 return res;
2977         dev_info(device, "redirect: %02x, %02x\n", i, p);
2978         return count;
2979 }
2980
2981 static ssize_t gap_show(struct device *device,
2982                         struct device_attribute *attr, char *buf)
2983 {
2984         struct ddb *dev = dev_get_drvdata(device);
2985         int num = attr->attr.name[3] - 0x30;
2986
2987         return sprintf(buf, "%d\n", dev->port[num].gap);
2988 }
2989
2990 static ssize_t gap_store(struct device *device, struct device_attribute *attr,
2991                          const char *buf, size_t count)
2992 {
2993         struct ddb *dev = dev_get_drvdata(device);
2994         int num = attr->attr.name[3] - 0x30;
2995         unsigned int val;
2996
2997         if (sscanf(buf, "%u\n", &val) != 1)
2998                 return -EINVAL;
2999         if (val > 128)
3000                 return -EINVAL;
3001         if (val == 128)
3002                 val = 0xffffffff;
3003         dev->port[num].gap = val;
3004         return count;
3005 }
3006
3007 static ssize_t version_show(struct device *device,
3008                             struct device_attribute *attr, char *buf)
3009 {
3010         struct ddb *dev = dev_get_drvdata(device);
3011
3012         return sprintf(buf, "%08x %08x\n",
3013                        dev->link[0].ids.hwid, dev->link[0].ids.regmapid);
3014 }
3015
3016 static ssize_t hwid_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.hwid);
3022 }
3023
3024 static ssize_t regmap_show(struct device *device,
3025                            struct device_attribute *attr, char *buf)
3026 {
3027         struct ddb *dev = dev_get_drvdata(device);
3028
3029         return sprintf(buf, "0x%08X\n", dev->link[0].ids.regmapid);
3030 }
3031
3032 static ssize_t fmode_show(struct device *device,
3033                           struct device_attribute *attr, char *buf)
3034 {
3035         int num = attr->attr.name[5] - 0x30;
3036         struct ddb *dev = dev_get_drvdata(device);
3037
3038         return sprintf(buf, "%u\n", dev->link[num].lnb.fmode);
3039 }
3040
3041 static ssize_t devid_show(struct device *device,
3042                           struct device_attribute *attr, char *buf)
3043 {
3044         int num = attr->attr.name[5] - 0x30;
3045         struct ddb *dev = dev_get_drvdata(device);
3046
3047         return sprintf(buf, "%08x\n", dev->link[num].ids.devid);
3048 }
3049
3050 static ssize_t fmode_store(struct device *device, struct device_attribute *attr,
3051                            const char *buf, size_t count)
3052 {
3053         struct ddb *dev = dev_get_drvdata(device);
3054         int num = attr->attr.name[5] - 0x30;
3055         unsigned int val;
3056
3057         if (sscanf(buf, "%u\n", &val) != 1)
3058                 return -EINVAL;
3059         if (val > 3)
3060                 return -EINVAL;
3061         ddb_lnb_init_fmode(dev, &dev->link[num], val);
3062         return count;
3063 }
3064
3065 static struct device_attribute ddb_attrs[] = {
3066         __ATTR_RO(version),
3067         __ATTR_RO(ports),
3068         __ATTR_RO(ts_irq),
3069         __ATTR_RO(i2c_irq),
3070         __ATTR(gap0, 0664, gap_show, gap_store),
3071         __ATTR(gap1, 0664, gap_show, gap_store),
3072         __ATTR(gap2, 0664, gap_show, gap_store),
3073         __ATTR(gap3, 0664, gap_show, gap_store),
3074         __ATTR(fmode0, 0664, fmode_show, fmode_store),
3075         __ATTR(fmode1, 0664, fmode_show, fmode_store),
3076         __ATTR(fmode2, 0664, fmode_show, fmode_store),
3077         __ATTR(fmode3, 0664, fmode_show, fmode_store),
3078         __ATTR_MRO(devid0, devid_show),
3079         __ATTR_MRO(devid1, devid_show),
3080         __ATTR_MRO(devid2, devid_show),
3081         __ATTR_MRO(devid3, devid_show),
3082         __ATTR_RO(hwid),
3083         __ATTR_RO(regmap),
3084         __ATTR(redirect, 0664, redirect_show, redirect_store),
3085         __ATTR_MRO(snr,  bsnr_show),
3086         __ATTR_RO(bpsnr),
3087         __ATTR_NULL,
3088 };
3089
3090 static struct device_attribute ddb_attrs_temp[] = {
3091         __ATTR_RO(temp),
3092 };
3093
3094 static struct device_attribute ddb_attrs_fan[] = {
3095         __ATTR(fan, 0664, fan_show, fan_store),
3096 };
3097
3098 static struct device_attribute ddb_attrs_snr[] = {
3099         __ATTR_MRO(snr0, snr_show),
3100         __ATTR_MRO(snr1, snr_show),
3101         __ATTR_MRO(snr2, snr_show),
3102         __ATTR_MRO(snr3, snr_show),
3103 };
3104
3105 static struct device_attribute ddb_attrs_ctemp[] = {
3106         __ATTR_MRO(temp0, ctemp_show),
3107         __ATTR_MRO(temp1, ctemp_show),
3108         __ATTR_MRO(temp2, ctemp_show),
3109         __ATTR_MRO(temp3, ctemp_show),
3110 };
3111
3112 static struct device_attribute ddb_attrs_led[] = {
3113         __ATTR(led0, 0664, led_show, led_store),
3114         __ATTR(led1, 0664, led_show, led_store),
3115         __ATTR(led2, 0664, led_show, led_store),
3116         __ATTR(led3, 0664, led_show, led_store),
3117 };
3118
3119 static struct device_attribute ddb_attrs_fanspeed[] = {
3120         __ATTR_MRO(fanspeed0, fanspeed_show),
3121         __ATTR_MRO(fanspeed1, fanspeed_show),
3122         __ATTR_MRO(fanspeed2, fanspeed_show),
3123         __ATTR_MRO(fanspeed3, fanspeed_show),
3124 };
3125
3126 static struct class ddb_class = {
3127         .name           = "ddbridge",
3128         .owner          = THIS_MODULE,
3129         .devnode        = ddb_devnode,
3130 };
3131
3132 static int ddb_class_create(void)
3133 {
3134         ddb_major = register_chrdev(0, DDB_NAME, &ddb_fops);
3135         if (ddb_major < 0)
3136                 return ddb_major;
3137         if (class_register(&ddb_class) < 0)
3138                 return -1;
3139         return 0;
3140 }
3141
3142 static void ddb_class_destroy(void)
3143 {
3144         class_unregister(&ddb_class);
3145         unregister_chrdev(ddb_major, DDB_NAME);
3146 }
3147
3148 static void ddb_device_attrs_del(struct ddb *dev)
3149 {
3150         int i;
3151
3152         for (i = 0; i < 4; i++)
3153                 if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3154                         device_remove_file(dev->ddb_dev,
3155                                            &ddb_attrs_fanspeed[i]);
3156         for (i = 0; i < dev->link[0].info->temp_num; i++)
3157                 device_remove_file(dev->ddb_dev, &ddb_attrs_temp[i]);
3158         for (i = 0; i < dev->link[0].info->fan_num; i++)
3159                 device_remove_file(dev->ddb_dev, &ddb_attrs_fan[i]);
3160         for (i = 0; i < dev->i2c_num && i < 4; i++) {
3161                 if (dev->link[0].info->led_num)
3162                         device_remove_file(dev->ddb_dev, &ddb_attrs_led[i]);
3163                 device_remove_file(dev->ddb_dev, &ddb_attrs_snr[i]);
3164                 device_remove_file(dev->ddb_dev, &ddb_attrs_ctemp[i]);
3165         }
3166         for (i = 0; ddb_attrs[i].attr.name; i++)
3167                 device_remove_file(dev->ddb_dev, &ddb_attrs[i]);
3168 }
3169
3170 static int ddb_device_attrs_add(struct ddb *dev)
3171 {
3172         int i;
3173
3174         for (i = 0; ddb_attrs[i].attr.name; i++)
3175                 if (device_create_file(dev->ddb_dev, &ddb_attrs[i]))
3176                         goto fail;
3177         for (i = 0; i < dev->link[0].info->temp_num; i++)
3178                 if (device_create_file(dev->ddb_dev, &ddb_attrs_temp[i]))
3179                         goto fail;
3180         for (i = 0; i < dev->link[0].info->fan_num; i++)
3181                 if (device_create_file(dev->ddb_dev, &ddb_attrs_fan[i]))
3182                         goto fail;
3183         for (i = 0; (i < dev->i2c_num) && (i < 4); i++) {
3184                 if (device_create_file(dev->ddb_dev, &ddb_attrs_snr[i]))
3185                         goto fail;
3186                 if (device_create_file(dev->ddb_dev, &ddb_attrs_ctemp[i]))
3187                         goto fail;
3188                 if (dev->link[0].info->led_num)
3189                         if (device_create_file(dev->ddb_dev,
3190                                                &ddb_attrs_led[i]))
3191                                 goto fail;
3192         }
3193         for (i = 0; i < 4; i++)
3194                 if (dev->link[i].info && dev->link[i].info->tempmon_irq)
3195                         if (device_create_file(dev->ddb_dev,
3196                                                &ddb_attrs_fanspeed[i]))
3197                                 goto fail;
3198         return 0;
3199 fail:
3200         return -1;
3201 }
3202
3203 int ddb_device_create(struct ddb *dev)
3204 {
3205         int res = 0;
3206
3207         if (ddb_num == DDB_MAX_ADAPTER)
3208                 return -ENOMEM;
3209         mutex_lock(&ddb_mutex);
3210         dev->nr = ddb_num;
3211         ddbs[dev->nr] = dev;
3212         dev->ddb_dev = device_create(&ddb_class, dev->dev,
3213                                      MKDEV(ddb_major, dev->nr),
3214                                      dev, "ddbridge%d", dev->nr);
3215         if (IS_ERR(dev->ddb_dev)) {
3216                 res = PTR_ERR(dev->ddb_dev);
3217                 dev_info(dev->dev, "Could not create ddbridge%d\n", dev->nr);
3218                 goto fail;
3219         }
3220         res = ddb_device_attrs_add(dev);
3221         if (res) {
3222                 ddb_device_attrs_del(dev);
3223                 device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3224                 ddbs[dev->nr] = NULL;
3225                 dev->ddb_dev = ERR_PTR(-ENODEV);
3226         } else {
3227                 ddb_num++;
3228         }
3229 fail:
3230         mutex_unlock(&ddb_mutex);
3231         return res;
3232 }
3233
3234 void ddb_device_destroy(struct ddb *dev)
3235 {
3236         if (IS_ERR(dev->ddb_dev))
3237                 return;
3238         ddb_device_attrs_del(dev);
3239         device_destroy(&ddb_class, MKDEV(ddb_major, dev->nr));
3240 }
3241
3242 /****************************************************************************/
3243 /****************************************************************************/
3244 /****************************************************************************/
3245
3246 static void tempmon_setfan(struct ddb_link *link)
3247 {
3248         u32 temp, temp2, pwm;
3249
3250         if ((ddblreadl(link, TEMPMON_CONTROL) &
3251             TEMPMON_CONTROL_OVERTEMP) != 0) {
3252                 dev_info(link->dev->dev, "Over temperature condition\n");
3253                 link->overtemperature_error = 1;
3254         }
3255         temp  = (ddblreadl(link, TEMPMON_SENSOR0) >> 8) & 0xFF;
3256         if (temp & 0x80)
3257                 temp = 0;
3258         temp2  = (ddblreadl(link, TEMPMON_SENSOR1) >> 8) & 0xFF;
3259         if (temp2 & 0x80)
3260                 temp2 = 0;
3261         if (temp2 > temp)
3262                 temp = temp2;
3263
3264         pwm = (ddblreadl(link, TEMPMON_FANCONTROL) >> 8) & 0x0F;
3265         if (pwm > 10)
3266                 pwm = 10;
3267
3268         if (temp >= link->temp_tab[pwm]) {
3269                 while (pwm < 10 && temp >= link->temp_tab[pwm + 1])
3270                         pwm += 1;
3271         } else {
3272                 while (pwm > 1 && temp < link->temp_tab[pwm - 2])
3273                         pwm -= 1;
3274         }
3275         ddblwritel(link, (pwm << 8), TEMPMON_FANCONTROL);
3276 }
3277
3278 static void temp_handler(void *data)
3279 {
3280         struct ddb_link *link = (struct ddb_link *)data;
3281
3282         spin_lock(&link->temp_lock);
3283         tempmon_setfan(link);
3284         spin_unlock(&link->temp_lock);
3285 }
3286
3287 static int tempmon_init(struct ddb_link *link, int first_time)
3288 {
3289         struct ddb *dev = link->dev;
3290         int status = 0;
3291         u32 l = link->nr;
3292
3293         spin_lock_irq(&link->temp_lock);
3294         if (first_time) {
3295                 static u8 temperature_table[11] = {
3296                         30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80 };
3297
3298                 memcpy(link->temp_tab, temperature_table,
3299                        sizeof(temperature_table));
3300         }
3301         ddb_irq_set(dev, l, link->info->tempmon_irq, temp_handler, link);
3302         ddblwritel(link, (TEMPMON_CONTROL_OVERTEMP | TEMPMON_CONTROL_AUTOSCAN |
3303                           TEMPMON_CONTROL_INTENABLE),
3304                    TEMPMON_CONTROL);
3305         ddblwritel(link, (3 << 8), TEMPMON_FANCONTROL);
3306
3307         link->overtemperature_error =
3308                 ((ddblreadl(link, TEMPMON_CONTROL) &
3309                         TEMPMON_CONTROL_OVERTEMP) != 0);
3310         if (link->overtemperature_error) {
3311                 dev_info(link->dev->dev, "Over temperature condition\n");
3312                 status = -1;
3313         }
3314         tempmon_setfan(link);
3315         spin_unlock_irq(&link->temp_lock);
3316         return status;
3317 }
3318
3319 static int ddb_init_tempmon(struct ddb_link *link)
3320 {
3321         const struct ddb_info *info = link->info;
3322
3323         if (!info->tempmon_irq)
3324                 return 0;
3325         if (info->type == DDB_OCTOPUS_MAX_CT)
3326                 if (link->ids.regmapid < 0x00010002)
3327                         return 0;
3328         spin_lock_init(&link->temp_lock);
3329         dev_dbg(link->dev->dev, "init_tempmon\n");
3330         return tempmon_init(link, 1);
3331 }
3332
3333 /****************************************************************************/
3334 /****************************************************************************/
3335 /****************************************************************************/
3336
3337 static int ddb_init_boards(struct ddb *dev)
3338 {
3339         const struct ddb_info *info;
3340         struct ddb_link *link;
3341         u32 l;
3342
3343         for (l = 0; l < DDB_MAX_LINK; l++) {
3344                 link = &dev->link[l];
3345                 info = link->info;
3346
3347                 if (!info)
3348                         continue;
3349                 if (info->board_control) {
3350                         ddbwritel(dev, 0, DDB_LINK_TAG(l) | BOARD_CONTROL);
3351                         msleep(100);
3352                         ddbwritel(dev, info->board_control_2,
3353                                   DDB_LINK_TAG(l) | BOARD_CONTROL);
3354                         usleep_range(2000, 3000);
3355                         ddbwritel(dev,
3356                                   info->board_control_2 | info->board_control,
3357                                   DDB_LINK_TAG(l) | BOARD_CONTROL);
3358                         usleep_range(2000, 3000);
3359                 }
3360                 ddb_init_tempmon(link);
3361         }
3362         return 0;
3363 }
3364
3365 int ddb_init(struct ddb *dev)
3366 {
3367         mutex_init(&dev->link[0].lnb.lock);
3368         mutex_init(&dev->link[0].flash_mutex);
3369         if (no_init) {
3370                 ddb_device_create(dev);
3371                 return 0;
3372         }
3373
3374         ddb_init_boards(dev);
3375
3376         if (ddb_i2c_init(dev) < 0)
3377                 goto fail1;
3378         ddb_ports_init(dev);
3379         if (ddb_buffers_alloc(dev) < 0) {
3380                 dev_info(dev->dev, "Could not allocate buffer memory\n");
3381                 goto fail2;
3382         }
3383         if (ddb_ports_attach(dev) < 0)
3384                 goto fail3;
3385
3386         ddb_device_create(dev);
3387
3388         if (dev->link[0].info->fan_num) {
3389                 ddbwritel(dev, 1, GPIO_DIRECTION);
3390                 ddbwritel(dev, 1, GPIO_OUTPUT);
3391         }
3392         return 0;
3393
3394 fail3:
3395         dev_err(dev->dev, "fail3\n");
3396         ddb_ports_detach(dev);
3397         ddb_buffers_free(dev);
3398 fail2:
3399         dev_err(dev->dev, "fail2\n");
3400         ddb_ports_release(dev);
3401         ddb_i2c_release(dev);
3402 fail1:
3403         dev_err(dev->dev, "fail1\n");
3404         return -1;
3405 }
3406
3407 void ddb_unmap(struct ddb *dev)
3408 {
3409         if (dev->regs)
3410                 iounmap(dev->regs);
3411         vfree(dev);
3412 }
3413
3414 int ddb_exit_ddbridge(int stage, int error)
3415 {
3416         switch (stage) {
3417         default:
3418         case 2:
3419                 destroy_workqueue(ddb_wq);
3420                 /* fall-through */
3421         case 1:
3422                 ddb_class_destroy();
3423                 break;
3424         }
3425
3426         return error;
3427 }
3428
3429 int ddb_init_ddbridge(void)
3430 {
3431         if (dma_buf_num < 8)
3432                 dma_buf_num = 8;
3433         if (dma_buf_num > 32)
3434                 dma_buf_num = 32;
3435         if (dma_buf_size < 1)
3436                 dma_buf_size = 1;
3437         if (dma_buf_size > 43)
3438                 dma_buf_size = 43;
3439
3440         if (ddb_class_create() < 0)
3441                 return -1;
3442         ddb_wq = alloc_workqueue("ddbridge", 0, 0);
3443         if (!ddb_wq)
3444                 return ddb_exit_ddbridge(1, -1);
3445
3446         return 0;
3447 }