static int stxh205_usb_exit(struct stm_device_state *device_state)
{
mutex_lock(&stxh205_usb_phy_mutex);
if (--stxh205_usb_phy_count == 0)
stm_pad_release(stxh205_usb_phy_state);
mutex_unlock(&stxh205_usb_phy_mutex);
return 0;
}
static void b2020_configure_tsin(bool freeze)
{
static struct stm_pad_state *tsin_pad = NULL;
if (!freeze) {
tsin_pad = stm_pad_claim(&b20202a_tsin_pad_config, "tsin");
}
else {
if (tsin_pad)
stm_pad_release(tsin_pad);
tsin_pad = NULL;
}
}
static void __stm_device_exit(struct stm_device_state *state)
{
struct stm_device_config *config = state->config;
int i;
stm_device_power(state, stm_device_power_off);
if (config->pad_config)
stm_pad_release(state->pad_state);
if (config->exit)
config->exit(state);
for (i = 0; i < config->sysconfs_num; i++)
sysconf_release(state->sysconf_fields[i]);
}
static int snd_stm_pcm_player_remove(struct platform_device *pdev)
{
struct snd_stm_pcm_player *pcm_player = platform_get_drvdata(pdev);
snd_stm_printd(1, "snd_stm_pcm_player_remove(pdev=%p)\n", pdev);
BUG_ON(!pcm_player);
BUG_ON(!snd_stm_magic_valid(pcm_player));
if (pcm_player->pads)
stm_pad_release(pcm_player->pads);
snd_stm_conv_unregister_source(pcm_player->conv_source);
snd_stm_buffer_dispose(pcm_player->buffer);
snd_stm_fdma_release(pcm_player->fdma_channel);
snd_stm_irq_release(pcm_player->irq, pcm_player);
snd_stm_memory_release(pcm_player->mem_region, pcm_player->base);
snd_stm_magic_clear(pcm_player);
kfree(pcm_player);
return 0;
}
static int spi_stm_remove(struct platform_device *pdev)
{
struct spi_stm *spi_stm;
struct spi_master *master;
master = platform_get_drvdata(pdev);
spi_stm = spi_master_get_devdata(master);
spi_bitbang_stop(&spi_stm->bitbang);
clk_disable(spi_stm->clk);
stm_pad_release(spi_stm->pad_state);
free_irq(spi_stm->r_irq.start, spi_stm);
iounmap(spi_stm->base);
release_mem_region(spi_stm->r_mem.start,
resource_size(&spi_stm->r_mem));
spi_master_put(spi_stm->bitbang.master);
platform_set_drvdata(pdev, NULL);
return 0;
}
static int __init spi_stm_probe(struct platform_device *pdev)
{
struct stm_plat_ssc_data *plat_data = pdev->dev.platform_data;
struct spi_master *master;
struct resource *res;
struct spi_stm *spi_stm;
u32 reg;
int status = 0;
master = spi_alloc_master(&pdev->dev, sizeof(struct spi_stm));
if (!master) {
dev_err(&pdev->dev, "failed to allocate spi master\n");
status = -ENOMEM;
goto err0;
}
platform_set_drvdata(pdev, master);
spi_stm = spi_master_get_devdata(master);
spi_stm->bitbang.master = spi_master_get(master);
spi_stm->bitbang.setup_transfer = spi_stm_setup_transfer;
spi_stm->bitbang.txrx_bufs = spi_stm_txrx_bufs;
spi_stm->bitbang.master->setup = spi_stm_setup;
spi_stm->bitbang.master->cleanup = spi_stm_cleanup;
if (plat_data->spi_chipselect)
spi_stm->bitbang.chipselect = plat_data->spi_chipselect;
else
spi_stm->bitbang.chipselect = spi_stm_gpio_chipselect;
/* the spi->mode bits understood by this driver: */
master->mode_bits = MODEBITS;
/* chip_select field of spi_device is declared as u8 and therefore
* limits number of GPIOs that can be used as a CS line. Sorry. */
master->num_chipselect =
sizeof(((struct spi_device *)0)->chip_select) * 256;
master->bus_num = pdev->id;
init_completion(&spi_stm->done);
/* Get resources */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "failed to find IOMEM resource\n");
status = -ENOENT;
goto err1;
}
spi_stm->r_mem = *res;
if (!request_mem_region(res->start,
res->end - res->start + 1, NAME)) {
dev_err(&pdev->dev, "request memory region failed [0x%x]\n",
res->start);
status = -EBUSY;
goto err1;
}
spi_stm->base = ioremap_nocache(res->start, res->end - res->start + 1);
if (!spi_stm->base) {
dev_err(&pdev->dev, "ioremap memory failed [0x%x]\n",
res->start);
status = -ENXIO;
goto err2;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(&pdev->dev, "failed to find IRQ resource\n");
status = -ENOENT;
goto err3;
}
spi_stm->r_irq = *res;
if (request_irq(res->start, spi_stm_irq,
IRQF_DISABLED, dev_name(&pdev->dev), spi_stm)) {
dev_err(&pdev->dev, "irq request failed\n");
status = -EBUSY;
goto err3;
}
spi_stm->pad_state = stm_pad_claim(plat_data->pad_config,
dev_name(&pdev->dev));
if (!spi_stm->pad_state) {
dev_err(&pdev->dev, "pads request failed\n");
status = -EBUSY;
goto err4;
}
/* Disable I2C and Reset SSC */
ssc_store32(spi_stm, SSC_I2C, 0x0);
reg = ssc_load16(spi_stm, SSC_CTL);
reg |= SSC_CTL_SR;
ssc_store32(spi_stm, SSC_CTL, reg);
udelay(1);
reg = ssc_load32(spi_stm, SSC_CTL);
reg &= ~SSC_CTL_SR;
ssc_store32(spi_stm, SSC_CTL, reg);
/* Set SSC into slave mode before reconfiguring PIO pins */
reg = ssc_load32(spi_stm, SSC_CTL);
reg &= ~SSC_CTL_MS;
ssc_store32(spi_stm, SSC_CTL, reg);
spi_stm->clk = clk_get(&pdev->dev, "comms_clk");
if (!spi_stm->clk) {
dev_err(&pdev->dev, "Comms clock not found!\n");
goto err5;
}
clk_enable(spi_stm->clk);
/* Start "bitbang" worker */
status = spi_bitbang_start(&spi_stm->bitbang);
if (status) {
dev_err(&pdev->dev, "bitbang start failed [%d]\n", status);
goto err5;
}
dev_info(&pdev->dev, "registered SPI Bus %d\n", master->bus_num);
return status;
err5:
stm_pad_release(spi_stm->pad_state);
err4:
free_irq(spi_stm->r_irq.start, spi_stm);
err3:
iounmap(spi_stm->base);
err2:
release_mem_region(spi_stm->r_mem.start,
resource_size(&spi_stm->r_mem));
err1:
spi_master_put(spi_stm->bitbang.master);
platform_set_drvdata(pdev, NULL);
err0:
return status;
}
