void __init msm_shared_pll_control_init(void)
{
#define PLL_REMOTE_SPINLOCK_ID "S:7"
unsigned smem_size;
remote_spin_lock_init(&pll_lock, PLL_REMOTE_SPINLOCK_ID);
pll_control = smem_get_entry(SMEM_CLKREGIM_SOURCES, &smem_size);
if (!pll_control) {
pr_err("Can't find shared PLL control data structure!\n");
BUG();
/*
* There might be more PLLs than what the application processor knows
* about. But the index used for each PLL is guaranteed to remain the
* same.
*/
} else if (smem_size < sizeof(struct shared_pll_control)) {
pr_err("Shared PLL control data"
"structure too small!\n");
BUG();
} else if (pll_control->version != 0xCCEE0001) {
pr_err("Shared PLL control version mismatch!\n");
BUG();
} else {
pr_info("Shared PLL control available.\n");
return;
}
}
void __init msm_shared_pll_control_init(void)
{
#define PLL_REMOTE_SPINLOCK_ID "S:7"
unsigned smem_size;
remote_spin_lock_init(&pll_lock, PLL_REMOTE_SPINLOCK_ID);
pll_control = smem_get_entry(SMEM_CLKREGIM_SOURCES, &smem_size);
if (!pll_control) {
pr_err("Can't find shared PLL control data structure!\n");
BUG();
} else if (smem_size < sizeof(struct shared_pll_control)) {
pr_err("Shared PLL control data"
"structure too small!\n");
BUG();
} else if (pll_control->version != 0xCCEE0001) {
pr_err("Shared PLL control version mismatch!\n");
BUG();
} else {
pr_info("Shared PLL control available.\n");
return;
}
}
static int __devinit msm_ssbi_probe(struct platform_device *pdev)
{
const struct msm_ssbi_platform_data *pdata = pdev->dev.platform_data;
struct resource *mem_res;
struct msm_ssbi *ssbi;
int ret = 0;
if (!pdata) {
pr_err("missing platform data\n");
return -EINVAL;
}
pr_debug("%s\n", pdata->slave.name);
ssbi = kzalloc(sizeof(struct msm_ssbi), GFP_KERNEL);
if (!ssbi) {
pr_err("can not allocate ssbi_data\n");
return -ENOMEM;
}
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem_res) {
pr_err("missing mem resource\n");
ret = -EINVAL;
goto err_get_mem_res;
}
ssbi->base = ioremap(mem_res->start, resource_size(mem_res));
if (!ssbi->base) {
pr_err("ioremap of 0x%p failed\n", (void *)mem_res->start);
ret = -EINVAL;
goto err_ioremap;
}
ssbi->dev = &pdev->dev;
platform_set_drvdata(pdev, ssbi);
ssbi->controller_type = pdata->controller_type;
if (ssbi->controller_type == MSM_SBI_CTRL_PMIC_ARBITER) {
ssbi->read = msm_ssbi_pa_read_bytes;
ssbi->write = msm_ssbi_pa_write_bytes;
} else {
ssbi->read = msm_ssbi_read_bytes;
ssbi->write = msm_ssbi_write_bytes;
}
if (pdata->rsl_id) {
ret = remote_spin_lock_init(&ssbi->rspin_lock, pdata->rsl_id);
if (ret) {
dev_err(&pdev->dev, "remote spinlock init failed\n");
goto err_ssbi_add_slave;
}
ssbi->use_rlock = 1;
}
spin_lock_init(&ssbi->lock);
ret = msm_ssbi_add_slave(ssbi, &pdata->slave);
if (ret)
goto err_ssbi_add_slave;
return 0;
err_ssbi_add_slave:
platform_set_drvdata(pdev, NULL);
iounmap(ssbi->base);
err_ioremap:
err_get_mem_res:
kfree(ssbi);
return ret;
}
static int __init i2c_ssbi_probe(struct platform_device *pdev)
{
int ret = 0;
struct resource *ssbi_res;
struct i2c_ssbi_dev *ssbi;
struct msm_ssbi_platform_data *pdata;
pdata = pdev->dev.platform_data;
if (!pdata) {
ret = -ENXIO;
dev_err(&pdev->dev, "platform data not initialized\n");
goto err_probe_exit;
}
ssbi = kzalloc(sizeof(struct i2c_ssbi_dev), GFP_KERNEL);
if (!ssbi) {
ret = -ENOMEM;
dev_err(&pdev->dev, "allocation failed\n");
goto err_probe_exit;
}
ssbi_res = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ssbi_base");
if (!ssbi_res) {
ret = -ENXIO;
dev_err(&pdev->dev, "get_resource_byname failed\n");
goto err_probe_res;
}
ssbi->mem_phys_addr = ssbi_res->start;
ssbi->mem_size = resource_size(ssbi_res);
if (!request_mem_region(ssbi->mem_phys_addr, ssbi->mem_size,
SSBI_MSM_NAME)) {
ret = -ENXIO;
dev_err(&pdev->dev, "request_mem_region failed\n");
goto err_probe_reqmem;
}
ssbi->base = ioremap(ssbi->mem_phys_addr, ssbi->mem_size);
if (!ssbi->base) {
dev_err(&pdev->dev, "ioremap failed\n");
goto err_probe_ioremap;
}
ssbi->dev = &pdev->dev;
platform_set_drvdata(pdev, ssbi);
ssbi->controller_type = pdata->controller_type;
if (ssbi->controller_type == MSM_SBI_CTRL_PMIC_ARBITER) {
ssbi->read = i2c_ssbi_pa_read_bytes;
ssbi->write = i2c_ssbi_pa_write_bytes;
} else {
ssbi->read = i2c_ssbi_read_bytes;
ssbi->write = i2c_ssbi_write_bytes;
}
i2c_set_adapdata(&ssbi->adapter, ssbi);
ssbi->adapter.algo = &msm_i2c_algo;
strlcpy(ssbi->adapter.name,
"MSM SSBI adapter",
sizeof(ssbi->adapter.name));
if (pdata->rsl_id) {
ret = remote_spin_lock_init(&ssbi->rspin_lock, pdata->rsl_id);
if (ret) {
dev_err(&pdev->dev, "remote spinlock init failed\n");
goto err_remote_spinlock_init_failed;
}
ssbi->use_rlock = 1;
}
ssbi->adapter.nr = pdev->id;
ret = i2c_add_numbered_adapter(&ssbi->adapter);
if (ret) {
dev_err(&pdev->dev, "i2c_add_numbered_adapter failed\n");
goto err_add_adapter_failed;
}
return 0;
err_add_adapter_failed:
err_remote_spinlock_init_failed:
iounmap(ssbi->base);
platform_set_drvdata(pdev, NULL);
err_probe_ioremap:
release_mem_region(ssbi->mem_phys_addr, ssbi->mem_size);
err_probe_reqmem:
err_probe_res:
kfree(ssbi);
err_probe_exit:
return ret;
}
static int
msm_i2c_probe(struct platform_device *pdev)
{
struct msm_i2c_dev *dev;
struct resource *mem, *irq, *ioarea;
int ret;
int fs_div;
int hs_div;
int i2c_clk;
int clk_ctl;
struct clk *clk;
struct msm_i2c_platform_data *pdata;
printk(KERN_INFO "msm_i2c_probe\n");
/* NOTE: driver uses the static register mapping */
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "no mem resource?\n");
return -ENODEV;
}
irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!irq) {
dev_err(&pdev->dev, "no irq resource?\n");
return -ENODEV;
}
ioarea = request_mem_region(mem->start, (mem->end - mem->start) + 1,
pdev->name);
if (!ioarea) {
dev_err(&pdev->dev, "I2C region already claimed\n");
return -EBUSY;
}
clk = clk_get(&pdev->dev, "i2c_clk");
if (IS_ERR(clk)) {
dev_err(&pdev->dev, "Could not get clock\n");
ret = PTR_ERR(clk);
goto err_clk_get_failed;
}
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "platform data not initialized\n");
ret = -ENOSYS;
goto err_clk_get_failed;
}
if (!pdata->msm_i2c_config_gpio) {
dev_err(&pdev->dev, "config_gpio function not initialized\n");
ret = -ENOSYS;
goto err_clk_get_failed;
}
/* We support frequencies upto FAST Mode(400KHz) */
if (pdata->clk_freq <= 0 || pdata->clk_freq > 400000) {
dev_err(&pdev->dev, "clock frequency not supported\n");
ret = -EIO;
goto err_clk_get_failed;
}
dev = kzalloc(sizeof(struct msm_i2c_dev), GFP_KERNEL);
if (!dev) {
ret = -ENOMEM;
goto err_alloc_dev_failed;
}
dev->dev = &pdev->dev;
dev->irq = irq->start;
dev->clk = clk;
dev->pdata = pdata;
dev->base = ioremap(mem->start, (mem->end - mem->start) + 1);
if (!dev->base) {
ret = -ENOMEM;
goto err_ioremap_failed;
}
spin_lock_init(&dev->lock);
platform_set_drvdata(pdev, dev);
clk_enable(clk);
if (pdata->rmutex != NULL)
remote_spin_lock_init(&dev->rspin_lock, pdata->rsl_id);
/* I2C_HS_CLK = I2C_CLK/(3*(HS_DIVIDER_VALUE+1) */
/* I2C_FS_CLK = I2C_CLK/(2*(FS_DIVIDER_VALUE+3) */
/* FS_DIVIDER_VALUE = ((I2C_CLK / I2C_FS_CLK) / 2) - 3 */
i2c_clk = 19200000; /* input clock */
fs_div = ((i2c_clk / pdata->clk_freq) / 2) - 3;
hs_div = 3;
clk_ctl = ((hs_div & 0x7) << 8) | (fs_div & 0xff);
writel(clk_ctl, dev->base + I2C_CLK_CTL);
printk(KERN_INFO "msm_i2c_probe: clk_ctl %x, %d Hz\n",
clk_ctl, i2c_clk / (2 * ((clk_ctl & 0xff) + 3)));
i2c_set_adapdata(&dev->adap_pri, dev);
dev->adap_pri.algo = &msm_i2c_algo;
strlcpy(dev->adap_pri.name,
"MSM I2C adapter-PRI",
sizeof(dev->adap_pri.name));
dev->adap_pri.nr = pdev->id;
ret = i2c_add_numbered_adapter(&dev->adap_pri);
if (ret) {
dev_err(&pdev->dev, "Primary i2c_add_adapter failed\n");
goto err_i2c_add_adapter_failed;
}
ret = request_irq(dev->irq, msm_i2c_interrupt,
IRQF_TRIGGER_RISING, pdev->name, dev);
if (ret) {
dev_err(&pdev->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, "msm_i2c",
PM_QOS_DEFAULT_VALUE);
disable_irq(dev->irq);
dev->suspended = 0;
mutex_init(&dev->mlock);
/* Config GPIOs for primary and secondary lines */
pdata->msm_i2c_config_gpio(dev->adap_pri.nr, 1);
return 0;
err_request_irq_failed:
i2c_del_adapter(&dev->adap_pri);
err_i2c_add_adapter_failed:
clk_disable(clk);
iounmap(dev->base);
err_ioremap_failed:
kfree(dev);
err_alloc_dev_failed:
clk_put(clk);
err_clk_get_failed:
release_mem_region(mem->start, (mem->end - mem->start) + 1);
return ret;
}
