/* * 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; }