[deb_xorg-server.git] / hw / xfree86 / i2c / msp3430.c

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <string.h>
#include <unistd.h>

#include "xf86.h"
#include "xf86i2c.h"
#include "msp3430.h"
#include "i2c_def.h"

#define CONTROL         0x00
#define WR_DEM          0x10
#define RD_DEM          0x11
#define WR_DSP          0x12
#define RD_DSP          0x13

void InitMSP34xxG(MSP3430Ptr m);
void InitMSP34x5D(MSP3430Ptr m);
void CheckModeMSP34x5D(MSP3430Ptr m);
static const char *MSP_getProductName(CARD16 product_id);
void mpause(int milliseconds);

#define __MSPDEBUG__	0

#if __MSPDEBUG__ > 3

void MSPBeep(MSP3430Ptr m, CARD8 freq);

#define __MSPBEEP MSPBeep(m,0x14);

#else

#define __MSPBEEP
#endif

static void
SetMSP3430Control(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegValueHigh,
                  CARD8 RegValueLow)
{
    I2CByte data[3];

    data[0] = RegAddress;
    data[1] = RegValueHigh;
    data[2] = RegValueLow;

    I2C_WriteRead(&(m->d), data, 3, NULL, 0);
}

static void
SetMSP3430Data(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegSubAddressHigh,
               CARD8 RegSubAddressLow, CARD8 RegValueHigh, CARD8 RegValueLow)
{
    I2CByte data[5];

#ifdef MSP_DEBUG
    if (!m->registers_present[RegSubAddressLow]) {
        xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_ERROR,
                   "Attempt to access non-existent register in MSP34xxX: 0x%02x 0x%02x 0x%02x <- 0x%02x 0x%02x\n",
                   RegAddress, RegSubAddressHigh, RegSubAddressLow,
                   RegValueHigh, RegValueLow);
    }
#endif

    data[0] = RegAddress;
    data[1] = RegSubAddressHigh;
    data[2] = RegSubAddressLow;
    data[3] = RegValueHigh;
    data[4] = RegValueLow;

    I2C_WriteRead(&(m->d), data, 5, NULL, 0);
}

static void
GetMSP3430Data(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegSubAddressHigh,
               CARD8 RegSubAddressLow, CARD8 *RegValueHigh, CARD8 *RegValueLow)
{
    I2CByte send[3];
    I2CByte receive[2];

    send[0] = RegAddress;
    send[1] = RegSubAddressHigh;
    send[2] = RegSubAddressLow;

    I2C_WriteRead(&(m->d), send, 3, receive, 2);

    *RegValueHigh = receive[0];
    *RegValueLow = receive[1];
}

#if __MSPDEBUG__ > 2
static void
MSP3430DumpStatus(MSP3430Ptr m)
{
    CARD8 status_hi, status_lo;
    CARD8 subaddr, data[2];

    GetMSP3430Data(m, RD_DEM, 0x02, 0x00, &status_hi, &status_lo);
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "MSP34xx: SAP(8)=%d mono/NICAM(7)=%d stereo=%d %s O_1=%d O_0=%d 2nd car=%d 1st car=%d\n",
               status_hi & 1, (status_lo >> 7) & 1, (status_lo >> 6) & 1,
               (status_lo >> 5) ? ((status_hi >> 1) & 1 ? "bad NICAM reception"
                                   : "NICAM") : ((status_hi >> 1) & 1 ? "bogus"
                                                 : "ANALOG FM/AM"),
               (status_lo >> 4) & 1, (status_lo >> 3) & 1,
               !((status_lo >> 2) & 1), !((status_lo >> 1) & 1));

    GetMSP3430Data(m, RD_DEM, 0x00, 0x7E, &status_hi, &status_lo);
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "MSP34xx: standard result=0x%02x%02x\n", status_hi, status_lo);
    subaddr = 0x0;
    I2C_WriteRead(&(m->d), &subaddr, 1, data, 2);
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP34xx: control=0x%02x%02x\n",
               data[1], data[0]);
}
#endif

/* wrapper */
void
InitMSP3430(MSP3430Ptr m)
{
#if __MSPDEBUG__ > 1
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "InitMSP3430(m->connector=%d, m->standard=%d, m->chip_family=%d)\n",
               m->connector, m->standard, m->chip_family);
#endif
    switch (m->chip_family) {
    case MSPFAMILY_34x0G:
        InitMSP34xxG(m);
        break;
    case MSPFAMILY_34x5G:
        InitMSP34xxG(m);
        break;
    case MSPFAMILY_34x5D:
        InitMSP34x5D(m);
        break;
    }
}

/*-----------------------------------------------------------------
| common functions for all MSP34xx chips 
|----------------------------------------------------------------*/

MSP3430Ptr
DetectMSP3430(I2CBusPtr b, I2CSlaveAddr addr)
{
    MSP3430Ptr m;
    I2CByte a;
    CARD8 hardware_version, major_revision, product_code, rom_version;
    Bool supported;

    m = calloc(1, sizeof(MSP3430Rec));
    if (m == NULL)
        return NULL;
    m->d.DevName = strdup("MSP34xx");
    m->d.SlaveAddr = addr;
    m->d.pI2CBus = b;
    m->d.NextDev = NULL;
    m->d.StartTimeout = b->StartTimeout;
    m->d.BitTimeout = b->BitTimeout;
    m->d.AcknTimeout = b->AcknTimeout;
    m->d.ByteTimeout = b->ByteTimeout;

    if (!I2C_WriteRead(&(m->d), NULL, 0, &a, 1)) {
        free(m->d.DevName);
        free(m);
        return NULL;
    }

    m->standard = MSP3430_NTSC;
    m->connector = MSP3430_CONNECTOR_1;
    m->mode = MSPMODE_STEREO_A; /*stereo or chanel A if avail. */
    m->c_format = MSPFORMAT_UNKNOWN;
    m->c_standard = MSPSTANDARD_UNKNOWN;
    m->c_matrix = m->c_fmmatrix = m->c_source = 0;
    m->volume = 0;
    m->recheck = FALSE;

    GetMSP3430Data(m, RD_DSP, 0x00, 0x1E, &hardware_version, &major_revision);
    GetMSP3430Data(m, RD_DSP, 0x00, 0x1F, &product_code, &rom_version);
    m->hardware_version = hardware_version;
    m->major_revision = major_revision;
    m->product_code = product_code;
    m->rom_version = rom_version;

    m->chip_id = ((major_revision << 8) | product_code);

    supported = FALSE;
    switch (major_revision) {
    case 4:                    /* 34xxD */
        switch (product_code) {
        case 0x05:             /* 3405D */
        case 0x0A:             /* 3410D */
        case 0x0F:             /* 3415D */
            m->chip_family = MSPFAMILY_34x5D;
            m->recheck = TRUE;
            supported = TRUE;
            break;
        default:
            m->chip_family = MSPFAMILY_34x0D;
        }
        break;
    case 7:                    /* 34xxG */
        switch (product_code) {
        case 0x00:
        case 0x0A:
        case 0x1E:
        case 0x28:
        case 0x32:
            m->chip_family = MSPFAMILY_34x0G;
            supported = TRUE;
            break;
        case 0x0f:
        case 0x19:
        case 0x2d:
        case 0x37:
        case 0x41:
            m->chip_family = MSPFAMILY_34x5G;
            supported = TRUE;
#ifdef MSP_DEBUG
            memset(m->registers_present, 0, 256);
#define A(num) m->registers_present[(num)]=1;
#define B(num1, num2) memset(&(m->registers_present[num1]), 1, num2-num1);
            A(0x20)
                A(0x30)
                A(0x40)
                A(0x00)
                B(0x01, 0x08)
                B(0x0B, 0x0E)
                A(0x10)
                B(0x12, 0x14)
                A(0x16)
                A(0x29)
#undef B
#undef A
#endif
                break;
        default:
            m->chip_family = MSPFAMILY_UNKNOWN;
        }
        break;
    default:
        m->chip_family = MSPFAMILY_UNKNOWN;
    }

    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "Found %s%s, rom version 0x%02x, chip_id=0x%04x\n",
               MSP_getProductName(m->chip_id),
               supported ? "" : " (unsupported)", rom_version, m->chip_id);

    if (!supported) {
        free(m->d.DevName);
        free(m);
        return NULL;
    }
    if (!I2CDevInit(&(m->d))) {
        free(m->d.DevName);
        free(m);
        return NULL;
    }

    return m;
}

void
ResetMSP3430(MSP3430Ptr m)
{
    /* Reset the MSP3430 */
    SetMSP3430Control(m, 0x00, 0x80, 0x00);
    /* Set it back to normal operation */
    SetMSP3430Control(m, 0x00, 0x00, 0x00);

    m->c_format = MSPFORMAT_UNKNOWN;
    m->c_standard = MSPSTANDARD_UNKNOWN;
    m->c_matrix = m->c_fmmatrix = m->c_source = 0;
    m->volume = 0;
}

void
MSP3430SetVolume(MSP3430Ptr m, CARD8 value)
{
    CARD8 result;

#if 0
    CARD8 old_volume;

    GetMSP3430Data(m, RD_DSP, 0x00, 0x00, &old_volume, &result);
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP3430 result 0x%02x\n",
               result);
#endif
    /* save an extra Get call */
    result = 0;

    SetMSP3430Data(m, WR_DSP, 0x00, 0x00, value, result);

    SetMSP3430Data(m, WR_DSP, 0x00, 0x07, value, 0);
    m->volume = value;

#if __MSPDEBUG__ > 2
    MSP3430DumpStatus(m);
    __MSPBEEP GetMSP3430Data(m, RD_DSP, 0x00, 0x00, &old_volume, &result);
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP3430 volume 0x%02x\n",
               value);
#endif
}

void
MSP3430SetSAP(MSP3430Ptr m, int mode)
{
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "Put actual code to change SAP here\n");

    SetMSP3430Data(m, WR_DSP, 0x00, 0x08, mode & 0xff, 0x20);
}

#if 0
void
MSP3430SetSource(MSP3430Ptr m, CARD8 value)
{
    /* Write to DSP, register 0x0008, (loudspeaker channel source/matrix) */
    /* This sets the source to the TV tuner, for stereo operation */
    SetMSP3430Data(m, WR_DSP, 0x00, 0x08, value, 0x20);
}
#endif

static const char *
MSP_getProductName(CARD16 product_id)
{
    switch (product_id) {
    case 0x0400:
        return "MSP3400D";
    case 0x040a:
        return "MSP3410D";
    case 0x0405:
        return "MSP3405D";
    case 0x040f:
        return "MSP3415D";
    case 0x0700:
        return "MSP3400G";
    case 0x070a:
        return "MSP3410G";
    case 0x071e:
        return "MSP3430G";
    case 0x0728:
        return "MSP3440G";
    case 0x0732:
        return "MSP3450G";
    case 0x070f:
        return "MSP3415G";
    case 0x0719:
        return "MSP3425G";
    case 0x072d:
        return "MSP3445G";
    case 0x0737:
        return "MSP3455G";
    case 0x0741:
        return "MSP3465G";
    }
    return "MSP - unknown type";
}

#if __MSPDEBUG__ > 2
/*puts beep in MSP output
    freq = 0x01 - 16Hz ... 0x40 - 1kHz ... 0xff - 4kHz  
*/
void
MSPBeep(MSP3430Ptr m, CARD8 freq)
{
    SetMSP3430Data(m, WR_DSP, 0x00, freq, 0x7f, 0x40);
    mpause(100);
    SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, 0x00);
}
#endif

void
mpause(int milliseconds)
{
    int i, m;

    m = milliseconds / 20;
    for (i = 0; i < m; i++)
        usleep(20000);
}

/*-----------------------------------------------------------------
| specific functions for all MSP34xxG chips 
|----------------------------------------------------------------*/

void
InitMSP34xxG(MSP3430Ptr m)
{

#if __MSPDEBUG__ > 1
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
               "InitMSP34xxG(m->connector=%d, m->standard=%d, m->chip_family=%d)\n",
               m->connector, m->standard, m->chip_family);
#endif
    /* Reset MSP3430 */
    SetMSP3430Control(m, 0x00, 0x80, 0x00);
    /* Set it back to normal operation */
    SetMSP3430Control(m, 0x00, 0x00, 0x00);

    /*set MODUS register */
    /* bits: 0 - automatic sound detection */
    /*       1 - enable STATUS change */
    /*       12 - detect 6.5 Mhz carrier as D/K1, D/K2 or D/K NICAM  (does not seem to work ) */
    /*       13 - detect 4.5 Mhz carrier as BTSC */
    if ((m->standard & 0xff) == MSP3430_PAL) {
        SetMSP3430Data(m, WR_DEM, 0x00, 0x30, 0x30, 0x03 | 0x08);       /* make O_ pins tristate */
        /* PAL standard */
        SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x01);      /* possibly wrong */
    }
    else {
        SetMSP3430Data(m, WR_DEM, 0x00, 0x30, 0x20, 0x03 | 0x08);
        /* standard selection is M-BTSC-Stereo */
        SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x20);
    }

    switch (m->connector) {
    case MSP3430_CONNECTOR_1:
        SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x03, 0x20);
        break;
    case MSP3430_CONNECTOR_2:
        /* this has not been checked yet.. could be bogus */
        /* SCART Input Prescale: 0 dB gain */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);
        SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x02, 0x20);
        break;
    case MSP3430_CONNECTOR_3:
    default:
        /* SCART Input Prescale: 0 dB gain */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);

        SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x02, 0x20);
        break;
    }

    switch (m->standard) {
    case MSP3430_PAL:
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);
        SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x00, 0x5a);
        SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x03);
        /* Set volume to FAST_MUTE. */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
        break;
    case MSP3430_PAL_DK1:
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);
        SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x00, 0x5a);
        SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x04);
        /* Set volume to FAST_MUTE. */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
        break;
    case MSP3430_SECAM:        /* is this right ? */
    case MSP3430_NTSC:
        /* Write to DSP, register 0x000E, (prescale FM/FM matrix) */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);

        /* Set volume to FAST_MUTE. */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
        break;
    }

}

/*-----------------------------------------------------------------
| specific functions for all MSP34x5D chips 
|----------------------------------------------------------------*/

void
InitMSP34x5D(MSP3430Ptr m)
{
    int count;
    CARD8 high, low;
    CARD16 result, standard;
    CARD16 peak;

    if (m->c_format == MSPFORMAT_UNKNOWN)
        ResetMSP3430(m);
    else {
        /*mute volume */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0x00, 0x00);
    }

    switch (m->connector) {
    case MSP3430_CONNECTOR_2:
    case MSP3430_CONNECTOR_3:
        if (m->c_format != MSPFORMAT_SCART) {
            /* SCART Input Prescale: 0 dB gain */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);
            /* this has not been checked yet.. could be bogus */
            m->c_format = MSPFORMAT_SCART;      /*stereo */
        }
        break;
    case MSP3430_CONNECTOR_1:
    default:

        switch (m->standard & 0x00ff) {
        case MSP3430_PAL:
            switch (m->standard) {
            case MSP3430_PAL_DK1:
                standard = MSPSTANDARD_FM_DK1;
                break;
/*			case MSP3430_PAL_DK2:
			    standard=MSPSTANDARD_FM_DK2;
			    break;
			case MSP3430_PAL_BG:
			may be FM stereo (Germany) or FM NICAM (Scandinavia,spain)
			    standard=MSPSTANDARD_AUTO;
			    break;
*/
            default:
                standard = MSPSTANDARD_AUTO;
            }
            break;
        case MSP3430_SECAM:
            standard = MSPSTANDARD_AUTO;
        case MSP3430_NTSC:
            /* Only MSP34x5 supported format - Korean NTSC-M */
            standard = MSPSTANDARD_FM_M;
        default:
            standard = MSPSTANDARD_AUTO;
        }

        /*no NICAM support in MSP3410D - force to autodetect */
        if ((m->chip_id == 0x405) && (standard >= MSPSTANDARD_NICAM_BG))
            standard = MSPSTANDARD_AUTO;

        if (m->c_standard != standard) {

            SetMSP3430Data(m, WR_DEM, 0x00, 0x20, standard >> 8,
                           standard & 0xFF);
            if (standard == MSPSTANDARD_AUTO) {
                count = 50;     /* time shouldn't exceed 1s, just in case */
                do {
                    usleep(20000);
                    GetMSP3430Data(m, RD_DEM, 0x00, 0x7e, &high, &low);
                    result = (high << 8) | low;
                    --count;
                } while (result > 0x07ff && count > 0);

                if ((result > MSPSTANDARD_AUTO))
                    standard = result;
                else
                    standard = MSPSTANDARD_UNKNOWN;
#if __MSPDEBUG__ > 1
                xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
                           "Detected audio standard: %d\n", result);
#endif
                /* result = MSPSTANDARD_NICAM_L can be one of:
                   SECAM_L - MSPSTANDARD_NICAM_L
                   D/K1 - MSPSTANDARD_FM_DK1
                   D/K2 - MSPSTANDARD_FM_DK2
                   D/K-NICAM - MSPSTANDARD_NICAM_DK */
                if (standard == MSPSTANDARD_NICAM_L) {
                    if ((m->standard & 0x00ff) == MSP3430_PAL) {
                        /* force PAL D/K  */
                        standard = MSPSTANDARD_FM_DK1;
                        SetMSP3430Data(m, WR_DEM, 0x00, 0x20, standard >> 8,
                                       standard & 0xFF);
#if __MSPDEBUG__ > 1
                        xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
                                   "Detected 6.5MHz carrier - forced to D/K1 !!!\n");
#endif
                    }
                }
            }
            m->c_standard = standard;
        }                       /*end - standard changed */
        else {
            if (standard < MSPSTANDARD_NICAM_BG) {
                /* get old value of ident. mode register */
                GetMSP3430Data(m, RD_DSP, 0x00, 0x15, &high, &low);
                /* reset Ident-Filter */
                SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, 0x3F);
                /* put back old value to ident. mode register */
                SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, low);
            }
        }

        if (standard <= MSPSTANDARD_AUTO) {
            m->c_format = MSPFORMAT_1xFM;
        }
        else if (standard < MSPSTANDARD_NICAM_BG) {
            /* set FM prescale */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x30, 0);
            /* set FM deemphasis */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x0f,
                           ((standard == MSPSTANDARD_FM_M) ? 0 : 1), 0);

            /* check if FM2 carrier is present */
            /*turn off FM DC Notch */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x17, 0x00, 0x3f);
            /*matrix source for Quasi-Peak Detector - stereo: ch2->L ch1->R */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x0c, 0x00, 0x20);

            mpause(250);
            GetMSP3430Data(m, RD_DSP, 0x00, 0x1A, &high, &low);
            peak = (high << 8) | low;
#if __MSPDEBUG__ > 1
            xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
                       "Second carrier Quasi-Peak detection: %d\n", peak);
#endif
            /*turn on FM DC Notch */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x17, 0x00, 0x00);

            if (peak < 5) {
                /* if second carrier not detected - only mono from first carrier */
                m->c_format = MSPFORMAT_1xFM;
            }
            else {
                m->c_format = MSPFORMAT_2xFM;
                /*start of FM identification process - FM_WAIT
                   wait at least 0.5s - used 1s - gives beter resolution */
                mpause(1000);
            }
        }
        else {
            if (standard == MSPSTANDARD_NICAM_L) {
                m->c_format = MSPFORMAT_NICAM_AM;
                /* set AM prescale */
                SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x7C, 0);
            }
            else {
                m->c_format = MSPFORMAT_NICAM_FM;
                /* set FM prescale */
                SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x30, 0);
            }
            /* set FM deemphasis */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x0f, 0x00, 0);
            /* set NICAM prescale to 0dB */
            SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x20, 0);
        }

        break;
    }                           /*end - case conector */

    CheckModeMSP34x5D(m);

    /* Set volume to FAST_MUTE. */
    /*SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00); */
    /*set volume */
    MSP3430SetVolume(m, m->volume);

__MSPBEEP}                      /* EnableMSP34x5D ()... */

void
CheckModeMSP34x5D(MSP3430Ptr m)
{
    const char stereo_on = 25;
    const char stereo_off = 20;
    const char dual_on = -stereo_on;
    const char dual_off = -stereo_off;
    char detect;
    CARD8 matrix, fmmatrix, source, high, low;

    fmmatrix = 0;               /*no matrix */
    source = 0;
    /*FM*/ switch (m->c_format) {
    case MSPFORMAT_NICAM_FM:
    case MSPFORMAT_NICAM_AM:
    case MSPFORMAT_SCART:
        source = ((m->c_format == MSPFORMAT_SCART) ? 2 : 1);
        switch (m->mode) {
        case MSPMODE_MONO:
            matrix = 0x30;
            /*MONO*/ break;
        case MSPMODE_A:
            matrix = 0x00;
            /*A*/ break;
        case MSPMODE_B:
            matrix = 0x10;
            /*B*/ break;
        default:
            matrix = 0x20;
            /*STEREO*/ break;
        }
        break;
    default:
    case MSPFORMAT_1xFM:
        matrix = 0x00;
        /*A*/ break;
    case MSPFORMAT_2xFM:
        switch (m->mode) {
        case MSPMODE_MONO:
            matrix = 0x30;
            /*MONO*/ break;
        case MSPMODE_STEREO:
            matrix = 0x20;
            /*STEREO*/ fmmatrix = ((m->c_standard == MSPSTANDARD_FM_M) ? 2 : 1);
            break;
        case MSPMODE_AB:
            matrix = 0x20;
            /*STEREO*/ break;
        case MSPMODE_A:
            matrix = 0x00;
            /*A*/ break;
        case MSPMODE_B:
            matrix = 0x10;
            /*B*/ break;
        default:
            /*FM_IDENT_CHECK */
            GetMSP3430Data(m, RD_DSP, 0x00, 0x18, &high, &low);
            detect = (char) high;
#if __MSPDEBUG__ > 1
            xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
                       "Stereo Detection Register: %d\n", detect);
#endif
            if (detect >=
                ((m->c_mode == MSPMODE_STEREO) ? stereo_off : stereo_on)) {
                m->c_mode = MSPMODE_STEREO;
                matrix = 0x20;
                /*STEREO*/
                    fmmatrix = ((m->c_standard == MSPSTANDARD_FM_M) ? 2 : 1);
            }
            else if (detect <= ((m->c_mode == MSPMODE_AB) ? dual_off : dual_on)) {
                m->c_mode = MSPMODE_AB;
                switch (m->mode) {
                case MSPMODE_STEREO_AB:
                    matrix = 0x20;
                    break;
                case MSPMODE_STEREO_B:
                    matrix = 0x10;
                    break;
                default:
                case MSPMODE_A:
                    matrix = 0x00;
                    break;
                }
            }
            else {
                m->c_mode = MSPMODE_MONO;
                matrix = 0x30;
            /*MONO*/}
            break;
        }                       /* end - case mode */
        break;
    }

    if (m->c_fmmatrix != fmmatrix) {
        GetMSP3430Data(m, RD_DSP, 0x00, 0x0e, &high, &low);
        SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, high, fmmatrix);
        m->c_fmmatrix = fmmatrix;
    }

    if ((m->c_matrix != matrix) || (m->c_source != source)) {
        /*set chanel source and matrix for loudspeaker */
        SetMSP3430Data(m, WR_DSP, 0x00, 0x08, source, matrix);

        m->c_matrix = matrix;
        m->c_source = source;
    }

    if (((m->c_format) & 0xF0) == MSPFORMAT_NICAM)
        SetMSP3430Data(m, WR_DEM, 0x00, 0x21, 0, 1);

#if __MSPDEBUG__ > 0
    char *msg;

    switch (matrix) {
    case 0x30:
        /*MONO*/ msg = "MONO";
        break;
    case 0x00:
        /*LEFT*/ msg = "MONO/CHANNEL_1";
        break;
    case 0x10:
        /*RIGHT*/ msg = "MONO/CHANNEL_2";
        break;
    case 0x20:
        /*LEFT*/ msg = "STEREO";
        break;
    default:
        msg = "unknown";
        break;
    }
    xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "Audio mode set to: %s\n", msg);
#endif
}
Commit	Line	Data
a09e091a JB	1	#ifdef HAVE_XORG_CONFIG_H
	2	#include <xorg-config.h>
	3	#endif
	4
	5	#include <string.h>
	6	#include <unistd.h>
	7
	8	#include "xf86.h"
	9	#include "xf86i2c.h"
	10	#include "msp3430.h"
	11	#include "i2c_def.h"
	12
	13	#define CONTROL 0x00
	14	#define WR_DEM 0x10
	15	#define RD_DEM 0x11
	16	#define WR_DSP 0x12
	17	#define RD_DSP 0x13
	18
	19	void InitMSP34xxG(MSP3430Ptr m);
	20	void InitMSP34x5D(MSP3430Ptr m);
	21	void CheckModeMSP34x5D(MSP3430Ptr m);
	22	static const char *MSP_getProductName(CARD16 product_id);
	23	void mpause(int milliseconds);
	24
	25	#define __MSPDEBUG__ 0
	26
	27	#if __MSPDEBUG__ > 3
	28
	29	void MSPBeep(MSP3430Ptr m, CARD8 freq);
	30
	31	#define __MSPBEEP MSPBeep(m,0x14);
	32
	33	#else
	34
	35	#define __MSPBEEP
	36	#endif
	37
	38	static void
	39	SetMSP3430Control(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegValueHigh,
	40	CARD8 RegValueLow)
	41	{
	42	I2CByte data[3];
	43
	44	data[0] = RegAddress;
	45	data[1] = RegValueHigh;
	46	data[2] = RegValueLow;
	47
	48	I2C_WriteRead(&(m->d), data, 3, NULL, 0);
	49	}
	50
	51	static void
	52	SetMSP3430Data(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegSubAddressHigh,
	53	CARD8 RegSubAddressLow, CARD8 RegValueHigh, CARD8 RegValueLow)
	54	{
	55	I2CByte data[5];
	56
	57	#ifdef MSP_DEBUG
	58	if (!m->registers_present[RegSubAddressLow]) {
	59	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_ERROR,
	60	"Attempt to access non-existent register in MSP34xxX: 0x%02x 0x%02x 0x%02x <- 0x%02x 0x%02x\n",
	61	RegAddress, RegSubAddressHigh, RegSubAddressLow,
	62	RegValueHigh, RegValueLow);
	63	}
	64	#endif
65
66	data[0] = RegAddress;
67	data[1] = RegSubAddressHigh;
68	data[2] = RegSubAddressLow;
69	data[3] = RegValueHigh;
70	data[4] = RegValueLow;
71
72	I2C_WriteRead(&(m->d), data, 5, NULL, 0);
73	}
74
75	static void
76	GetMSP3430Data(MSP3430Ptr m, CARD8 RegAddress, CARD8 RegSubAddressHigh,
77	CARD8 RegSubAddressLow, CARD8 RegValueHigh, CARD8 RegValueLow)
78	{
79	I2CByte send[3];
80	I2CByte receive[2];
81
82	send[0] = RegAddress;
83	send[1] = RegSubAddressHigh;
84	send[2] = RegSubAddressLow;
85
86	I2C_WriteRead(&(m->d), send, 3, receive, 2);
87
88	*RegValueHigh = receive[0];
89	*RegValueLow = receive[1];
90	}
91
92	#if __MSPDEBUG__ > 2
93	static void
94	MSP3430DumpStatus(MSP3430Ptr m)
95	{
96	CARD8 status_hi, status_lo;
97	CARD8 subaddr, data[2];
98
99	GetMSP3430Data(m, RD_DEM, 0x02, 0x00, &status_hi, &status_lo);
100	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
101	"MSP34xx: SAP(8)=%d mono/NICAM(7)=%d stereo=%d %s O_1=%d O_0=%d 2nd car=%d 1st car=%d\n",
102	status_hi & 1, (status_lo >> 7) & 1, (status_lo >> 6) & 1,
103	(status_lo >> 5) ? ((status_hi >> 1) & 1 ? "bad NICAM reception"
104	: "NICAM") : ((status_hi >> 1) & 1 ? "bogus"
105	: "ANALOG FM/AM"),
106	(status_lo >> 4) & 1, (status_lo >> 3) & 1,
107	!((status_lo >> 2) & 1), !((status_lo >> 1) & 1));
108
109	GetMSP3430Data(m, RD_DEM, 0x00, 0x7E, &status_hi, &status_lo);
110	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
111	"MSP34xx: standard result=0x%02x%02x\n", status_hi, status_lo);
112	subaddr = 0x0;
113	I2C_WriteRead(&(m->d), &subaddr, 1, data, 2);
114	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP34xx: control=0x%02x%02x\n",
115	data[1], data[0]);
116	}
117	#endif
118
119	/* wrapper */
120	void
121	InitMSP3430(MSP3430Ptr m)
122	{
123	#if __MSPDEBUG__ > 1
124	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
125	"InitMSP3430(m->connector=%d, m->standard=%d, m->chip_family=%d)\n",
126	m->connector, m->standard, m->chip_family);
127	#endif
128	switch (m->chip_family) {
129	case MSPFAMILY_34x0G:
130	InitMSP34xxG(m);
131	break;
132	case MSPFAMILY_34x5G:
133	InitMSP34xxG(m);
134	break;
135	case MSPFAMILY_34x5D:
136	InitMSP34x5D(m);
137	break;
138	}
139	}
140
141	/*-----------------------------------------------------------------
142	\| common functions for all MSP34xx chips
143	\|----------------------------------------------------------------*/
144
145	MSP3430Ptr
146	DetectMSP3430(I2CBusPtr b, I2CSlaveAddr addr)
147	{
148	MSP3430Ptr m;
149	I2CByte a;
150	CARD8 hardware_version, major_revision, product_code, rom_version;
151	Bool supported;
152
153	m = calloc(1, sizeof(MSP3430Rec));
154	if (m == NULL)
155	return NULL;
156	m->d.DevName = strdup("MSP34xx");
157	m->d.SlaveAddr = addr;
158	m->d.pI2CBus = b;
159	m->d.NextDev = NULL;
160	m->d.StartTimeout = b->StartTimeout;
161	m->d.BitTimeout = b->BitTimeout;
162	m->d.AcknTimeout = b->AcknTimeout;
163	m->d.ByteTimeout = b->ByteTimeout;
164
165	if (!I2C_WriteRead(&(m->d), NULL, 0, &a, 1)) {
166	free(m->d.DevName);
167	free(m);
168	return NULL;
169	}
170
171	m->standard = MSP3430_NTSC;
172	m->connector = MSP3430_CONNECTOR_1;
173	m->mode = MSPMODE_STEREO_A; /stereo or chanel A if avail. /
174	m->c_format = MSPFORMAT_UNKNOWN;
175	m->c_standard = MSPSTANDARD_UNKNOWN;
176	m->c_matrix = m->c_fmmatrix = m->c_source = 0;
177	m->volume = 0;
178	m->recheck = FALSE;
179
180	GetMSP3430Data(m, RD_DSP, 0x00, 0x1E, &hardware_version, &major_revision);
181	GetMSP3430Data(m, RD_DSP, 0x00, 0x1F, &product_code, &rom_version);
182	m->hardware_version = hardware_version;
183	m->major_revision = major_revision;
184	m->product_code = product_code;
185	m->rom_version = rom_version;
186
187	m->chip_id = ((major_revision << 8) \| product_code);
188
189	supported = FALSE;
190	switch (major_revision) {
191	case 4: /* 34xxD */
192	switch (product_code) {
193	case 0x05: /* 3405D */
194	case 0x0A: /* 3410D */
195	case 0x0F: /* 3415D */
196	m->chip_family = MSPFAMILY_34x5D;
197	m->recheck = TRUE;
198	supported = TRUE;
199	break;
200	default:
201	m->chip_family = MSPFAMILY_34x0D;
202	}
203	break;
204	case 7: /* 34xxG */
205	switch (product_code) {
206	case 0x00:
207	case 0x0A:
208	case 0x1E:
209	case 0x28:
210	case 0x32:
211	m->chip_family = MSPFAMILY_34x0G;
212	supported = TRUE;
213	break;
214	case 0x0f:
215	case 0x19:
216	case 0x2d:
217	case 0x37:
218	case 0x41:
219	m->chip_family = MSPFAMILY_34x5G;
220	supported = TRUE;
221	#ifdef MSP_DEBUG
222	memset(m->registers_present, 0, 256);
223	#define A(num) m->registers_present[(num)]=1;
224	#define B(num1, num2) memset(&(m->registers_present[num1]), 1, num2-num1);
225	A(0x20)
226	A(0x30)
227	A(0x40)
228	A(0x00)
229	B(0x01, 0x08)
230	B(0x0B, 0x0E)
231	A(0x10)
232	B(0x12, 0x14)
233	A(0x16)
234	A(0x29)
235	#undef B
236	#undef A
237	#endif
238	break;
239	default:
240	m->chip_family = MSPFAMILY_UNKNOWN;
241	}
242	break;
243	default:
244	m->chip_family = MSPFAMILY_UNKNOWN;
245	}
246
247	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
248	"Found %s%s, rom version 0x%02x, chip_id=0x%04x\n",
249	MSP_getProductName(m->chip_id),
250	supported ? "" : " (unsupported)", rom_version, m->chip_id);
251
252	if (!supported) {
253	free(m->d.DevName);
254	free(m);
255	return NULL;
256	}
257	if (!I2CDevInit(&(m->d))) {
258	free(m->d.DevName);
259	free(m);
260	return NULL;
261	}
262
263	return m;
264	}
265
266	void
267	ResetMSP3430(MSP3430Ptr m)
268	{
269	/* Reset the MSP3430 */
270	SetMSP3430Control(m, 0x00, 0x80, 0x00);
271	/* Set it back to normal operation */
272	SetMSP3430Control(m, 0x00, 0x00, 0x00);
273
274	m->c_format = MSPFORMAT_UNKNOWN;
275	m->c_standard = MSPSTANDARD_UNKNOWN;
276	m->c_matrix = m->c_fmmatrix = m->c_source = 0;
277	m->volume = 0;
278	}
279
280	void
281	MSP3430SetVolume(MSP3430Ptr m, CARD8 value)
282	{
283	CARD8 result;
284
285	#if 0
286	CARD8 old_volume;
287
288	GetMSP3430Data(m, RD_DSP, 0x00, 0x00, &old_volume, &result);
289	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP3430 result 0x%02x\n",
290	result);
291	#endif
292	/* save an extra Get call */
293	result = 0;
294
295	SetMSP3430Data(m, WR_DSP, 0x00, 0x00, value, result);
296
297	SetMSP3430Data(m, WR_DSP, 0x00, 0x07, value, 0);
298	m->volume = value;
299
300	#if __MSPDEBUG__ > 2
301	MSP3430DumpStatus(m);
302	__MSPBEEP GetMSP3430Data(m, RD_DSP, 0x00, 0x00, &old_volume, &result);
303	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "MSP3430 volume 0x%02x\n",
304	value);
305	#endif
306	}
307
308	void
309	MSP3430SetSAP(MSP3430Ptr m, int mode)
310	{
311	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
312	"Put actual code to change SAP here\n");
313
314	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, mode & 0xff, 0x20);
315	}
316
317	#if 0
318	void
319	MSP3430SetSource(MSP3430Ptr m, CARD8 value)
320	{
321	/* Write to DSP, register 0x0008, (loudspeaker channel source/matrix) */
322	/* This sets the source to the TV tuner, for stereo operation */
323	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, value, 0x20);
324	}
325	#endif
326
327	static const char *
328	MSP_getProductName(CARD16 product_id)
329	{
330	switch (product_id) {
331	case 0x0400:
332	return "MSP3400D";
333	case 0x040a:
334	return "MSP3410D";
335	case 0x0405:
336	return "MSP3405D";
337	case 0x040f:
338	return "MSP3415D";
339	case 0x0700:
340	return "MSP3400G";
341	case 0x070a:
342	return "MSP3410G";
343	case 0x071e:
344	return "MSP3430G";
345	case 0x0728:
346	return "MSP3440G";
347	case 0x0732:
348	return "MSP3450G";
349	case 0x070f:
350	return "MSP3415G";
351	case 0x0719:
352	return "MSP3425G";
353	case 0x072d:
354	return "MSP3445G";
355	case 0x0737:
356	return "MSP3455G";
357	case 0x0741:
358	return "MSP3465G";
359	}
360	return "MSP - unknown type";
361	}
362
363	#if __MSPDEBUG__ > 2
364	/*puts beep in MSP output
365	freq = 0x01 - 16Hz ... 0x40 - 1kHz ... 0xff - 4kHz
366	*/
367	void
368	MSPBeep(MSP3430Ptr m, CARD8 freq)
369	{
370	SetMSP3430Data(m, WR_DSP, 0x00, freq, 0x7f, 0x40);
371	mpause(100);
372	SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, 0x00);
373	}
374	#endif
375
376	void
377	mpause(int milliseconds)
378	{
379	int i, m;
380
381	m = milliseconds / 20;
382	for (i = 0; i < m; i++)
383	usleep(20000);
384	}
385
386	/*-----------------------------------------------------------------
387	\| specific functions for all MSP34xxG chips
388	\|----------------------------------------------------------------*/
389
390	void
391	InitMSP34xxG(MSP3430Ptr m)
392	{
393
394	#if __MSPDEBUG__ > 1
395	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
396	"InitMSP34xxG(m->connector=%d, m->standard=%d, m->chip_family=%d)\n",
397	m->connector, m->standard, m->chip_family);
398	#endif
399	/* Reset MSP3430 */
400	SetMSP3430Control(m, 0x00, 0x80, 0x00);
401	/* Set it back to normal operation */
402	SetMSP3430Control(m, 0x00, 0x00, 0x00);
403
404	/set MODUS register /
405	/* bits: 0 - automatic sound detection */
406	/* 1 - enable STATUS change */
407	/* 12 - detect 6.5 Mhz carrier as D/K1, D/K2 or D/K NICAM (does not seem to work ) */
408	/* 13 - detect 4.5 Mhz carrier as BTSC */
409	if ((m->standard & 0xff) == MSP3430_PAL) {
410	SetMSP3430Data(m, WR_DEM, 0x00, 0x30, 0x30, 0x03 \| 0x08); /* make O_ pins tristate */
411	/* PAL standard */
412	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x01); /* possibly wrong */
413	}
414	else {
415	SetMSP3430Data(m, WR_DEM, 0x00, 0x30, 0x20, 0x03 \| 0x08);
416	/* standard selection is M-BTSC-Stereo */
417	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x20);
418	}
419
420	switch (m->connector) {
421	case MSP3430_CONNECTOR_1:
422	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x03, 0x20);
423	break;
424	case MSP3430_CONNECTOR_2:
425	/* this has not been checked yet.. could be bogus */
426	/* SCART Input Prescale: 0 dB gain */
427	SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);
428	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x02, 0x20);
429	break;
430	case MSP3430_CONNECTOR_3:
431	default:
432	/* SCART Input Prescale: 0 dB gain */
433	SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);
434
435	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, 0x02, 0x20);
436	break;
437	}
438
439	switch (m->standard) {
440	case MSP3430_PAL:
441	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);
442	SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x00, 0x5a);
443	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x03);
444	/* Set volume to FAST_MUTE. */
445	SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
446	break;
447	case MSP3430_PAL_DK1:
448	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);
449	SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x00, 0x5a);
450	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, 0x00, 0x04);
451	/* Set volume to FAST_MUTE. */
452	SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
453	break;
454	case MSP3430_SECAM: /* is this right ? */
455	case MSP3430_NTSC:
456	/* Write to DSP, register 0x000E, (prescale FM/FM matrix) */
457	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x24, 0x03);
458
459	/* Set volume to FAST_MUTE. */
460	SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00);
461	break;
462	}
463
464	}
465
466	/*-----------------------------------------------------------------
467	\| specific functions for all MSP34x5D chips
468	\|----------------------------------------------------------------*/
469
470	void
471	InitMSP34x5D(MSP3430Ptr m)
472	{
473	int count;
474	CARD8 high, low;
475	CARD16 result, standard;
476	CARD16 peak;
477
478	if (m->c_format == MSPFORMAT_UNKNOWN)
479	ResetMSP3430(m);
480	else {
481	/mute volume /
482	SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0x00, 0x00);
483	}
484
485	switch (m->connector) {
486	case MSP3430_CONNECTOR_2:
487	case MSP3430_CONNECTOR_3:
488	if (m->c_format != MSPFORMAT_SCART) {
489	/* SCART Input Prescale: 0 dB gain */
490	SetMSP3430Data(m, WR_DSP, 0x00, 0x0d, 0x19, 0x00);
491	/* this has not been checked yet.. could be bogus */
492	m->c_format = MSPFORMAT_SCART; /stereo /
493	}
494	break;
495	case MSP3430_CONNECTOR_1:
496	default:
497
498	switch (m->standard & 0x00ff) {
499	case MSP3430_PAL:
500	switch (m->standard) {
501	case MSP3430_PAL_DK1:
502	standard = MSPSTANDARD_FM_DK1;
503	break;
504	/* case MSP3430_PAL_DK2:
505	standard=MSPSTANDARD_FM_DK2;
506	break;
507	case MSP3430_PAL_BG:
508	may be FM stereo (Germany) or FM NICAM (Scandinavia,spain)
509	standard=MSPSTANDARD_AUTO;
510	break;
511	*/
512	default:
513	standard = MSPSTANDARD_AUTO;
514	}
515	break;
516	case MSP3430_SECAM:
517	standard = MSPSTANDARD_AUTO;
518	case MSP3430_NTSC:
519	/* Only MSP34x5 supported format - Korean NTSC-M */
520	standard = MSPSTANDARD_FM_M;
521	default:
522	standard = MSPSTANDARD_AUTO;
523	}
524
525	/no NICAM support in MSP3410D - force to autodetect /
526	if ((m->chip_id == 0x405) && (standard >= MSPSTANDARD_NICAM_BG))
527	standard = MSPSTANDARD_AUTO;
528
529	if (m->c_standard != standard) {
530
531	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, standard >> 8,
532	standard & 0xFF);
533	if (standard == MSPSTANDARD_AUTO) {
534	count = 50; /* time shouldn't exceed 1s, just in case */
535	do {
536	usleep(20000);
537	GetMSP3430Data(m, RD_DEM, 0x00, 0x7e, &high, &low);
538	result = (high << 8) \| low;
539	--count;
540	} while (result > 0x07ff && count > 0);
541
542	if ((result > MSPSTANDARD_AUTO))
543	standard = result;
544	else
545	standard = MSPSTANDARD_UNKNOWN;
546	#if __MSPDEBUG__ > 1
547	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
548	"Detected audio standard: %d\n", result);
549	#endif
550	/* result = MSPSTANDARD_NICAM_L can be one of:
551	SECAM_L - MSPSTANDARD_NICAM_L
552	D/K1 - MSPSTANDARD_FM_DK1
553	D/K2 - MSPSTANDARD_FM_DK2
554	D/K-NICAM - MSPSTANDARD_NICAM_DK */
555	if (standard == MSPSTANDARD_NICAM_L) {
556	if ((m->standard & 0x00ff) == MSP3430_PAL) {
557	/* force PAL D/K */
558	standard = MSPSTANDARD_FM_DK1;
559	SetMSP3430Data(m, WR_DEM, 0x00, 0x20, standard >> 8,
560	standard & 0xFF);
561	#if __MSPDEBUG__ > 1
562	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
563	"Detected 6.5MHz carrier - forced to D/K1 !!!\n");
564	#endif
565	}
566	}
567	}
568	m->c_standard = standard;
569	} /end - standard changed /
570	else {
571	if (standard < MSPSTANDARD_NICAM_BG) {
572	/* get old value of ident. mode register */
573	GetMSP3430Data(m, RD_DSP, 0x00, 0x15, &high, &low);
574	/* reset Ident-Filter */
575	SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, 0x3F);
576	/* put back old value to ident. mode register */
577	SetMSP3430Data(m, WR_DSP, 0x00, 0x14, 0x00, low);
578	}
579	}
580
581	if (standard <= MSPSTANDARD_AUTO) {
582	m->c_format = MSPFORMAT_1xFM;
583	}
584	else if (standard < MSPSTANDARD_NICAM_BG) {
585	/* set FM prescale */
586	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x30, 0);
587	/* set FM deemphasis */
588	SetMSP3430Data(m, WR_DSP, 0x00, 0x0f,
589	((standard == MSPSTANDARD_FM_M) ? 0 : 1), 0);
590
591	/* check if FM2 carrier is present */
592	/turn off FM DC Notch /
593	SetMSP3430Data(m, WR_DSP, 0x00, 0x17, 0x00, 0x3f);
594	/matrix source for Quasi-Peak Detector - stereo: ch2->L ch1->R /
595	SetMSP3430Data(m, WR_DSP, 0x00, 0x0c, 0x00, 0x20);
596
597	mpause(250);
598	GetMSP3430Data(m, RD_DSP, 0x00, 0x1A, &high, &low);
599	peak = (high << 8) \| low;
600	#if __MSPDEBUG__ > 1
601	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
602	"Second carrier Quasi-Peak detection: %d\n", peak);
603	#endif
604	/turn on FM DC Notch /
605	SetMSP3430Data(m, WR_DSP, 0x00, 0x17, 0x00, 0x00);
606
607	if (peak < 5) {
608	/* if second carrier not detected - only mono from first carrier */
609	m->c_format = MSPFORMAT_1xFM;
610	}
611	else {
612	m->c_format = MSPFORMAT_2xFM;
613	/*start of FM identification process - FM_WAIT
614	wait at least 0.5s - used 1s - gives beter resolution */
615	mpause(1000);
616	}
617	}
618	else {
619	if (standard == MSPSTANDARD_NICAM_L) {
620	m->c_format = MSPFORMAT_NICAM_AM;
621	/* set AM prescale */
622	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x7C, 0);
623	}
624	else {
625	m->c_format = MSPFORMAT_NICAM_FM;
626	/* set FM prescale */
627	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, 0x30, 0);
628	}
629	/* set FM deemphasis */
630	SetMSP3430Data(m, WR_DSP, 0x00, 0x0f, 0x00, 0);
631	/* set NICAM prescale to 0dB */
632	SetMSP3430Data(m, WR_DSP, 0x00, 0x10, 0x20, 0);
633	}
634
635	break;
636	} /end - case conector /
637
638	CheckModeMSP34x5D(m);
639
640	/* Set volume to FAST_MUTE. */
641	/SetMSP3430Data(m, WR_DSP, 0x00, 0x00, 0xFF, 0x00); /
642	/set volume /
643	MSP3430SetVolume(m, m->volume);
644
645	__MSPBEEP} /* EnableMSP34x5D ()... */
646
647	void
648	CheckModeMSP34x5D(MSP3430Ptr m)
649	{
650	const char stereo_on = 25;
651	const char stereo_off = 20;
652	const char dual_on = -stereo_on;
653	const char dual_off = -stereo_off;
654	char detect;
655	CARD8 matrix, fmmatrix, source, high, low;
656
657	fmmatrix = 0; /no matrix /
658	source = 0;
659	/FM/ switch (m->c_format) {
660	case MSPFORMAT_NICAM_FM:
661	case MSPFORMAT_NICAM_AM:
662	case MSPFORMAT_SCART:
663	source = ((m->c_format == MSPFORMAT_SCART) ? 2 : 1);
664	switch (m->mode) {
665	case MSPMODE_MONO:
666	matrix = 0x30;
667	/MONO/ break;
668	case MSPMODE_A:
669	matrix = 0x00;
670	/A/ break;
671	case MSPMODE_B:
672	matrix = 0x10;
673	/B/ break;
674	default:
675	matrix = 0x20;
676	/STEREO/ break;
677	}
678	break;
679	default:
680	case MSPFORMAT_1xFM:
681	matrix = 0x00;
682	/A/ break;
683	case MSPFORMAT_2xFM:
684	switch (m->mode) {
685	case MSPMODE_MONO:
686	matrix = 0x30;
687	/MONO/ break;
688	case MSPMODE_STEREO:
689	matrix = 0x20;
690	/STEREO/ fmmatrix = ((m->c_standard == MSPSTANDARD_FM_M) ? 2 : 1);
691	break;
692	case MSPMODE_AB:
693	matrix = 0x20;
694	/STEREO/ break;
695	case MSPMODE_A:
696	matrix = 0x00;
697	/A/ break;
698	case MSPMODE_B:
699	matrix = 0x10;
700	/B/ break;
701	default:
702	/FM_IDENT_CHECK /
703	GetMSP3430Data(m, RD_DSP, 0x00, 0x18, &high, &low);
704	detect = (char) high;
705	#if __MSPDEBUG__ > 1
706	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO,
707	"Stereo Detection Register: %d\n", detect);
708	#endif
709	if (detect >=
710	((m->c_mode == MSPMODE_STEREO) ? stereo_off : stereo_on)) {
711	m->c_mode = MSPMODE_STEREO;
712	matrix = 0x20;
713	/STEREO/
714	fmmatrix = ((m->c_standard == MSPSTANDARD_FM_M) ? 2 : 1);
715	}
716	else if (detect <= ((m->c_mode == MSPMODE_AB) ? dual_off : dual_on)) {
717	m->c_mode = MSPMODE_AB;
718	switch (m->mode) {
719	case MSPMODE_STEREO_AB:
720	matrix = 0x20;
721	break;
722	case MSPMODE_STEREO_B:
723	matrix = 0x10;
724	break;
725	default:
726	case MSPMODE_A:
727	matrix = 0x00;
728	break;
729	}
730	}
731	else {
732	m->c_mode = MSPMODE_MONO;
733	matrix = 0x30;
734	/MONO/}
735	break;
736	} /* end - case mode */
737	break;
738	}
739
740	if (m->c_fmmatrix != fmmatrix) {
741	GetMSP3430Data(m, RD_DSP, 0x00, 0x0e, &high, &low);
742	SetMSP3430Data(m, WR_DSP, 0x00, 0x0e, high, fmmatrix);
743	m->c_fmmatrix = fmmatrix;
744	}
745
746	if ((m->c_matrix != matrix) \|\| (m->c_source != source)) {
747	/set chanel source and matrix for loudspeaker /
748	SetMSP3430Data(m, WR_DSP, 0x00, 0x08, source, matrix);
749
750	m->c_matrix = matrix;
751	m->c_source = source;
752	}
753
754	if (((m->c_format) & 0xF0) == MSPFORMAT_NICAM)
755	SetMSP3430Data(m, WR_DEM, 0x00, 0x21, 0, 1);
756
757	#if __MSPDEBUG__ > 0
758	char *msg;
759
760	switch (matrix) {
761	case 0x30:
762	/MONO/ msg = "MONO";
763	break;
764	case 0x00:
765	/LEFT/ msg = "MONO/CHANNEL_1";
766	break;
767	case 0x10:
768	/RIGHT/ msg = "MONO/CHANNEL_2";
769	break;
770	case 0x20:
771	/LEFT/ msg = "STEREO";
772	break;
773	default:
774	msg = "unknown";
775	break;
776	}
777	xf86DrvMsg(m->d.pI2CBus->scrnIndex, X_INFO, "Audio mode set to: %s\n", msg);
778	#endif
779	}