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

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