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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ddbridge-max.c: Digital Devices bridge MAX card support
   4  *
   5  * Copyright (C) 2010-2017 Digital Devices GmbH
   6  *                         Ralph Metzler <rjkm@metzlerbros.de>
   7  *                         Marcus Metzler <mocm@metzlerbros.de>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/delay.h>
  14 #include <linux/slab.h>
  15 #include <linux/poll.h>
  16 #include <linux/io.h>
  17 #include <linux/pci.h>
  18 #include <linux/pci_ids.h>
  19 #include <linux/timer.h>
  20 #include <linux/i2c.h>
  21 #include <linux/swab.h>
  22 #include <linux/vmalloc.h>
  23
  24 #include "ddbridge.h"
  25 #include "ddbridge-regs.h"
  26 #include "ddbridge-io.h"
  27 #include "ddbridge-mci.h"
  28
  29 #include "ddbridge-max.h"
  30 #include "mxl5xx.h"
  31
  32 /******************************************************************************/
  33
  34 /* MaxS4/8 related modparams */
  35 static int fmode;
  36 module_param(fmode, int, 0444);
  37 MODULE_PARM_DESC(fmode, "frontend emulation mode");
  38
  39 static int fmode_sat = -1;
  40 module_param(fmode_sat, int, 0444);
  41 MODULE_PARM_DESC(fmode_sat, "set frontend emulation mode sat");
  42
  43 static int old_quattro;
  44 module_param(old_quattro, int, 0444);
  45 MODULE_PARM_DESC(old_quattro, "old quattro LNB input order ");
  46
  47 /******************************************************************************/
  48
  49 static int lnb_command(struct ddb *dev, u32 link, u32 lnb, u32 cmd)
  50 {
  51         u32 c, v = 0, tag = DDB_LINK_TAG(link);
  52
  53         v = LNB_TONE & (dev->link[link].lnb.tone << (15 - lnb));
  54         ddbwritel(dev, cmd | v, tag | LNB_CONTROL(lnb));
  55         for (c = 0; c < 10; c++) {
  56                 v = ddbreadl(dev, tag | LNB_CONTROL(lnb));
  57                 if ((v & LNB_BUSY) == 0)
  58                         break;
  59                 msleep(20);
  60         }
  61         if (c == 10)
  62                 dev_info(dev->dev, "%s lnb = %08x  cmd = %08x\n",
  63                          __func__, lnb, cmd);
  64         return 0;
  65 }
  66
  67 static int max_send_master_cmd(struct dvb_frontend *fe,
  68                                struct dvb_diseqc_master_cmd *cmd)
  69 {
  70         struct ddb_input *input = fe->sec_priv;
  71         struct ddb_port *port = input->port;
  72         struct ddb *dev = port->dev;
  73         struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
  74         u32 tag = DDB_LINK_TAG(port->lnr);
  75         int i;
  76         u32 fmode = dev->link[port->lnr].lnb.fmode;
  77
  78         if (fmode == 2 || fmode == 1)
  79                 return 0;
  80         if (dvb->diseqc_send_master_cmd)
  81                 dvb->diseqc_send_master_cmd(fe, cmd);
  82
  83         mutex_lock(&dev->link[port->lnr].lnb.lock);
  84         ddbwritel(dev, 0, tag | LNB_BUF_LEVEL(dvb->input));
  85         for (i = 0; i < cmd->msg_len; i++)
  86                 ddbwritel(dev, cmd->msg[i], tag | LNB_BUF_WRITE(dvb->input));
  87         lnb_command(dev, port->lnr, dvb->input, LNB_CMD_DISEQC);
  88         mutex_unlock(&dev->link[port->lnr].lnb.lock);
  89         return 0;
  90 }
  91
  92 static int lnb_send_diseqc(struct ddb *dev, u32 link, u32 input,
  93                            struct dvb_diseqc_master_cmd *cmd)
  94 {
  95         u32 tag = DDB_LINK_TAG(link);
  96         int i;
  97
  98         ddbwritel(dev, 0, tag | LNB_BUF_LEVEL(input));
  99         for (i = 0; i < cmd->msg_len; i++)
 100                 ddbwritel(dev, cmd->msg[i], tag | LNB_BUF_WRITE(input));
 101         lnb_command(dev, link, input, LNB_CMD_DISEQC);
 102         return 0;
 103 }
 104
 105 static int lnb_set_sat(struct ddb *dev, u32 link, u32 input, u32 sat, u32 band,
 106                        u32 hor)
 107 {
 108         struct dvb_diseqc_master_cmd cmd = {
 109                 .msg = {0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00},
 110                 .msg_len = 4
 111         };
 112         cmd.msg[3] = 0xf0 | (((sat << 2) & 0x0c) | (band ? 1 : 0) |
 113                 (hor ? 2 : 0));
 114         return lnb_send_diseqc(dev, link, input, &cmd);
 115 }
 116
 117 static int lnb_set_tone(struct ddb *dev, u32 link, u32 input,
 118                         enum fe_sec_tone_mode tone)
 119 {
 120         int s = 0;
 121         u32 mask = (1ULL << input);
 122
 123         switch (tone) {
 124         case SEC_TONE_OFF:
 125                 if (!(dev->link[link].lnb.tone & mask))
 126                         return 0;
 127                 dev->link[link].lnb.tone &= ~(1ULL << input);
 128                 break;
 129         case SEC_TONE_ON:
 130                 if (dev->link[link].lnb.tone & mask)
 131                         return 0;
 132                 dev->link[link].lnb.tone |= (1ULL << input);
 133                 break;
 134         default:
 135                 s = -EINVAL;
 136                 break;
 137         }
 138         if (!s)
 139                 s = lnb_command(dev, link, input, LNB_CMD_NOP);
 140         return s;
 141 }
 142
 143 static int lnb_set_voltage(struct ddb *dev, u32 link, u32 input,
 144                            enum fe_sec_voltage voltage)
 145 {
 146         int s = 0;
 147
 148         if (dev->link[link].lnb.oldvoltage[input] == voltage)
 149                 return 0;
 150         switch (voltage) {
 151         case SEC_VOLTAGE_OFF:
 152                 if (dev->link[link].lnb.voltage[input])
 153                         return 0;
 154                 lnb_command(dev, link, input, LNB_CMD_OFF);
 155                 break;
 156         case SEC_VOLTAGE_13:
 157                 lnb_command(dev, link, input, LNB_CMD_LOW);
 158                 break;
 159         case SEC_VOLTAGE_18:
 160                 lnb_command(dev, link, input, LNB_CMD_HIGH);
 161                 break;
 162         default:
 163                 s = -EINVAL;
 164                 break;
 165         }
 166         dev->link[link].lnb.oldvoltage[input] = voltage;
 167         return s;
 168 }
 169
 170 static int max_set_input_unlocked(struct dvb_frontend *fe, int in)
 171 {
 172         struct ddb_input *input = fe->sec_priv;
 173         struct ddb_port *port = input->port;
 174         struct ddb *dev = port->dev;
 175         struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
 176         int res = 0;
 177
 178         if (in > 3)
 179                 return -EINVAL;
 180         if (dvb->input != in) {
 181                 u32 bit = (1ULL << input->nr);
 182                 u32 obit =
 183                         dev->link[port->lnr].lnb.voltage[dvb->input & 3] & bit;
 184
 185                 dev->link[port->lnr].lnb.voltage[dvb->input & 3] &= ~bit;
 186                 dvb->input = in;
 187                 dev->link[port->lnr].lnb.voltage[dvb->input & 3] |= obit;
 188         }
 189         res = dvb->set_input(fe, in);
 190         return res;
 191 }
 192
 193 static int max_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
 194 {
 195         struct ddb_input *input = fe->sec_priv;
 196         struct ddb_port *port = input->port;
 197         struct ddb *dev = port->dev;
 198         struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
 199         int tuner = 0;
 200         int res = 0;
 201         u32 fmode = dev->link[port->lnr].lnb.fmode;
 202
 203         mutex_lock(&dev->link[port->lnr].lnb.lock);
 204         dvb->tone = tone;
 205         switch (fmode) {
 206         default:
 207         case 0:
 208         case 3:
 209                 res = lnb_set_tone(dev, port->lnr, dvb->input, tone);
 210                 break;
 211         case 1:
 212         case 2:
 213                 if (old_quattro) {
 214                         if (dvb->tone == SEC_TONE_ON)
 215                                 tuner |= 2;
 216                         if (dvb->voltage == SEC_VOLTAGE_18)
 217                                 tuner |= 1;
 218                 } else {
 219                         if (dvb->tone == SEC_TONE_ON)
 220                                 tuner |= 1;
 221                         if (dvb->voltage == SEC_VOLTAGE_18)
 222                                 tuner |= 2;
 223                 }
 224                 res = max_set_input_unlocked(fe, tuner);
 225                 break;
 226         }
 227         mutex_unlock(&dev->link[port->lnr].lnb.lock);
 228         return res;
 229 }
 230
 231 static int max_set_voltage(struct dvb_frontend *fe, enum fe_sec_voltage voltage)
 232 {
 233         struct ddb_input *input = fe->sec_priv;
 234         struct ddb_port *port = input->port;
 235         struct ddb *dev = port->dev;
 236         struct ddb_dvb *dvb = &port->dvb[input->nr & 1];
 237         int tuner = 0;
 238         u32 nv, ov = dev->link[port->lnr].lnb.voltages;
 239         int res = 0;
 240         u32 fmode = dev->link[port->lnr].lnb.fmode;
 241
 242         mutex_lock(&dev->link[port->lnr].lnb.lock);
 243         dvb->voltage = voltage;
 244
 245         switch (fmode) {
 246         case 3:
 247         default:
 248         case 0:
 249                 if (fmode == 3)
 250                         max_set_input_unlocked(fe, 0);
 251                 if (voltage == SEC_VOLTAGE_OFF)
 252                         dev->link[port->lnr].lnb.voltage[dvb->input] &=
 253                                 ~(1ULL << input->nr);
 254                 else
 255                         dev->link[port->lnr].lnb.voltage[dvb->input] |=
 256                                 (1ULL << input->nr);
 257
 258                 res = lnb_set_voltage(dev, port->lnr, dvb->input, voltage);
 259                 break;
 260         case 1:
 261         case 2:
 262                 if (voltage == SEC_VOLTAGE_OFF)
 263                         dev->link[port->lnr].lnb.voltages &=
 264                                 ~(1ULL << input->nr);
 265                 else
 266                         dev->link[port->lnr].lnb.voltages |=
 267                                 (1ULL << input->nr);
 268
 269                 nv = dev->link[port->lnr].lnb.voltages;
 270
 271                 if (old_quattro) {
 272                         if (dvb->tone == SEC_TONE_ON)
 273                                 tuner |= 2;
 274                         if (dvb->voltage == SEC_VOLTAGE_18)
 275                                 tuner |= 1;
 276                 } else {
 277                         if (dvb->tone == SEC_TONE_ON)
 278                                 tuner |= 1;
 279                         if (dvb->voltage == SEC_VOLTAGE_18)
 280                                 tuner |= 2;
 281                 }
 282                 res = max_set_input_unlocked(fe, tuner);
 283
 284                 if (nv != ov) {
 285                         if (nv) {
 286                                 lnb_set_voltage(
 287                                         dev, port->lnr,
 288                                         0, SEC_VOLTAGE_13);
 289                                 if (fmode == 1) {
 290                                         lnb_set_voltage(
 291                                                 dev, port->lnr,
 292                                                 0, SEC_VOLTAGE_13);
 293                                         if (old_quattro) {
 294                                                 lnb_set_voltage(
 295                                                         dev, port->lnr,
 296                                                         1, SEC_VOLTAGE_18);
 297                                                 lnb_set_voltage(
 298                                                         dev, port->lnr,
 299                                                         2, SEC_VOLTAGE_13);
 300                                         } else {
 301                                                 lnb_set_voltage(
 302                                                         dev, port->lnr,
 303                                                         1, SEC_VOLTAGE_13);
 304                                                 lnb_set_voltage(
 305                                                         dev, port->lnr,
 306                                                         2, SEC_VOLTAGE_18);
 307                                         }
 308                                         lnb_set_voltage(
 309                                                 dev, port->lnr,
 310                                                 3, SEC_VOLTAGE_18);
 311                                 }
 312                         } else {
 313                                 lnb_set_voltage(
 314                                         dev, port->lnr,
 315                                         0, SEC_VOLTAGE_OFF);
 316                                 if (fmode == 1) {
 317                                         lnb_set_voltage(
 318                                                 dev, port->lnr,
 319                                                 1, SEC_VOLTAGE_OFF);
 320                                         lnb_set_voltage(
 321                                                 dev, port->lnr,
 322                                                 2, SEC_VOLTAGE_OFF);
 323                                         lnb_set_voltage(
 324                                                 dev, port->lnr,
 325                                                 3, SEC_VOLTAGE_OFF);
 326                                 }
 327                         }
 328                 }
 329                 break;
 330         }
 331         mutex_unlock(&dev->link[port->lnr].lnb.lock);
 332         return res;
 333 }
 334
 335 static int max_enable_high_lnb_voltage(struct dvb_frontend *fe, long arg)
 336 {
 337         return 0;
 338 }
 339
 340 static int max_send_burst(struct dvb_frontend *fe, enum fe_sec_mini_cmd burst)
 341 {
 342         return 0;
 343 }
 344
 345 static int mxl_fw_read(void *priv, u8 *buf, u32 len)
 346 {
 347         struct ddb_link *link = priv;
 348         struct ddb *dev = link->dev;
 349
 350         dev_info(dev->dev, "Read mxl_fw from link %u\n", link->nr);
 351
 352         return ddbridge_flashread(dev, link->nr, buf, 0xc0000, len);
 353 }
 354
 355 int ddb_lnb_init_fmode(struct ddb *dev, struct ddb_link *link, u32 fm)
 356 {
 357         u32 l = link->nr;
 358
 359         if (link->lnb.fmode == fm)
 360                 return 0;
 361         dev_info(dev->dev, "Set fmode link %u = %u\n", l, fm);
 362         mutex_lock(&link->lnb.lock);
 363         if (fm == 2 || fm == 1) {
 364                 if (fmode_sat >= 0) {
 365                         lnb_set_sat(dev, l, 0, fmode_sat, 0, 0);
 366                         if (old_quattro) {
 367                                 lnb_set_sat(dev, l, 1, fmode_sat, 0, 1);
 368                                 lnb_set_sat(dev, l, 2, fmode_sat, 1, 0);
 369                         } else {
 370                                 lnb_set_sat(dev, l, 1, fmode_sat, 1, 0);
 371                                 lnb_set_sat(dev, l, 2, fmode_sat, 0, 1);
 372                         }
 373                         lnb_set_sat(dev, l, 3, fmode_sat, 1, 1);
 374                 }
 375                 lnb_set_tone(dev, l, 0, SEC_TONE_OFF);
 376                 if (old_quattro) {
 377                         lnb_set_tone(dev, l, 1, SEC_TONE_OFF);
 378                         lnb_set_tone(dev, l, 2, SEC_TONE_ON);
 379                 } else {
 380                         lnb_set_tone(dev, l, 1, SEC_TONE_ON);
 381                         lnb_set_tone(dev, l, 2, SEC_TONE_OFF);
 382                 }
 383                 lnb_set_tone(dev, l, 3, SEC_TONE_ON);
 384         }
 385         link->lnb.fmode = fm;
 386         mutex_unlock(&link->lnb.lock);
 387         return 0;
 388 }
 389
 390 static struct mxl5xx_cfg mxl5xx = {
 391         .adr      = 0x60,
 392         .type     = 0x01,
 393         .clk      = 27000000,
 394         .ts_clk   = 139,
 395         .cap      = 12,
 396         .fw_read  = mxl_fw_read,
 397 };
 398
 399 int ddb_fe_attach_mxl5xx(struct ddb_input *input)
 400 {
 401         struct ddb *dev = input->port->dev;
 402         struct i2c_adapter *i2c = &input->port->i2c->adap;
 403         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 404         struct ddb_port *port = input->port;
 405         struct ddb_link *link = &dev->link[port->lnr];
 406         struct mxl5xx_cfg cfg;
 407         int demod, tuner;
 408
 409         cfg = mxl5xx;
 410         cfg.fw_priv = link;
 411         dvb->set_input = NULL;
 412
 413         demod = input->nr;
 414         tuner = demod & 3;
 415         if (fmode == 3)
 416                 tuner = 0;
 417
 418         dvb->fe = dvb_attach(mxl5xx_attach, i2c, &cfg,
 419                              demod, tuner, &dvb->set_input);
 420
 421         if (!dvb->fe) {
 422                 dev_err(dev->dev, "No MXL5XX found!\n");
 423                 return -ENODEV;
 424         }
 425
 426         if (!dvb->set_input) {
 427                 dev_err(dev->dev, "No mxl5xx_set_input function pointer!\n");
 428                 return -ENODEV;
 429         }
 430
 431         if (input->nr < 4) {
 432                 lnb_command(dev, port->lnr, input->nr, LNB_CMD_INIT);
 433                 lnb_set_voltage(dev, port->lnr, input->nr, SEC_VOLTAGE_OFF);
 434         }
 435         ddb_lnb_init_fmode(dev, link, fmode);
 436
 437         dvb->fe->ops.set_voltage = max_set_voltage;
 438         dvb->fe->ops.enable_high_lnb_voltage = max_enable_high_lnb_voltage;
 439         dvb->fe->ops.set_tone = max_set_tone;
 440         dvb->diseqc_send_master_cmd = dvb->fe->ops.diseqc_send_master_cmd;
 441         dvb->fe->ops.diseqc_send_master_cmd = max_send_master_cmd;
 442         dvb->fe->ops.diseqc_send_burst = max_send_burst;
 443         dvb->fe->sec_priv = input;
 444         dvb->input = tuner;
 445         return 0;
 446 }
 447
 448 /******************************************************************************/
 449 /* MAX MCI related functions */
 450
 451 int ddb_fe_attach_mci(struct ddb_input *input, u32 type)
 452 {
 453         struct ddb *dev = input->port->dev;
 454         struct ddb_dvb *dvb = &input->port->dvb[input->nr & 1];
 455         struct ddb_port *port = input->port;
 456         struct ddb_link *link = &dev->link[port->lnr];
 457         int demod, tuner;
 458         struct mci_cfg cfg;
 459
 460         demod = input->nr;
 461         tuner = demod & 3;
 462         switch (type) {
 463         case DDB_TUNER_MCI_SX8:
 464                 cfg = ddb_max_sx8_cfg;
 465                 if (fmode == 3)
 466                         tuner = 0;
 467                 break;
 468         default:
 469                 return -EINVAL;
 470         }
 471         dvb->fe = ddb_mci_attach(input, &cfg, demod, &dvb->set_input);
 472         if (!dvb->fe) {
 473                 dev_err(dev->dev, "No MCI card found!\n");
 474                 return -ENODEV;
 475         }
 476         if (!dvb->set_input) {
 477                 dev_err(dev->dev, "No MCI set_input function pointer!\n");
 478                 return -ENODEV;
 479         }
 480         if (input->nr < 4) {
 481                 lnb_command(dev, port->lnr, input->nr, LNB_CMD_INIT);
 482                 lnb_set_voltage(dev, port->lnr, input->nr, SEC_VOLTAGE_OFF);
 483         }
 484         ddb_lnb_init_fmode(dev, link, fmode);
 485
 486         dvb->fe->ops.set_voltage = max_set_voltage;
 487         dvb->fe->ops.enable_high_lnb_voltage = max_enable_high_lnb_voltage;
 488         dvb->fe->ops.set_tone = max_set_tone;
 489         dvb->diseqc_send_master_cmd = dvb->fe->ops.diseqc_send_master_cmd;
 490         dvb->fe->ops.diseqc_send_master_cmd = max_send_master_cmd;
 491         dvb->fe->ops.diseqc_send_burst = max_send_burst;
 492         dvb->fe->sec_priv = input;
 493         dvb->input = tuner;
 494         return 0;
 495 }