static void vib_set(int const new_power_state)
{
struct twl6040 *twl6040 = misc_data->twl6040;
u8 speed = misc_data->pdata->voltage_raise_speed;
int ret;
mutex_lock(&misc_data->io_mutex);
/* already in requested state */
if (new_power_state == misc_data->vib_power_state)
goto out;
/**
* @warning VIBDATx registers MUST be setted BEFORE VIBENAx bit
* setted in corresponding VIBCTLx registers
*/
if (new_power_state) {
ret = twl6040_vib_power(true);
if (ret)
goto out;
if (speed == 0x00)
speed = 0x32;
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, speed);
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, speed);
/*
* ERRATA: Disable overcurrent protection for at least
* 2.5ms when enabling vibrator drivers to avoid false
* overcurrent detection
*/
twl6040_set_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBENAL | TWL6040_VIBCTRLLP);
twl6040_set_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBENAR | TWL6040_VIBCTRLRP);
mdelay(4);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBCTRLLP);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBCTRLRP);
} else {
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, 0x00);
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, 0x00);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBENAL);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBENAR);
twl6040_vib_power(false);
}
misc_data->vib_power_state = new_power_state;
out:
mutex_unlock(&misc_data->io_mutex);
}
static void vib_set(int on)
{
struct twl6040_codec *twl6040 = misc_data->twl6040;
mutex_lock(&misc_data->io_mutex);
/* already in requested state */
if (misc_data->vib_power_state == on)
goto out;
if (on) {
/*
* ERRATA: Disable overcurrent protection for at least
* 2.5ms when enabling vibrator drivers to avoid false
* overcurrent detection
*/
twl6040_set_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBENAL | TWL6040_VIBCTRLR);
twl6040_set_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBENAR | TWL6040_VIBCTRLR);
mdelay(4);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBCTRLL);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBCTRLR);
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, 0x26);
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, 0x26);
} else {
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, 0x00);
twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, 0x00);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
TWL6040_VIBENAL);
twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
TWL6040_VIBENAR);
}
misc_data->vib_power_state = on;
out:
mutex_unlock(&misc_data->io_mutex);
}
static void sdp4430_mcpdm_twl6040_post(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_codec *codec = rtd->codec;
struct twl6040 *twl6040 = codec->control_data;
int ret;
/* TWL6040 supplies McPDM PAD_CLKS */
twl6040_disable(twl6040);
/* enable internal 32kHz oscillator */
twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_CLK32KSEL);
/* disable external 32kHz clock */
ret = regulator_disable(twl6040_clk32kreg);
if (ret)
printk(KERN_ERR "failed to disable TWL6040 CLK32K\n");
}
static int twl6040_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct twl6040_platform_data *pdata = client->dev.platform_data;
struct device_node *node = client->dev.of_node;
struct twl6040 *twl6040;
struct mfd_cell *cell = NULL;
int irq, ret, children = 0;
if (!pdata && !node) {
dev_err(&client->dev, "Platform data is missing\n");
return -EINVAL;
}
/* In order to operate correctly we need valid interrupt config */
if (!client->irq) {
dev_err(&client->dev, "Invalid IRQ configuration\n");
return -EINVAL;
}
twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
GFP_KERNEL);
if (!twl6040) {
ret = -ENOMEM;
goto err;
}
twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
if (IS_ERR(twl6040->regmap)) {
ret = PTR_ERR(twl6040->regmap);
goto err;
}
i2c_set_clientdata(client, twl6040);
twl6040->supplies[0].supply = "vio";
twl6040->supplies[1].supply = "v2v1";
ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
twl6040->supplies);
if (ret != 0) {
dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
goto regulator_get_err;
}
ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
if (ret != 0) {
dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
goto regulator_get_err;
}
twl6040->dev = &client->dev;
twl6040->irq = client->irq;
mutex_init(&twl6040->mutex);
init_completion(&twl6040->ready);
twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
/* ERRATA: Automatic power-up is not possible in ES1.0 */
if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0) {
if (pdata)
twl6040->audpwron = pdata->audpwron_gpio;
else
twl6040->audpwron = of_get_named_gpio(node,
"ti,audpwron-gpio", 0);
} else
twl6040->audpwron = -EINVAL;
if (gpio_is_valid(twl6040->audpwron)) {
ret = devm_gpio_request_one(&client->dev, twl6040->audpwron,
GPIOF_OUT_INIT_LOW, "audpwron");
if (ret)
goto gpio_err;
}
ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq,
IRQF_ONESHOT, 0, &twl6040_irq_chip,
&twl6040->irq_data);
if (ret < 0)
goto gpio_err;
twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data,
TWL6040_IRQ_READY);
twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data,
TWL6040_IRQ_TH);
ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_ready, NULL,
twl6040_readyint_handler, IRQF_ONESHOT,
"twl6040_irq_ready", twl6040);
if (ret) {
dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret);
goto readyirq_err;
}
ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL,
twl6040_thint_handler, IRQF_ONESHOT,
"twl6040_irq_th", twl6040);
if (ret) {
dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret);
goto thirq_err;
}
/* dual-access registers controlled by I2C only */
twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL);
/*
* The main functionality of twl6040 to provide audio on OMAP4+ systems.
* We can add the ASoC codec child whenever this driver has been loaded.
* The ASoC codec can work without pdata, pass the platform_data only if
* it has been provided.
*/
irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG);
cell = &twl6040->cells[children];
cell->name = "twl6040-codec";
twl6040_codec_rsrc[0].start = irq;
twl6040_codec_rsrc[0].end = irq;
cell->resources = twl6040_codec_rsrc;
cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
if (pdata && pdata->codec) {
cell->platform_data = pdata->codec;
cell->pdata_size = sizeof(*pdata->codec);
}
children++;
if (twl6040_has_vibra(pdata, node)) {
irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB);
cell = &twl6040->cells[children];
cell->name = "twl6040-vibra";
twl6040_vibra_rsrc[0].start = irq;
twl6040_vibra_rsrc[0].end = irq;
cell->resources = twl6040_vibra_rsrc;
cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
if (pdata && pdata->vibra) {
cell->platform_data = pdata->vibra;
cell->pdata_size = sizeof(*pdata->vibra);
}
children++;
}
/*
* Enable the GPO driver in the following cases:
* DT booted kernel or legacy boot with valid gpo platform_data
*/
if (!pdata || (pdata && pdata->gpo)) {
cell = &twl6040->cells[children];
cell->name = "twl6040-gpo";
if (pdata) {
cell->platform_data = pdata->gpo;
cell->pdata_size = sizeof(*pdata->gpo);
}
children++;
}
ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
NULL, 0, NULL);
if (ret)
goto mfd_err;
return 0;
mfd_err:
devm_free_irq(&client->dev, twl6040->irq_th, twl6040);
thirq_err:
devm_free_irq(&client->dev, twl6040->irq_ready, twl6040);
readyirq_err:
regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
gpio_err:
regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
regulator_get_err:
i2c_set_clientdata(client, NULL);
err:
return ret;
}
static int twl6040_power(struct twl6040 *twl6040, int enable)
{
struct twl4030_codec_data *pdata = dev_get_platdata(twl6040->dev);
int audpwron = twl6040->audpwron;
int naudint = twl6040->irq;
int ret = 0;
if (enable) {
/* enable 32kHz external clock */
if (pdata->set_ext_clk32k) {
ret = pdata->set_ext_clk32k(true);
if (ret) {
dev_err(twl6040->dev,
"failed to enable CLK32K %d\n", ret);
return ret;
}
}
/* disable internal 32kHz oscillator */
twl6040_clear_bits(twl6040, TWL6040_REG_ACCCTL,
TWL6040_CLK32KSEL);
if (gpio_is_valid(audpwron)) {
/* wait for power-up completion */
ret = twl6040_power_up_completion(twl6040, naudint);
if (ret) {
dev_err(twl6040->dev,
"automatic power-down failed\n");
return ret;
}
} else {
/* use manual power-up sequence */
ret = twl6040_power_up(twl6040);
if (ret) {
dev_err(twl6040->dev,
"manual power-up failed\n");
return ret;
}
}
/* Errata: PDMCLK can fail to generate at cold temperatures
* The workaround consists of resetting HPPLL and LPPLL
* after Sleep/Deep-Sleep mode and before application mode.
*/
twl6040_set_bits(twl6040, TWL6040_REG_HPPLLCTL,
TWL6040_HPLLRST);
twl6040_clear_bits(twl6040, TWL6040_REG_HPPLLCTL,
TWL6040_HPLLRST);
twl6040_set_bits(twl6040, TWL6040_REG_LPPLLCTL,
TWL6040_LPLLRST);
twl6040_clear_bits(twl6040, TWL6040_REG_LPPLLCTL,
TWL6040_LPLLRST);
twl6040->pll = TWL6040_LPPLL_ID;
twl6040->sysclk = 19200000;
} else {
if (gpio_is_valid(audpwron)) {
/* use AUDPWRON line */
gpio_set_value(audpwron, 0);
/* power-down sequence latency */
udelay(500);
} else {
/* use manual power-down sequence */
ret = twl6040_power_down(twl6040);
if (ret) {
dev_err(twl6040->dev,
"manual power-down failed\n");
return ret;
}
}
/* enable internal 32kHz oscillator */
twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL,
TWL6040_CLK32KSEL);
/* disable 32kHz external clock */
if (pdata->set_ext_clk32k) {
ret = pdata->set_ext_clk32k(false);
if (ret)
dev_err(twl6040->dev,
"failed to disable CLK32K %d\n", ret);
}
twl6040->pll = TWL6040_NOPLL_ID;
twl6040->sysclk = 0;
}
twl6040->powered = enable;
return ret;
}
static int __devinit twl6040_probe(struct platform_device *pdev)
{
struct twl4030_audio_data *pdata = pdev->dev.platform_data;
struct twl6040 *twl6040;
struct mfd_cell *cell = NULL;
int ret, children = 0;
if (!pdata) {
dev_err(&pdev->dev, "Platform data is missing\n");
return -EINVAL;
}
/* In order to operate correctly we need valid interrupt config */
if (!pdata->naudint_irq || !pdata->irq_base) {
dev_err(&pdev->dev, "Invalid IRQ configuration\n");
return -EINVAL;
}
twl6040 = kzalloc(sizeof(struct twl6040), GFP_KERNEL);
if (!twl6040)
return -ENOMEM;
platform_set_drvdata(pdev, twl6040);
twl6040_dev = pdev;
twl6040->dev = &pdev->dev;
twl6040->audpwron = pdata->audpwron_gpio;
twl6040->irq = pdata->naudint_irq;
twl6040->irq_base = pdata->irq_base;
mutex_init(&twl6040->mutex);
mutex_init(&twl6040->io_mutex);
init_completion(&twl6040->ready);
twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
if (gpio_is_valid(twl6040->audpwron)) {
ret = gpio_request(twl6040->audpwron, "audpwron");
if (ret)
goto gpio1_err;
ret = gpio_direction_output(twl6040->audpwron, 0);
if (ret)
goto gpio2_err;
}
/* ERRATA: Automatic power-up is not possible in ES1.0 */
if (twl6040->rev == TWL6040_REV_ES1_0)
twl6040->audpwron = -EINVAL;
/* codec interrupt */
ret = twl6040_irq_init(twl6040);
if (ret)
goto gpio2_err;
ret = request_threaded_irq(twl6040->irq_base + TWL6040_IRQ_READY,
NULL, twl6040_naudint_handler, 0,
"twl6040_irq_ready", twl6040);
if (ret) {
dev_err(twl6040->dev, "READY IRQ request failed: %d\n",
ret);
goto irq_err;
}
/* dual-access registers controlled by I2C only */
twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL);
if (pdata->codec) {
int irq = twl6040->irq_base + TWL6040_IRQ_PLUG;
cell = &twl6040->cells[children];
cell->name = "twl6040-codec";
twl6040_codec_rsrc[0].start = irq;
twl6040_codec_rsrc[0].end = irq;
cell->resources = twl6040_codec_rsrc;
cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
cell->platform_data = pdata->codec;
cell->pdata_size = sizeof(*pdata->codec);
children++;
}
if (pdata->vibra) {
int irq = twl6040->irq_base + TWL6040_IRQ_VIB;
cell = &twl6040->cells[children];
cell->name = "twl6040-vibra";
twl6040_vibra_rsrc[0].start = irq;
twl6040_vibra_rsrc[0].end = irq;
cell->resources = twl6040_vibra_rsrc;
cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
cell->platform_data = pdata->vibra;
cell->pdata_size = sizeof(*pdata->vibra);
children++;
}
if (children) {
ret = mfd_add_devices(&pdev->dev, pdev->id, twl6040->cells,
children, NULL, 0);
if (ret)
goto mfd_err;
} else {
dev_err(&pdev->dev, "No platform data found for children\n");
ret = -ENODEV;
goto mfd_err;
}
return 0;
mfd_err:
free_irq(twl6040->irq_base + TWL6040_IRQ_READY, twl6040);
irq_err:
twl6040_irq_exit(twl6040);
gpio2_err:
if (gpio_is_valid(twl6040->audpwron))
gpio_free(twl6040->audpwron);
gpio1_err:
platform_set_drvdata(pdev, NULL);
kfree(twl6040);
twl6040_dev = NULL;
return ret;
}
