/*
* tviu800_init
* Called to add the devices which we have on this board
*/
static int __init tviu800_init(void)
{
struct platform_device *audio_dev;
struct ubi32_wm8988_platform_data *wm8988_pd;
int ret;
if (ubicom32_flash_single_init()) {
printk(KERN_ERR "%s: could not initialize flash controller\n", __FUNCTION__);
}
board_init();
ubi_gpio_init();
/*
* Start the flash driver
*/
ubicom32_flash_single_init();
/*
* Hold the POWER_HOLD line
*/
ret = gpio_request(GPIO_RF_11, "POWER_HOLD");
if (ret) {
printk(KERN_ERR "%s: could not request POWER_HOLD GPIO\n", __FUNCTION__);
}
gpio_direction_output(GPIO_RF_11, 1);
mach_power_off = tviu800_power_off;
/*
* Bring up audio devices
*/
platform_add_devices(tviu800_devices, ARRAY_SIZE(tviu800_devices));
audio_dev = audio_device_alloc("snd-ubi32-wm8988", "audio", "audio-i2sout", sizeof(struct ubi32_wm8988_platform_data));
if (audio_dev) {
printk(KERN_INFO "%s: setting audio_dev properties\n", __FUNCTION__);
wm8988_pd = audio_device_priv(audio_dev);
wm8988_pd->mclk_src = UBI32_WM8988_MCLK_CLKDIV_1;
wm8988_pd->n_mclk = ARRAY_SIZE(tviu800_wm8988_mclk_entries);
wm8988_pd->mclk_entries = tviu800_wm8988_mclk_entries;
tviu800_i2c_board_info[0].platform_data = audio_dev;
}
printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
i2c_register_board_info(0, tviu800_i2c_board_info, ARRAY_SIZE(tviu800_i2c_board_info));
printk(KERN_INFO "TVIU800 TechVision DLNA board\n");
return 0;
}
/*
* Ubicom audio driver probe() method. Args change depending on whether we use
* platform_device or i2c_device.
*/
static int snd_ubi32_generic_probe(struct platform_device *dev)
{
struct snd_card *card;
struct ubi32_snd_priv *ubi32_priv;
int err;
struct ubi32_generic_platform_data *pdata;
/*
* dev is audio device
*/
if (!dev) {
snd_printk(KERN_WARNING "generic platform_data null!\n");
return -ENODEV;
}
/*
* setup mclk if pdata exists
*/
pdata = audio_device_priv(dev);
if (pdata) {
if (snd_ubi32_generic_setup_mclk(pdata)) {
snd_printk(KERN_WARNING "can not setup mclk!\n");
return -EINVAL;
}
}
/*
* Create a snd_card structure
*/
card = snd_card_new(index, "Ubi32-Generic", THIS_MODULE, sizeof(struct ubi32_snd_priv));
if (card == NULL) {
return -ENOMEM;
}
card->private_free = snd_ubi32_generic_free; /* Not sure if correct */
ubi32_priv = card->private_data;
/*
* Initialize the snd_card's private data structure
*/
ubi32_priv->card = card;
/*
* Create the new PCM instance
*/
err = snd_ubi32_pcm_probe(ubi32_priv, dev);
if (err < 0) {
snd_card_free(card);
return err;
}
strcpy(card->driver, "Ubi32-Generic");
strcpy(card->shortname, "Ubi32-Generic");
snprintf(card->longname, sizeof(card->longname),
"%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
snd_card_set_dev(card, &dev->dev);
/*
* Register the sound card
*/
if ((err = snd_card_register(card)) != 0) {
snd_printk(KERN_INFO "snd_card_register error\n");
}
/*
* Store card for access from other methods
*/
platform_set_drvdata(dev, card);
return 0;
}
/*
* snd_ubi32_cs4384_i2c_probe
*/
static int snd_ubi32_cs4384_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct snd_card *card;
struct ubi32_snd_priv *ubi32_priv;
int err, ret;
struct platform_device *pdev;
struct ubi32_cs4384_platform_data *pdata;
struct snd_ubi32_cs4384_priv *cs4384_priv;
/*
* pdev is audio device
*/
pdev = client->dev.platform_data;
if (!pdev) {
return -ENODEV;
}
/*
* pdev->dev.platform_data is ubi32-pcm platform_data
*/
pdata = audio_device_priv(pdev);
if (!pdata) {
return -ENODEV;
}
/*
* Initialize the CS4384 DAC
*/
ret = snd_ubi32_cs4384_dac_init(client, id);
if (ret < 0) {
/*
* Initialization failed. Propagate the error.
*/
return ret;
}
if (snd_ubi32_cs4384_setup_mclk(pdata)) {
return -EINVAL;
}
/*
* Create a snd_card structure
*/
card = snd_card_new(index, "Ubi32-CS4384", THIS_MODULE, sizeof(struct ubi32_snd_priv));
if (card == NULL) {
return -ENOMEM;
}
card->private_free = snd_ubi32_cs4384_free;
ubi32_priv = card->private_data;
/*
* Initialize the snd_card's private data structure
*/
ubi32_priv->card = card;
ubi32_priv->client = client;
ubi32_priv->set_channels = snd_ubi32_cs4384_set_channels;
ubi32_priv->set_rate = snd_ubi32_cs4384_set_rate;
/*
* CS4384 DAC has a minimum sample rate of 4khz and an
* upper limit of 216khz for its auto-detect.
*/
ubi32_priv->min_sample_rate = 4000;
ubi32_priv->max_sample_rate = 216000;
/*
* Create our private data (to manage volume, etc)
*/
cs4384_priv = kzalloc(sizeof(struct snd_ubi32_cs4384_priv), GFP_KERNEL);
if (!cs4384_priv) {
snd_card_free(card);
return -ENOMEM;
}
snd_ubi32_priv_set_drv(ubi32_priv, cs4384_priv);
spin_lock_init(&cs4384_priv->lock);
/*
* We start off all muted and max volume
*/
cs4384_priv->mute = 0xFF;
memset(cs4384_priv->volume, 0xFF, 8);
/*
* Create the new PCM instance
*/
err = snd_ubi32_pcm_probe(ubi32_priv, pdev);
if (err < 0) {
snd_card_free(card);
return err; /* What is err? Need to include correct file */
}
strcpy(card->driver, "Ubi32-CS4384");
strcpy(card->shortname, "Ubi32-CS4384");
snprintf(card->longname, sizeof(card->longname),
"%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
snd_card_set_dev(card, &client->dev);
/*
* Set up the mixer
*/
snd_ubi32_cs4384_mixer(ubi32_priv);
/*
* Register the sound card
*/
if ((err = snd_card_register(card)) != 0) {
snd_printk(KERN_INFO "snd_card_register error\n");
}
/*
* Store card for access from other methods
*/
i2c_set_clientdata(client, card);
return 0;
}
/*
* ip7500av_init
* Called to add the devices which we have on this board
*/
static int __init ip7500av_init(void)
{
struct platform_device *audio_dev;
struct platform_device *audio_dev2;
struct ubi32_cs4384_platform_data *cs4384_pd;
if (ubicom32_flash_single_init()) {
printk(KERN_ERR "%s: could not initialize flash controller\n", __FUNCTION__);
}
board_init();
ubi_gpio_init();
/*
* Start the flash driver
*/
ubicom32_flash_single_init();
vdc_tio_init(NULL);
printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
platform_add_devices(ip7500av_devices, ARRAY_SIZE(ip7500av_devices));
/*
* CS4384 DAC
*/
audio_dev = audio_device_alloc("snd-ubi32-cs4384", "audio", "audio-i2sout",
sizeof(struct ubi32_cs4384_platform_data));
if (audio_dev) {
/*
* Attempt to figure out a good divisor. This will only work
* assuming the core frequency is compatible.
*/
int i;
unsigned int freq = processor_frequency();
for (i = 0; i < ARRAY_SIZE(ip7500av_cs4384_mclk_entries); i++) {
unsigned int div;
unsigned int rate = ip7500av_cs4384_mclk_entries[i].rate / 1000;
div = ((freq / rate) + 500) / 1000;
ip7500av_cs4384_mclk_entries[i].div = div;
printk("CS4384 mclk %d rate %u000Hz div %u act %u\n", i, rate, div, freq / div);
}
cs4384_pd = audio_device_priv(audio_dev);
cs4384_pd->mclk_src = UBI32_CS4384_MCLK_PWM_0;
cs4384_pd->n_mclk = ARRAY_SIZE(ip7500av_cs4384_mclk_entries);
cs4384_pd->mclk_entries = ip7500av_cs4384_mclk_entries;
ip7500av_i2c_board_info[0].platform_data = audio_dev;
/*
* Reset the DAC
*/
if (gpio_request(GPIO_RF_4, "DAC Reset") == 0) {
gpio_direction_output(GPIO_RF_4, 0);
udelay(1);
gpio_direction_output(GPIO_RF_4, 1);
} else {
printk("Unable to request DAC reset GPIO\n");
}
}
/*
* SPDIF port
*/
audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0);
if (audio_dev2) {
platform_device_register(audio_dev2);
}
/*
* Register all of the devices which sit on the I2C bus
*/
printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
i2c_register_board_info(0, ip7500av_i2c_board_info, ARRAY_SIZE(ip7500av_i2c_board_info));
printk(KERN_INFO "IP7500 Audio/Video Board\n");
return 0;
}
