static int snd_cs8427_spdif_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct cs8427 *chip = kcontrol->private_data;
unsigned char *status;
int err, change;
if (!chip) {
pr_err("%s: invalid device info\n", __func__);
return -ENODEV;
}
status = kcontrol->private_value ?
chip->playback.pcm_status : chip->playback.def_status;
change = memcmp(ucontrol->value.iec958.status, status,
CHANNEL_STATUS_SIZE);
if (change) {
memcpy(status, ucontrol->value.iec958.status,
CHANNEL_STATUS_SIZE);
err = snd_cs8427_send_corudata(chip, 0, status,
CHANNEL_STATUS_SIZE);
if (err < 0)
change = err;
}
return change;
}
int snd_cs8427_iec958_pcm(struct snd_i2c_device *cs8427, unsigned int rate)
{
struct cs8427 *chip;
char *status;
int err, reset;
if (snd_BUG_ON(!cs8427))
return -ENXIO;
chip = cs8427->private_data;
status = chip->playback.pcm_status;
snd_i2c_lock(cs8427->bus);
if (status[0] & IEC958_AES0_PROFESSIONAL) {
status[0] &= ~IEC958_AES0_PRO_FS;
switch (rate) {
case 32000: status[0] |= IEC958_AES0_PRO_FS_32000; break;
case 44100: status[0] |= IEC958_AES0_PRO_FS_44100; break;
case 48000: status[0] |= IEC958_AES0_PRO_FS_48000; break;
default: status[0] |= IEC958_AES0_PRO_FS_NOTID; break;
}
} else {
status[3] &= ~IEC958_AES3_CON_FS;
switch (rate) {
case 32000: status[3] |= IEC958_AES3_CON_FS_32000; break;
case 44100: status[3] |= IEC958_AES3_CON_FS_44100; break;
case 48000: status[3] |= IEC958_AES3_CON_FS_48000; break;
}
}
err = snd_cs8427_send_corudata(cs8427, 0, status, 24);
if (err > 0)
snd_ctl_notify(cs8427->bus->card,
SNDRV_CTL_EVENT_MASK_VALUE,
&chip->playback.pcm_ctl->id);
reset = chip->rate != rate;
chip->rate = rate;
snd_i2c_unlock(cs8427->bus);
if (reset)
snd_cs8427_reset(cs8427);
return err < 0 ? err : 0;
}
static int snd_cs8427_spdif_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol);
struct cs8427 *chip = device->private_data;
unsigned char *status = kcontrol->private_value ?
chip->playback.pcm_status : chip->playback.def_status;
struct snd_pcm_runtime *runtime = chip->playback.substream ?
chip->playback.substream->runtime : NULL;
int err, change;
snd_i2c_lock(device->bus);
change = memcmp(ucontrol->value.iec958.status, status, 24) != 0;
memcpy(status, ucontrol->value.iec958.status, 24);
if (change && (kcontrol->private_value ?
runtime != NULL : runtime == NULL)) {
err = snd_cs8427_send_corudata(device, 0, status, 24);
if (err < 0)
change = err;
}
snd_i2c_unlock(device->bus);
return change;
}
static __devinit int cs8427_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
static unsigned char initvals1[] = {
CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC,
/* CS8427_REG_CONTROL1: RMCK to OMCK, valid PCM audio, disable mutes,
* TCBL=output
*/
CS8427_SWCLK | CS8427_TCBLDIR,
/* CS8427_REG_CONTROL2: hold last valid audio sample, RMCK=256*Fs,
* normal stereo operation
*/
0x08,
/* CS8427_REG_DATAFLOW:
* AES3 Transmitter data source => Serial Audio input port
* Serial audio output port data source => reserved
*/
CS8427_TXDSERIAL,
/* CS8427_REG_CLOCKSOURCE: Run off, CMCK=256*Fs,
* output time base = OMCK, input time base = recovered input clock,
* recovered input clock source is ILRCK changed to AES3INPUT
* (workaround, see snd_cs8427_reset)
*/
CS8427_RXDILRCK | CS8427_OUTC,
/* CS8427_REG_SERIALINPUT: Serial audio input port data format = I2S,
* 24-bit, 64*Fsi
*/
CS8427_SIDEL | CS8427_SILRPOL | CS8427_SORES16,
/* CS8427_REG_SERIALOUTPUT: Serial audio output port data format
* = I2S, 24-bit, 64*Fsi
*/
CS8427_SODEL | CS8427_SOLRPOL | CS8427_SIRES16,
};
static unsigned char initvals2[] = {
CS8427_REG_RECVERRMASK | CS8427_REG_AUTOINC,
/* CS8427_REG_RECVERRMASK: unmask the input PLL clock, V, confidence,
* biphase, parity status bits
* CS8427_UNLOCK | CS8427_V | CS8427_CONF | CS8427_BIP | CS8427_PAR,
*/
0xff, /* set everything */
/* CS8427_REG_CSDATABUF:
* Registers 32-55 window to CS buffer
* Inhibit D->E transfers from overwriting first 5 bytes of CS data.
* Inhibit D->E transfers (all) of CS data.
* Allow E->F transfer of CS data.
* One byte mode; both A/B channels get same written CB data.
* A channel info is output to chip's EMPH* pin.
*/
CS8427_CBMR | CS8427_DETCI,
/* CS8427_REG_UDATABUF:
* Use internal buffer to transmit User (U) data.
* Chip's U pin is an output.
* Transmit all O's for user data.
* Inhibit D->E transfers.
* Inhibit E->F transfers.
*/
CS8427_UD | CS8427_EFTUI | CS8427_DETUI,
};
int err;
unsigned char buf[CHANNEL_STATUS_SIZE];
unsigned char val = 0;
char addr = 0;
unsigned int reset_timeout = 1;
int ret = 0;
struct cs8427 *chip;
if (!client) {
pr_err("%s: invalid device info\n", __func__);
return -EINVAL;
}
chip = kzalloc(sizeof(struct cs8427), GFP_KERNEL);
if (chip == NULL) {
dev_err(&client->dev,
"%s: error, allocation failed\n", __func__);
return -ENOMEM;
}
chip->client = client;
dev_set_drvdata(&chip->client->dev, chip);
ret = poweron_cs8427(chip);
if (ret) {
dev_err(&chip->client->dev,
"failed to bring chip out of reset\n");
return -ENODEV;
}
err = cs8427_i2c_read(chip, CS8427_REG_ID_AND_VER, 1, &val);
if (err < 0) {
/* give second chance */
dev_err(&chip->client->dev,
"failed to read cs8427 trying once again\n");
err = cs8427_i2c_read(chip, CS8427_REG_ID_AND_VER,
1, &val);
if (err < 0) {
dev_err(&chip->client->dev,
"failed to read version number\n");
return -ENODEV;
}
dev_dbg(&chip->client->dev,
"version number read = %x\n", val);
}
if (val != CS8427_VER8427A) {
dev_err(&chip->client->dev,
"unable to find CS8427 signature "
"(expected 0x%x, read 0x%x),\n",
CS8427_VER8427A, val);
dev_err(&chip->client->dev,
" initialization is not completed\n");
return -EFAULT;
}
val = 0;
/* turn off run bit while making changes to configuration */
err = cs8427_i2c_write(chip, CS8427_REG_CLOCKSOURCE, 1, &val);
if (err < 0)
goto __fail;
/* send initial values */
memcpy(chip->regmap + (initvals1[0] & 0x7f), initvals1 + 1, 6);
addr = 1;
err = cs8427_i2c_sendbytes(chip, &addr, &initvals1[1], 6);
if (err != 6) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* Turn off CS8427 interrupt stuff that is not used in hardware */
memset(buf, 0, 7);
/* from address 9 to 15 */
addr = 9;
err = cs8427_i2c_sendbytes(chip, &addr, buf, 7);
if (err != 7)
goto __fail;
/* send transfer initialization sequence */
addr = 0x11;
memcpy(chip->regmap + (initvals2[0] & 0x7f), initvals2 + 1, 3);
err = cs8427_i2c_sendbytes(chip, &addr, &initvals2[1], 3);
if (err != 3) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* write default channel status bytes */
put_unaligned_le32(SNDRV_PCM_DEFAULT_CON_SPDIF, buf);
memset(buf + 4, 0, CHANNEL_STATUS_SIZE - 4);
if (snd_cs8427_send_corudata(chip, 0, buf, CHANNEL_STATUS_SIZE) < 0)
goto __fail;
memcpy(chip->playback.def_status, buf, CHANNEL_STATUS_SIZE);
memcpy(chip->playback.pcm_status, buf, CHANNEL_STATUS_SIZE);
/* turn on run bit and rock'n'roll */
if (reset_timeout < 1)
reset_timeout = 1;
chip->reset_timeout = reset_timeout;
snd_cs8427_reset(chip);
ret = snd_soc_register_codec(&chip->client->dev, &soc_codec_dev_cs8427,
cs8427_dai, ARRAY_SIZE(cs8427_dai));
return 0;
__fail:
kfree(chip);
return err < 0 ? err : -EIO;
}
static __devinit int cs8427_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
static unsigned char initvals1[] = {
CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC,
CS8427_SWCLK | CS8427_TCBLDIR,
0x08,
CS8427_TXDSERIAL,
CS8427_RXDILRCK | CS8427_OUTC,
CS8427_SIDEL | CS8427_SILRPOL | CS8427_SORES16,
CS8427_SODEL | CS8427_SOLRPOL | CS8427_SIRES16,
};
static unsigned char initvals2[] = {
CS8427_REG_RECVERRMASK | CS8427_REG_AUTOINC,
0xff,
/* CS8427_REG_CSDATABUF:
* Registers 32-55 window to CS buffer
* Inhibit D->E transfers from overwriting first 5 bytes of CS data.
* Inhibit D->E transfers (all) of CS data.
* Allow E->F transfer of CS data.
* One byte mode; both A/B channels get same written CB data.
* A channel info is output to chip's EMPH* pin.
*/
CS8427_CBMR | CS8427_DETCI,
CS8427_UD | CS8427_EFTUI | CS8427_DETUI,
};
int err;
unsigned char buf[CHANNEL_STATUS_SIZE];
unsigned char val = 0;
char addr = 0;
unsigned int reset_timeout = 100;
int ret = 0;
struct cs8427 *chip;
if (!client) {
pr_err("%s: invalid device info\n", __func__);
return -EINVAL;
}
chip = kzalloc(sizeof(struct cs8427), GFP_KERNEL);
if (chip == NULL) {
dev_err(&client->dev,
"%s: error, allocation failed\n", __func__);
return -ENOMEM;
}
chip->client = client;
dev_set_drvdata(&chip->client->dev, chip);
ret = poweron_cs8427(chip);
if (ret) {
dev_err(&chip->client->dev,
"failed to bring chip out of reset\n");
return -ENODEV;
}
err = cs8427_i2c_read(chip, CS8427_REG_ID_AND_VER, 1, &val);
if (err < 0) {
dev_err(&chip->client->dev,
"failed to read cs8427 trying once again\n");
err = cs8427_i2c_read(chip, CS8427_REG_ID_AND_VER,
1, &val);
if (err < 0) {
dev_err(&chip->client->dev,
"failed to read version number\n");
return -ENODEV;
}
dev_dbg(&chip->client->dev,
"version number read = %x\n", val);
}
if (val != CS8427_VER8427A) {
dev_err(&chip->client->dev,
"unable to find CS8427 signature "
"(expected 0x%x, read 0x%x),\n",
CS8427_VER8427A, val);
dev_err(&chip->client->dev,
" initialization is not completed\n");
return -EFAULT;
}
val = 0;
err = cs8427_i2c_write(chip, CS8427_REG_CLOCKSOURCE, 1, &val);
if (err < 0)
goto __fail;
memcpy(chip->regmap + (initvals1[0] & 0x7f), initvals1 + 1, 6);
addr = 1;
err = cs8427_i2c_sendbytes(chip, &addr, &initvals1[1], 6);
if (err != 6) {
err = err < 0 ? err : -EIO;
goto __fail;
}
memset(buf, 0, 7);
addr = 9;
err = cs8427_i2c_sendbytes(chip, &addr, buf, 7);
if (err != 7)
goto __fail;
addr = 0x11;
memcpy(chip->regmap + (initvals2[0] & 0x7f), initvals2 + 1, 3);
err = cs8427_i2c_sendbytes(chip, &addr, &initvals2[1], 3);
if (err != 3) {
err = err < 0 ? err : -EIO;
goto __fail;
}
put_unaligned_le32(SNDRV_PCM_DEFAULT_CON_SPDIF, buf);
memset(buf + 4, 0, CHANNEL_STATUS_SIZE - 4);
if (snd_cs8427_send_corudata(chip, 0, buf, CHANNEL_STATUS_SIZE) < 0)
goto __fail;
memcpy(chip->playback.def_status, buf, CHANNEL_STATUS_SIZE);
memcpy(chip->playback.pcm_status, buf, CHANNEL_STATUS_SIZE);
if (reset_timeout < 1)
reset_timeout = 1;
chip->reset_timeout = reset_timeout;
snd_cs8427_reset(chip);
ret = snd_soc_register_codec(&chip->client->dev, &soc_codec_dev_cs8427,
cs8427_dai, ARRAY_SIZE(cs8427_dai));
return 0;
__fail:
kfree(chip);
return err < 0 ? err : -EIO;
}
int snd_cs8427_create(struct snd_i2c_bus *bus,
unsigned char addr,
unsigned int reset_timeout,
struct snd_i2c_device **r_cs8427)
{
static unsigned char initvals1[] = {
CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC,
/* CS8427_REG_CONTROL1: RMCK to OMCK, valid PCM audio, disable mutes,
TCBL=output */
CS8427_SWCLK | CS8427_TCBLDIR,
/* CS8427_REG_CONTROL2: hold last valid audio sample, RMCK=256*Fs,
normal stereo operation */
0x00,
/* CS8427_REG_DATAFLOW: output drivers normal operation, Tx<=serial,
Rx=>serial */
CS8427_TXDSERIAL | CS8427_SPDAES3RECEIVER,
/* CS8427_REG_CLOCKSOURCE: Run off, CMCK=256*Fs,
output time base = OMCK, input time base = recovered input clock,
recovered input clock source is ILRCK changed to AES3INPUT
(workaround, see snd_cs8427_reset) */
CS8427_RXDILRCK,
/* CS8427_REG_SERIALINPUT: Serial audio input port data format = I2S,
24-bit, 64*Fsi */
CS8427_SIDEL | CS8427_SILRPOL,
/* CS8427_REG_SERIALOUTPUT: Serial audio output port data format
= I2S, 24-bit, 64*Fsi */
CS8427_SODEL | CS8427_SOLRPOL,
};
static unsigned char initvals2[] = {
CS8427_REG_RECVERRMASK | CS8427_REG_AUTOINC,
/* CS8427_REG_RECVERRMASK: unmask the input PLL clock, V, confidence,
biphase, parity status bits */
/* CS8427_UNLOCK | CS8427_V | CS8427_CONF | CS8427_BIP | CS8427_PAR,*/
0xff, /* set everything */
/* CS8427_REG_CSDATABUF:
Registers 32-55 window to CS buffer
Inhibit D->E transfers from overwriting first 5 bytes of CS data.
Inhibit D->E transfers (all) of CS data.
Allow E->F transfer of CS data.
One byte mode; both A/B channels get same written CB data.
A channel info is output to chip's EMPH* pin. */
CS8427_CBMR | CS8427_DETCI,
/* CS8427_REG_UDATABUF:
Use internal buffer to transmit User (U) data.
Chip's U pin is an output.
Transmit all O's for user data.
Inhibit D->E transfers.
Inhibit E->F transfers. */
CS8427_UD | CS8427_EFTUI | CS8427_DETUI,
};
int err;
struct cs8427 *chip;
struct snd_i2c_device *device;
unsigned char buf[24];
if ((err = snd_i2c_device_create(bus, "CS8427",
CS8427_ADDR | (addr & 7),
&device)) < 0)
return err;
chip = device->private_data = kzalloc(sizeof(*chip), GFP_KERNEL);
if (chip == NULL) {
snd_i2c_device_free(device);
return -ENOMEM;
}
device->private_free = snd_cs8427_free;
snd_i2c_lock(bus);
err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER);
if (err != CS8427_VER8427A) {
/* give second chance */
#ifdef CONFIG_DEBUG_PRINTK
snd_printk(KERN_WARNING "invalid CS8427 signature 0x%x: "
"let me try again...\n", err);
#else
;
#endif
err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER);
}
if (err != CS8427_VER8427A) {
snd_i2c_unlock(bus);
snd_printk(KERN_ERR "unable to find CS8427 signature "
"(expected 0x%x, read 0x%x),\n",
CS8427_VER8427A, err);
snd_printk(KERN_ERR " initialization is not completed\n");
return -EFAULT;
}
/* turn off run bit while making changes to configuration */
err = snd_cs8427_reg_write(device, CS8427_REG_CLOCKSOURCE, 0x00);
if (err < 0)
goto __fail;
/* send initial values */
memcpy(chip->regmap + (initvals1[0] & 0x7f), initvals1 + 1, 6);
if ((err = snd_i2c_sendbytes(device, initvals1, 7)) != 7) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* Turn off CS8427 interrupt stuff that is not used in hardware */
memset(buf, 0, 7);
/* from address 9 to 15 */
buf[0] = 9; /* register */
if ((err = snd_i2c_sendbytes(device, buf, 7)) != 7)
goto __fail;
/* send transfer initialization sequence */
memcpy(chip->regmap + (initvals2[0] & 0x7f), initvals2 + 1, 3);
if ((err = snd_i2c_sendbytes(device, initvals2, 4)) != 4) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* write default channel status bytes */
put_unaligned_le32(SNDRV_PCM_DEFAULT_CON_SPDIF, buf);
memset(buf + 4, 0, 24 - 4);
if (snd_cs8427_send_corudata(device, 0, buf, 24) < 0)
goto __fail;
memcpy(chip->playback.def_status, buf, 24);
memcpy(chip->playback.pcm_status, buf, 24);
snd_i2c_unlock(bus);
/* turn on run bit and rock'n'roll */
if (reset_timeout < 1)
reset_timeout = 1;
chip->reset_timeout = reset_timeout;
snd_cs8427_reset(device);
#if 0 // it's nice for read tests
{
char buf[128];
int xx;
buf[0] = 0x81;
snd_i2c_sendbytes(device, buf, 1);
snd_i2c_readbytes(device, buf, 127);
for (xx = 0; xx < 127; xx++)
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_DEBUG "reg[0x%x] = 0x%x\n", xx+1, buf[xx]);
#else
;
#endif
}
#endif
if (r_cs8427)
*r_cs8427 = device;
return 0;
__fail:
snd_i2c_unlock(bus);
snd_i2c_device_free(device);
return err < 0 ? err : -EIO;
}
int snd_cs8427_create(struct snd_i2c_bus *bus,
unsigned char addr,
unsigned int reset_timeout,
struct snd_i2c_device **r_cs8427)
{
static unsigned char initvals1[] = {
CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC,
/*
*/
CS8427_SWCLK | CS8427_TCBLDIR,
/*
*/
0x00,
/*
*/
CS8427_TXDSERIAL | CS8427_SPDAES3RECEIVER,
/*
*/
CS8427_RXDILRCK,
/*
*/
CS8427_SIDEL | CS8427_SILRPOL,
/*
*/
CS8427_SODEL | CS8427_SOLRPOL,
};
static unsigned char initvals2[] = {
CS8427_REG_RECVERRMASK | CS8427_REG_AUTOINC,
/*
*/
/* */
0xff, /* */
/*
*/
CS8427_CBMR | CS8427_DETCI,
/*
*/
CS8427_UD | CS8427_EFTUI | CS8427_DETUI,
};
int err;
struct cs8427 *chip;
struct snd_i2c_device *device;
unsigned char buf[24];
if ((err = snd_i2c_device_create(bus, "CS8427",
CS8427_ADDR | (addr & 7),
&device)) < 0)
return err;
chip = device->private_data = kzalloc(sizeof(*chip), GFP_KERNEL);
if (chip == NULL) {
snd_i2c_device_free(device);
return -ENOMEM;
}
device->private_free = snd_cs8427_free;
snd_i2c_lock(bus);
err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER);
if (err != CS8427_VER8427A) {
/* */
snd_printk(KERN_WARNING "invalid CS8427 signature 0x%x: "
"let me try again...\n", err);
err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER);
}
if (err != CS8427_VER8427A) {
snd_i2c_unlock(bus);
snd_printk(KERN_ERR "unable to find CS8427 signature "
"(expected 0x%x, read 0x%x),\n",
CS8427_VER8427A, err);
snd_printk(KERN_ERR " initialization is not completed\n");
return -EFAULT;
}
/* */
err = snd_cs8427_reg_write(device, CS8427_REG_CLOCKSOURCE, 0x00);
if (err < 0)
goto __fail;
/* */
memcpy(chip->regmap + (initvals1[0] & 0x7f), initvals1 + 1, 6);
if ((err = snd_i2c_sendbytes(device, initvals1, 7)) != 7) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* */
memset(buf, 0, 7);
/* */
buf[0] = 9; /* */
if ((err = snd_i2c_sendbytes(device, buf, 7)) != 7)
goto __fail;
/* */
memcpy(chip->regmap + (initvals2[0] & 0x7f), initvals2 + 1, 3);
if ((err = snd_i2c_sendbytes(device, initvals2, 4)) != 4) {
err = err < 0 ? err : -EIO;
goto __fail;
}
/* */
put_unaligned_le32(SNDRV_PCM_DEFAULT_CON_SPDIF, buf);
memset(buf + 4, 0, 24 - 4);
if (snd_cs8427_send_corudata(device, 0, buf, 24) < 0)
goto __fail;
memcpy(chip->playback.def_status, buf, 24);
memcpy(chip->playback.pcm_status, buf, 24);
snd_i2c_unlock(bus);
/* */
if (reset_timeout < 1)
reset_timeout = 1;
chip->reset_timeout = reset_timeout;
snd_cs8427_reset(device);
#if 0 //
{
char buf[128];
int xx;
buf[0] = 0x81;
snd_i2c_sendbytes(device, buf, 1);
snd_i2c_readbytes(device, buf, 127);
for (xx = 0; xx < 127; xx++)
printk(KERN_DEBUG "reg[0x%x] = 0x%x\n", xx+1, buf[xx]);
}
#endif
if (r_cs8427)
*r_cs8427 = device;
return 0;
__fail:
snd_i2c_unlock(bus);
snd_i2c_device_free(device);
return err < 0 ? err : -EIO;
}
