sys/dev/video/cxm/cxm_msp34xxx.c

   1 /*
   2  * Copyright (c) 2003, 2004, 2005
   3  *      John Wehle <john@feith.com>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by John Wehle.
  16  * 4. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Audio decoder routines for the Conexant MPEG-2 Codec driver.
  34  *
  35  * Ideally these routines should be implemented as a separate
  36  * driver which has a generic audio decoder interface so that
  37  * it's not necessary for each multimedia driver to re-invent
  38  * the wheel.
  39  */
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/conf.h>
  44 #include <sys/uio.h>
  45 #include <sys/kernel.h>
  46 #include <sys/poll.h>
  47 #include <sys/select.h>
  48 #include <sys/resource.h>
  49 #include <sys/bus.h>
  50 #include <sys/rman.h>
  51
  52 #include <machine/clock.h>
  53
  54 #include <dev/video/cxm/cxm.h>
  55
  56 #include <bus/iicbus/iiconf.h>
  57 #include <bus/iicbus/iicbus.h>
  58
  59 #include "iicbb_if.h"
  60
  61
  62 static const struct cxm_msp_command
  63 msp34x5G_init = {
  64         5,
  65         {
  66                 /* Enable Automatic Sound Select */
  67                 { CXM_MSP3400C_DEM, 0x0030, { 0x20, 0x03 } },
  68                 /* SCART Prescale = 0 dB */
  69                 { CXM_MSP3400C_DFP, 0x000d, { 0x19, 0x00 } },
  70                 /* FM / AM Prescale = 100 Khz and FM Matrix = Sound A Mono  */
  71                 { CXM_MSP3400C_DFP, 0x000e, { 0x24, 0x03 } },
  72                 /* NICAM Prescale = 9 dB  */
  73                 { CXM_MSP3400C_DFP, 0x0010, { 0x5a, 0x00 } },
  74                 /* Enable Automatic Standard Select */
  75                 { CXM_MSP3400C_DEM, 0x0020, { 0x00, 0x01 } },
  76         }
  77 };
  78
  79 static const struct cxm_msp_command
  80 msp34x5G_select_tuner = {
  81         3,
  82         {
  83                 /* Loudspeaker Source = demodulator (St or A), Matrix = St */
  84                 { CXM_MSP3400C_DFP, 0x0008, { 0x03, 0x20 } },
  85                 /* SCART1_L/R Source = demodulator (St or A), Matrix = St */
  86                 { CXM_MSP3400C_DFP, 0x000a, { 0x03, 0x20 } },
  87                 /* DSP In = mute, SC1_OUT_L/R Source = SCART1_L/R */
  88                 { CXM_MSP3400C_DFP, 0x0013, { 0x0f, 0x20 } }
  89         }
  90 };
  91
  92 static const struct cxm_msp_command
  93 msp34x5D_init = {
  94         4,
  95         {
  96                 /* Enable Automatic NICAM-FM/AM Switching */
  97                 { CXM_MSP3400C_DEM, 0x0021, { 0x00, 0x01 } },
  98                 /* SCART Prescale = 0 dB */
  99                 { CXM_MSP3400C_DFP, 0x000d, { 0x19, 0x00 } },
 100                 /* NICAM Prescale = 9 dB  */
 101                 { CXM_MSP3400C_DFP, 0x0010, { 0x5a, 0x00 } },
 102                 /* Enable Automatic Standard Select */
 103                 { CXM_MSP3400C_DEM, 0x0020, { 0x00, 0x01 } },
 104         }
 105 };
 106
 107 static const struct cxm_msp_command
 108 msp34x5D_select_tuner = {
 109         5,
 110         {
 111                 /* Loudspeaker Source = demodulator (NICAM), Matrix = St */
 112                 { CXM_MSP3400C_DFP, 0x0008, { 0x01, 0x20 } },
 113                 /* SCART1_L/R Source = demodulator (NICAM), Matrix = St */
 114                 { CXM_MSP3400C_DFP, 0x000a, { 0x01, 0x20 } },
 115                 /* FM / AM Prescale = 100 Khz and FM Matrix = No Matrix  */
 116                 { CXM_MSP3400C_DFP, 0x000e, { 0x24, 0x00 } },
 117                 /* FM Deemphasis = 50 us */
 118                 { CXM_MSP3400C_DFP, 0x000f, { 0x00, 0x00 } },
 119                 /* DSP In = mute, SC1_OUT_L/R Source = SCART1_L/R */
 120                 { CXM_MSP3400C_DFP, 0x0013, { 0x0f, 0x20 } }
 121         }
 122 };
 123
 124 static const struct cxm_msp_command
 125 msp34xxx_mute = {
 126         2,
 127         {
 128                 /* Loudspeaker volume = mute */
 129                 { CXM_MSP3400C_DFP, 0x0000, { 0x00, 0x00 } },
 130                 /* SC1_OUT_L/R volume = mute */
 131                 { CXM_MSP3400C_DFP, 0x0007, { 0x00, 0x01 } }
 132         }
 133 };
 134
 135 static const struct cxm_msp_command
 136 msp34xxx_unmute = {
 137         2,
 138         {
 139                 /* Loudspeaker volume = 0 db */
 140                 { CXM_MSP3400C_DFP, 0x0000, { 0x73, 0x00 } },
 141                 /* SC1_OUT_L/R volume = 0 db */
 142                 { CXM_MSP3400C_DFP, 0x0007, { 0x73, 0x01 } }
 143         }
 144 };
 145
 146 static const struct cxm_msp_command
 147 msp34xxx_select_fm = {
 148         3,
 149         {
 150                 /* Loudspeaker Source = SCART, Matrix = STEREO */
 151                 { CXM_MSP3400C_DFP, 0x0008, { 0x02, 0x20 } },
 152                 /* SCART1_L/R Source = SCART, Matrix = STEREO */
 153                 { CXM_MSP3400C_DFP, 0x000a, { 0x02, 0x20 } },
 154                 /* DSP In = SC2_IN_L/R, SC1_OUT_L/R Source = SCART1_L/R */
 155                 { CXM_MSP3400C_DFP, 0x0013, { 0x0e, 0x00 } }
 156         }
 157 };
 158
 159 static const struct cxm_msp_command
 160 msp34xxx_select_line_in = {
 161         3,
 162         {
 163                 /* Loudspeaker Source = SCART, Matrix = STEREO */
 164                 { CXM_MSP3400C_DFP, 0x0008, { 0x02, 0x20 } },
 165                 /* SCART1_L/R Source = SCART, Matrix = STEREO */
 166                 { CXM_MSP3400C_DFP, 0x000a, { 0x02, 0x20 } },
 167                 /* DSP In = SC1_IN_L/R, SC1_OUT_L/R Source = SCART1_L/R */
 168                 { CXM_MSP3400C_DFP, 0x0013, { 0x0c, 0x00 } }
 169         }
 170 };
 171
 172
 173 /* Reset the MSP or DPL chip */
 174 static int
 175 cxm_msp_dpl_reset(device_t iicbus, int i2c_addr)
 176 {
 177         unsigned char msg[3];
 178         int sent;
 179
 180         /* put into reset mode */
 181         msg[0] = 0x00;
 182         msg[1] = 0x80;
 183         msg[2] = 0x00;
 184
 185         if (iicbus_start(iicbus, i2c_addr, CXM_I2C_TIMEOUT) != 0)
 186                 return -1;
 187
 188         if (iicbus_write(iicbus, msg, sizeof(msg), &sent, CXM_I2C_TIMEOUT) != 0
 189             || sent != sizeof(msg))
 190                 goto fail;
 191
 192         iicbus_stop(iicbus);
 193
 194         /* put back to operational mode */
 195         msg[0] = 0x00;
 196         msg[1] = 0x00;
 197         msg[2] = 0x00;
 198
 199         if (iicbus_start(iicbus, i2c_addr, CXM_I2C_TIMEOUT) != 0)
 200                 return -1;
 201
 202         if (iicbus_write(iicbus, msg, sizeof(msg), &sent, CXM_I2C_TIMEOUT) != 0
 203             || sent != sizeof(msg))
 204                 goto fail;
 205
 206         iicbus_stop(iicbus);
 207
 208         return 0;
 209
 210 fail:
 211         iicbus_stop(iicbus);
 212         return -1;
 213 }
 214
 215
 216 /* Read from the MSP or DPL registers */
 217 static int
 218 cxm_msp_dpl_read(device_t iicbus, int i2c_addr,
 219                   unsigned char dev, unsigned int addr,
 220                   char *buf, int len)
 221 {
 222         unsigned char msg[3];
 223         int received;
 224         int sent;
 225
 226         msg[0] = (unsigned char)(dev + 1);
 227         msg[1] = (unsigned char)(addr >> 8);
 228         msg[2] = (unsigned char)addr;
 229
 230         if (iicbus_start(iicbus, i2c_addr, CXM_I2C_TIMEOUT) != 0)
 231                 return -1;
 232
 233         if (iicbus_write(iicbus, msg, sizeof(msg), &sent, CXM_I2C_TIMEOUT) != 0
 234             || sent != sizeof(msg))
 235                 goto fail;
 236
 237         if (iicbus_repeated_start(iicbus, i2c_addr + 1, CXM_I2C_TIMEOUT) != 0)
 238                 goto fail;
 239
 240         if (iicbus_read(iicbus, buf, len, &received, IIC_LAST_READ, 0) != 0)
 241                 goto fail;
 242
 243         iicbus_stop(iicbus);
 244
 245         return received;
 246
 247 fail:
 248         iicbus_stop(iicbus);
 249         return -1;
 250 }
 251
 252
 253 /* Write to the MSP or DPL registers */
 254 static int
 255 cxm_msp_dpl_write(device_t iicbus, int i2c_addr,
 256                    unsigned char dev, unsigned int addr,
 257                    const char *buf, int len)
 258 {
 259         unsigned char msg[3];
 260         int sent;
 261
 262         msg[0] = (unsigned char)dev;
 263         msg[1] = (unsigned char)(addr >> 8);
 264         msg[2] = (unsigned char)addr;
 265
 266         if (iicbus_start(iicbus, i2c_addr, CXM_I2C_TIMEOUT) != 0)
 267                 return -1;
 268
 269         if (iicbus_write(iicbus, msg, sizeof(msg), &sent, CXM_I2C_TIMEOUT) != 0
 270             || sent != sizeof(msg))
 271                 goto fail;
 272
 273         if (iicbus_write(iicbus, buf, len, &sent, CXM_I2C_TIMEOUT) != 0)
 274                 goto fail;
 275
 276         iicbus_stop(iicbus);
 277
 278         return sent;
 279
 280 fail:
 281         iicbus_stop(iicbus);
 282         return -1;
 283 }
 284
 285
 286 int
 287 cxm_msp_init(struct cxm_softc *sc)
 288 {
 289         unsigned char rev1[2];
 290         unsigned char rev2[2];
 291         unsigned int i;
 292         unsigned int nsettings;
 293         const struct cxm_msp_setting *settings;
 294
 295         if (cxm_msp_dpl_reset (sc->iicbus, CXM_I2C_MSP3400) < 0)
 296                 return -1;
 297
 298         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 299                              0x001e, rev1, sizeof(rev1)) != sizeof(rev1))
 300                 return -1;
 301
 302         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 303                              0x001f, rev2, sizeof(rev2)) != sizeof(rev2))
 304                 return -1;
 305
 306         ksnprintf(sc->msp_name, sizeof(sc->msp_name), "%c4%02d%c-%c%d",
 307                  ((rev1[1] >> 4) & 0x0f) + '3', rev2[0],
 308                  (rev1[1] & 0x0f) + '@', rev1[0] + '@', rev2[1] & 0x1f);
 309
 310         /*
 311          * MSP 34x5D, 34x5G, and MSP 44x8G are the
 312          * only audio decoders currently supported.
 313          */
 314
 315         if (strncmp(&sc->msp_name[0], "34", 2) == 0
 316             && strncmp(&sc->msp_name[3], "5D", 2) == 0)
 317           ;
 318         else if (strncmp(&sc->msp_name[0], "34", 2) == 0
 319                  && strncmp(&sc->msp_name[3], "5G", 2) == 0)
 320           ;
 321         else if (strncmp(&sc->msp_name[0], "44", 2) == 0
 322                  && strncmp(&sc->msp_name[3], "8G", 2) == 0)
 323           ;
 324         else {
 325                 device_printf(sc->dev, "unknown audio decoder MSP%s\n",
 326                     sc->msp_name);
 327                 return -1;
 328         }
 329
 330         nsettings = msp34x5G_init.nsettings;
 331         settings = msp34x5G_init.settings;
 332         if (sc->msp_name[4] == 'D') {
 333                 nsettings = msp34x5D_init.nsettings;
 334                 settings = msp34x5D_init.settings;
 335           }
 336
 337         for (i = 0; i < nsettings; i++)
 338                 if (cxm_msp_dpl_write(sc->iicbus, CXM_I2C_MSP3400,
 339                                       settings[i].dev, settings[i].addr,
 340                                       settings[i].value,
 341                                       sizeof(settings[i].value))
 342                     != sizeof(settings[i].value))
 343                         return -1;
 344
 345         if (cxm_msp_select_source(sc, cxm_tuner_source) < 0)
 346                 return -1;
 347
 348         device_printf(sc->dev, "MSP%s audio decoder\n", sc->msp_name);
 349
 350         return 0;
 351 }
 352
 353
 354 int
 355 cxm_msp_mute(struct cxm_softc *sc)
 356 {
 357         unsigned int i;
 358         unsigned int nsettings;
 359         const struct cxm_msp_setting *settings;
 360
 361         nsettings = msp34xxx_mute.nsettings;
 362         settings = msp34xxx_mute.settings;
 363
 364         for (i = 0; i < nsettings; i++)
 365                 if (cxm_msp_dpl_write(sc->iicbus, CXM_I2C_MSP3400,
 366                                       settings[i].dev, settings[i].addr,
 367                                       settings[i].value,
 368                                       sizeof(settings[i].value))
 369                     != sizeof(settings[i].value))
 370                         return -1;
 371
 372         return 0;
 373 }
 374
 375
 376 int
 377 cxm_msp_unmute(struct cxm_softc *sc)
 378 {
 379         unsigned int i;
 380         unsigned int nsettings;
 381         const struct cxm_msp_setting *settings;
 382
 383         nsettings = msp34xxx_unmute.nsettings;
 384         settings = msp34xxx_unmute.settings;
 385
 386         for (i = 0; i < nsettings; i++)
 387                 if (cxm_msp_dpl_write(sc->iicbus, CXM_I2C_MSP3400,
 388                                       settings[i].dev, settings[i].addr,
 389                                       settings[i].value,
 390                                       sizeof(settings[i].value))
 391                     != sizeof(settings[i].value))
 392                         return -1;
 393
 394         return 0;
 395 }
 396
 397
 398 int
 399 cxm_msp_is_muted(struct cxm_softc *sc)
 400 {
 401         unsigned char volume[2];
 402
 403         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 404                              0x0000, volume, sizeof(volume)) != sizeof(volume))
 405                 return -1;
 406
 407         return volume[0] == 0x00 || volume[0] == 0xff ? 1 : 0;
 408 }
 409
 410
 411 int
 412 cxm_msp_select_source(struct cxm_softc *sc, enum cxm_source source)
 413 {
 414         unsigned int i;
 415         unsigned int nsettings;
 416         const struct cxm_msp_setting *settings;
 417
 418         switch (source) {
 419         case cxm_fm_source:
 420                 nsettings = msp34xxx_select_fm.nsettings;
 421                 settings = msp34xxx_select_fm.settings;
 422                 break;
 423
 424         case cxm_line_in_source_composite:
 425         case cxm_line_in_source_svideo:
 426                 nsettings = msp34xxx_select_line_in.nsettings;
 427                 settings = msp34xxx_select_line_in.settings;
 428                 break;
 429
 430         case cxm_tuner_source:
 431                 nsettings = msp34x5G_select_tuner.nsettings;
 432                 settings = msp34x5G_select_tuner.settings;
 433                 if (sc->msp_name[4] == 'D') {
 434                         nsettings = msp34x5D_select_tuner.nsettings;
 435                         settings = msp34x5D_select_tuner.settings;
 436                   }
 437                 break;
 438
 439         default:
 440                 return -1;
 441         }
 442
 443         for (i = 0; i < nsettings; i++)
 444                 if (cxm_msp_dpl_write(sc->iicbus, CXM_I2C_MSP3400,
 445                                       settings[i].dev, settings[i].addr,
 446                                       settings[i].value,
 447                                       sizeof(settings[i].value))
 448                     != sizeof(settings[i].value))
 449                         return -1;
 450
 451         return 0;
 452 }
 453
 454
 455 enum cxm_source
 456 cxm_msp_selected_source(struct cxm_softc *sc)
 457 {
 458         unsigned char dsp[2];
 459         unsigned char source[2];
 460
 461         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 462                              0x0008, source, sizeof(source)) != sizeof(source))
 463                 return cxm_unknown_source;
 464
 465         switch (source[0]) {
 466         case 0: /* FM / AM mono signal */
 467         case 1: /* Stereo or A / B */
 468         case 3: /* Stereo or A */
 469         case 4: /* Stereo or B */
 470                 return cxm_tuner_source;
 471
 472         case 2: /* SCART */
 473                 break;
 474
 475         default:
 476                 return cxm_unknown_source;
 477         }
 478
 479         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 480                              0x0013, dsp, sizeof(dsp)) != sizeof(dsp))
 481                 return cxm_unknown_source;
 482
 483         if (dsp[1] & 0x20)
 484                 return cxm_unknown_source;
 485
 486         switch (dsp[0] & 0x03) {
 487         case 0:
 488                 return cxm_line_in_source_composite;
 489
 490         case 2:
 491                 return cxm_fm_source;
 492
 493         default:
 494                  return cxm_unknown_source;
 495         }
 496 }
 497
 498
 499 int
 500 cxm_msp_autodetect_standard(struct cxm_softc *sc)
 501 {
 502         unsigned int i;
 503         int locked;
 504         unsigned int nsettings;
 505         const struct cxm_msp_setting *settings;
 506
 507         switch (cxm_msp_selected_source(sc)) {
 508         case cxm_tuner_source:
 509                 break;
 510
 511         case cxm_fm_source:
 512         case cxm_line_in_source_composite:
 513         case cxm_line_in_source_svideo:
 514                 return 1;
 515
 516         default:
 517                 return -1;
 518         }
 519
 520         /*
 521          * Section 3.3.2.2 of the data sheet states:
 522          *
 523          *   A general refresh of the STANDARD SELECT
 524          *   register is not allowed.
 525          */
 526
 527         if (cxm_msp_dpl_reset (sc->iicbus, CXM_I2C_MSP3400) < 0)
 528                 return -1;
 529
 530         nsettings = msp34x5G_init.nsettings;
 531         settings = msp34x5G_init.settings;
 532         if (sc->msp_name[4] == 'D') {
 533                 nsettings = msp34x5D_init.nsettings;
 534                 settings = msp34x5D_init.settings;
 535           }
 536
 537         for (i = 0; i < nsettings; i++)
 538                 if (cxm_msp_dpl_write(sc->iicbus, CXM_I2C_MSP3400,
 539                                       settings[i].dev, settings[i].addr,
 540                                       settings[i].value,
 541                                       sizeof(settings[i].value))
 542                     != sizeof(settings[i].value))
 543                         return -1;
 544
 545         locked = cxm_msp_wait_for_lock(sc);
 546
 547         if (cxm_msp_select_source(sc, cxm_tuner_source) < 0)
 548                 return -1;
 549
 550         return locked;
 551 }
 552
 553
 554 int
 555 cxm_msp_is_locked(struct cxm_softc *sc)
 556 {
 557         unsigned char source[2];
 558         unsigned char standard[2];
 559
 560         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DFP,
 561                              0x0008, source, sizeof(source)) != sizeof(source))
 562                 return -1;
 563
 564         switch (source[0]) {
 565         case 0: /* FM / AM mono signal */
 566         case 1: /* Stereo or A / B */
 567         case 3: /* Stereo or A */
 568         case 4: /* Stereo or B */
 569                 break;
 570
 571         default:
 572                 return 1;
 573         }
 574
 575         if (cxm_msp_dpl_read(sc->iicbus, CXM_I2C_MSP3400, CXM_MSP3400C_DEM,
 576                              0x007e, standard, sizeof(standard))
 577             != sizeof(standard))
 578                 return -1;
 579
 580         if (standard[0] >= 8 || (standard[0] == 0 && standard[1] == 0))
 581                 return 0;
 582
 583         return 1;
 584 }
 585
 586
 587 int
 588 cxm_msp_wait_for_lock(struct cxm_softc *sc)
 589 {
 590         unsigned int i;
 591
 592         /*
 593          * Section 3.3.2.1 of the data sheet states:
 594          *
 595          *   Within 0.5 s the detection and setup of the actual
 596          *   TV sound standard is performed.  The detected result
 597          *   can be read out of the STANDARD RESULT register by
 598          *   the control processor.
 599          */
 600
 601         for (i = 0; i < 10; i++) {
 602
 603                 /*
 604                  * The input may have just changed (prior to
 605                  * cxm_msp_wait_for_lock) so start with the
 606                  * delay to give the audio decoder a chance
 607                  * to update its status.
 608                  */
 609
 610                 tsleep(&sc->iicbus, 0, "audio", hz / 20);
 611
 612                 switch (cxm_msp_is_locked(sc)) {
 613                 case 1:
 614                         return 1;
 615
 616                 case 0:
 617                         break;
 618
 619                 default:
 620                         return -1;
 621                 }
 622         }
 623
 624         device_printf(sc->dev, "audio decoder failed to lock\n");
 625
 626         return 0;
 627 }