/* * registering functions to load algorithms at runtime * Prior to calling us, the 50MHz clock frequency and routing * must have been set up for the PSC indicated by the adapter. */ static int i2c_au1550_probe(struct platform_device *pdev) { struct i2c_au1550_data *priv; struct resource *r; int ret; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) { ret = -ENODEV; goto out; } priv = kzalloc(sizeof(struct i2c_au1550_data), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto out; } priv->ioarea = request_mem_region(r->start, resource_size(r), pdev->name); if (!priv->ioarea) { ret = -EBUSY; goto out_mem; } priv->psc_base = ioremap(r->start, resource_size(r)); if (!priv->psc_base) { ret = -EIO; goto out_map; } priv->xfer_timeout = 200; priv->adap.nr = pdev->id; priv->adap.algo = &au1550_algo; priv->adap.algo_data = priv; priv->adap.dev.parent = &pdev->dev; strlcpy(priv->adap.name, "Au1xxx PSC I2C", sizeof(priv->adap.name)); /* Now, set up the PSC for SMBus PIO mode. */ i2c_au1550_setup(priv); ret = i2c_add_numbered_adapter(&priv->adap); if (ret == 0) { platform_set_drvdata(pdev, priv); return 0; } i2c_au1550_disable(priv); iounmap(priv->psc_base); out_map: release_resource(priv->ioarea); kfree(priv->ioarea); out_mem: kfree(priv); out: return ret; }
static int __devinit i2c_platform_probe(struct platform_device *pdev) { struct i2c_platform_data *priv; struct resource *r; int ret; pr_debug("i2c_platform_probe\n"); r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) { ret = -ENODEV; goto out; } priv = kzalloc(sizeof(struct i2c_platform_data), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto out; } /* FIXME: need to allocate resource in PIC32 space */ #if 0 priv->base = bus_request_region(r->start, resource_size(r), pdev->name); #else priv->base = r->start; #endif if (!priv->base) { ret = -EBUSY; goto out_mem; } priv->xfer_timeout = 200; priv->ack_timeout = 200; priv->ctl_timeout = 200; priv->adap.nr = pdev->id; priv->adap.algo = &platform_algo; priv->adap.algo_data = priv; priv->adap.dev.parent = &pdev->dev; strlcpy(priv->adap.name, "PIC32 I2C", sizeof(priv->adap.name)); i2c_platform_setup(priv); ret = i2c_add_numbered_adapter(&priv->adap); if (ret == 0) { platform_set_drvdata(pdev, priv); return 0; } i2c_platform_disable(priv); out_mem: kfree(priv); out: return ret; }
int i2c_pca_add_numbered_bus(struct i2c_adapter *adap) { int rval; rval = pca_init(adap); if (rval) return rval; return i2c_add_numbered_adapter(adap); }
static int __init i2c_fsl_probe(struct device_d *pdev) { struct fsl_i2c_struct *i2c_fsl; struct i2c_platform_data *pdata; int ret; pdata = pdev->platform_data; i2c_fsl = xzalloc(sizeof(*i2c_fsl)); #ifdef CONFIG_COMMON_CLK i2c_fsl->clk = clk_get(pdev, NULL); if (IS_ERR(i2c_fsl->clk)) { ret = PTR_ERR(i2c_fsl->clk); goto fail; } #endif /* Setup i2c_fsl driver structure */ i2c_fsl->adapter.master_xfer = i2c_fsl_xfer; i2c_fsl->adapter.nr = pdev->id; i2c_fsl->adapter.dev.parent = pdev; i2c_fsl->adapter.dev.device_node = pdev->device_node; i2c_fsl->base = dev_request_mem_region(pdev, 0); if (IS_ERR(i2c_fsl->base)) { ret = PTR_ERR(i2c_fsl->base); goto fail; } i2c_fsl_init_recovery(i2c_fsl, pdev); i2c_fsl->dfsrr = -1; /* Set up clock divider */ if (pdata && pdata->bitrate) i2c_fsl_set_clk(i2c_fsl, pdata->bitrate); else i2c_fsl_set_clk(i2c_fsl, FSL_I2C_BIT_RATE); /* Set up chip registers to defaults */ writeb(0, i2c_fsl->base + FSL_I2C_I2CR); writeb(0, i2c_fsl->base + FSL_I2C_I2SR); /* Add I2C adapter */ ret = i2c_add_numbered_adapter(&i2c_fsl->adapter); if (ret < 0) { dev_err(pdev, "registration failed\n"); goto fail; } return 0; fail: kfree(i2c_fsl); return ret; }
struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent, void *mux_dev, u32 force_nr, u32 chan_id, int (*select) (struct i2c_adapter *, void *, u32), int (*deselect) (struct i2c_adapter *, void *, u32)) { struct i2c_mux_priv *priv; int ret; priv = kzalloc(sizeof(struct i2c_mux_priv), GFP_KERNEL); if (!priv) return NULL; priv->parent = parent; priv->mux_dev = mux_dev; priv->chan_id = chan_id; priv->select = select; priv->deselect = deselect; if (parent->algo->master_xfer) priv->algo.master_xfer = i2c_mux_master_xfer; if (parent->algo->smbus_xfer) priv->algo.smbus_xfer = i2c_mux_smbus_xfer; priv->algo.functionality = i2c_mux_functionality; snprintf(priv->adap.name, sizeof(priv->adap.name), "i2c-%d-mux (chan_id %d)", i2c_adapter_id(parent), chan_id); priv->adap.owner = THIS_MODULE; priv->adap.algo = &priv->algo; priv->adap.algo_data = priv; priv->adap.dev.parent = &parent->dev; if (force_nr) { priv->adap.nr = force_nr; ret = i2c_add_numbered_adapter(&priv->adap); } else { ret = i2c_add_adapter(&priv->adap); } if (ret < 0) { dev_err(&parent->dev, "failed to add mux-adapter (error=%d)\n", ret); kfree(priv); return NULL; } dev_info(&parent->dev, "Added multiplexed i2c bus %d\n", i2c_adapter_id(&priv->adap)); return &priv->adap; }
int i2c_add_rk30_adapter(struct i2c_adapter *adap) { int ret = 0; struct rk30_i2c *i2c = (struct rk30_i2c *)adap->algo_data; adap->algo = &rk30_i2c_algorithm; i2c->i2c_init_hw = &rk30_i2c_init_hw; i2c->i2c_set_clk = &rk30_i2c_set_clk; i2c->i2c_irq = &rk30_i2c_irq; ret = i2c_add_numbered_adapter(adap); return ret; }
static int sead3_i2c_platform_probe(struct platform_device *pdev) { struct pic32_i2c_platform_data *priv; struct resource *r; int ret; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) { ret = -ENODEV; goto out; } priv = kzalloc(sizeof(struct pic32_i2c_platform_data), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto out; } priv->base = r->start; if (!priv->base) { ret = -EBUSY; goto out_mem; } priv->xfer_timeout = 200; priv->ack_timeout = 200; priv->ctl_timeout = 200; priv->adap.nr = pdev->id; priv->adap.algo = &sead3_platform_algo; priv->adap.algo_data = priv; priv->adap.dev.parent = &pdev->dev; strlcpy(priv->adap.name, "SEAD3 PIC32", sizeof(priv->adap.name)); sead3_i2c_platform_setup(priv); ret = i2c_add_numbered_adapter(&priv->adap); if (ret == 0) { platform_set_drvdata(pdev, priv); return 0; } out_mem: kfree(priv); out: return ret; }
int oaktrail_hdmi_i2c_init(struct pci_dev *dev) { struct oaktrail_hdmi_dev *hdmi_dev; struct hdmi_i2c_dev *i2c_dev; int ret; hdmi_dev = pci_get_drvdata(dev); i2c_dev = kzalloc(sizeof(struct hdmi_i2c_dev), GFP_KERNEL); if (i2c_dev == NULL) { DRM_ERROR("Can't allocate interface\n"); ret = -ENOMEM; goto exit; } i2c_dev->adap = &oaktrail_hdmi_i2c_adapter; i2c_dev->status = I2C_STAT_INIT; init_completion(&i2c_dev->complete); mutex_init(&i2c_dev->i2c_lock); i2c_set_adapdata(&oaktrail_hdmi_i2c_adapter, hdmi_dev); hdmi_dev->i2c_dev = i2c_dev; /* Enable HDMI I2C function on gpio */ oaktrail_hdmi_i2c_gpio_fix(); /* request irq */ ret = request_irq(dev->irq, oaktrail_hdmi_i2c_handler, IRQF_SHARED, oaktrail_hdmi_i2c_adapter.name, hdmi_dev); if (ret) { DRM_ERROR("Failed to request IRQ for I2C controller\n"); goto err; } /* Adapter registration */ ret = i2c_add_numbered_adapter(&oaktrail_hdmi_i2c_adapter); return ret; err: kfree(i2c_dev); exit: return ret; }
static int __init i2c_imx_probe(struct device_d *pdev) { struct imx_i2c_struct *i2c_imx; struct i2c_platform_data *pdata; unsigned long base = pdev->map_base; int ret; pdata = pdev->platform_data; i2c_imx = kzalloc(sizeof(struct imx_i2c_struct), GFP_KERNEL); /* Setup i2c_imx driver structure */ i2c_imx->adapter.master_xfer = i2c_imx_xfer; i2c_imx->adapter.nr = pdev->id; i2c_imx->adapter.dev = pdev; /* Set up clock divider */ if (pdata && pdata->bitrate) i2c_imx_set_clk(i2c_imx, pdata->bitrate); else i2c_imx_set_clk(i2c_imx, IMX_I2C_BIT_RATE); /* Set up chip registers to defaults */ writeb(0, base + IMX_I2C_I2CR); writeb(0, base + IMX_I2C_I2SR); /* Add I2C adapter */ ret = i2c_add_numbered_adapter(&i2c_imx->adapter); if (ret < 0) { dev_err(pdev, "registration failed\n"); goto fail; } return 0; fail: kfree(i2c_imx); return ret; }
/*! * This function is called during the driver binding process. * * @param pdev the device structure used to store device specific * information that is used by the suspend, resume and remove * functions * * @return The function always returns 0. */ static int mxci2c_probe(struct platform_device *pdev) { mxc_i2c_device *mxc_i2c; struct mxc_i2c_platform_data *i2c_plat_data = pdev->dev.platform_data; struct resource *res; int id = pdev->id; u32 clk_freq; int ret = 0; int i; mxc_i2c = kzalloc(sizeof(mxc_i2c_device), GFP_KERNEL); if (!mxc_i2c) { return -ENOMEM; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { ret = -ENODEV; goto err1; } mxc_i2c->membase = ioremap(res->start, res->end - res->start + 1); /* * Request the I2C interrupt */ mxc_i2c->irq = platform_get_irq(pdev, 0); if (mxc_i2c->irq < 0) { ret = mxc_i2c->irq; goto err2; } ret = request_irq(mxc_i2c->irq, mxc_i2c_handler, 0, pdev->name, mxc_i2c); if (ret < 0) { goto err2; } init_waitqueue_head(&mxc_i2c->wq); mxc_i2c->low_power = false; gpio_i2c_active(id); mxc_i2c->clk = clk_get(&pdev->dev, "i2c_clk"); clk_freq = clk_get_rate(mxc_i2c->clk); mxc_i2c->clkdiv = -1; if (i2c_plat_data->i2c_clk) { /* Calculate divider and round up any fractional part */ int div = (clk_freq + i2c_plat_data->i2c_clk - 1) / i2c_plat_data->i2c_clk; for (i = 0; i2c_clk_table[i].div != 0; i++) { if (i2c_clk_table[i].div >= div) { mxc_i2c->clkdiv = i2c_clk_table[i].reg_value; break; } } } if (mxc_i2c->clkdiv == -1) { i--; mxc_i2c->clkdiv = 0x1F; /* Use max divider */ } dev_dbg(&pdev->dev, "i2c speed is %d/%d = %d bps, reg val = 0x%02X\n", clk_freq, i2c_clk_table[i].div, clk_freq / i2c_clk_table[i].div, mxc_i2c->clkdiv); /* * Set the adapter information */ strlcpy(mxc_i2c->adap.name, pdev->name, 48); mxc_i2c->adap.id = mxc_i2c->adap.nr = id; mxc_i2c->adap.algo = &mxc_i2c_algorithm; mxc_i2c->adap.timeout = 1; platform_set_drvdata(pdev, mxc_i2c); i2c_set_adapdata(&mxc_i2c->adap, mxc_i2c); ret = i2c_add_numbered_adapter(&mxc_i2c->adap); if (ret < 0) goto err3; printk(KERN_INFO "MXC I2C driver\n"); return 0; err3: free_irq(mxc_i2c->irq, mxc_i2c); gpio_i2c_inactive(id); err2: iounmap(mxc_i2c->membase); err1: dev_err(&pdev->dev, "failed to probe i2c adapter\n"); kfree(mxc_i2c); return ret; }
static int __devinit i2c_pnx_probe(struct platform_device *pdev) { unsigned long tmp; int ret = 0; struct i2c_pnx_algo_data *alg_data; int freq_mhz; struct i2c_pnx_data *i2c_pnx = pdev->dev.platform_data; if (!i2c_pnx || !i2c_pnx->adapter) { dev_err(&pdev->dev, "%s: no platform data supplied\n", __func__); ret = -EINVAL; goto out; } platform_set_drvdata(pdev, i2c_pnx); if (i2c_pnx->calculate_input_freq) freq_mhz = i2c_pnx->calculate_input_freq(pdev); else { freq_mhz = PNX_DEFAULT_FREQ; dev_info(&pdev->dev, "Setting bus frequency to default value: " "%d MHz\n", freq_mhz); } i2c_pnx->adapter->algo = &pnx_algorithm; alg_data = i2c_pnx->adapter->algo_data; init_timer(&alg_data->mif.timer); alg_data->mif.timer.function = i2c_pnx_timeout; alg_data->mif.timer.data = (unsigned long)i2c_pnx->adapter; /* Register I/O resource */ if (!request_region(alg_data->base, I2C_PNX_REGION_SIZE, pdev->name)) { dev_err(&pdev->dev, "I/O region 0x%08x for I2C already in use.\n", alg_data->base); ret = -ENODEV; goto out_drvdata; } if (!(alg_data->ioaddr = (u32)ioremap(alg_data->base, I2C_PNX_REGION_SIZE))) { dev_err(&pdev->dev, "Couldn't ioremap I2C I/O region\n"); ret = -ENOMEM; goto out_release; } i2c_pnx->set_clock_run(pdev); /* * Clock Divisor High This value is the number of system clocks * the serial clock (SCL) will be high. * For example, if the system clock period is 50 ns and the maximum * desired serial period is 10000 ns (100 kHz), then CLKHI would be * set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value * programmed into CLKHI will vary from this slightly due to * variations in the output pad's rise and fall times as well as * the deglitching filter length. */ tmp = ((freq_mhz * 1000) / I2C_PNX_SPEED_KHZ) / 2 - 2; iowrite32(tmp, I2C_REG_CKH(alg_data)); iowrite32(tmp, I2C_REG_CKL(alg_data)); iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data)); if (wait_reset(I2C_PNX_TIMEOUT, alg_data)) { ret = -ENODEV; goto out_unmap; } init_completion(&alg_data->mif.complete); ret = request_irq(alg_data->irq, i2c_pnx_interrupt, 0, pdev->name, i2c_pnx->adapter); if (ret) goto out_clock; /* Register this adapter with the I2C subsystem */ i2c_pnx->adapter->dev.parent = &pdev->dev; i2c_pnx->adapter->nr = pdev->id; ret = i2c_add_numbered_adapter(i2c_pnx->adapter); if (ret < 0) { dev_err(&pdev->dev, "I2C: Failed to add bus\n"); goto out_irq; } dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n", i2c_pnx->adapter->name, alg_data->base, alg_data->irq); return 0; out_irq: free_irq(alg_data->irq, alg_data); out_clock: i2c_pnx->set_clock_stop(pdev); out_unmap: iounmap((void *)alg_data->ioaddr); out_release: release_region(alg_data->base, I2C_PNX_REGION_SIZE); out_drvdata: platform_set_drvdata(pdev, NULL); out: 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; int target_clk; 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; } target_clk = pdata->clk_freq; /* We support frequencies upto FAST Mode(400KHz) */ if (target_clk <= 0 || target_clk > 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->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); /* 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 / target_clk) / 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->adapter, dev); dev->adapter.algo = &msm_i2c_algo; strncpy(dev->adapter.name, "MSM I2C adapter", sizeof(dev->adapter.name)); dev->adapter.nr = pdev->id; ret = i2c_add_numbered_adapter(&dev->adapter); if (ret) { dev_err(&pdev->dev, "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; } return 0; /* free_irq(dev->irq, dev); */ err_request_irq_failed: i2c_del_adapter(&dev->adapter); 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; }
int i2c_dw_probe(struct dw_i2c_dev *dev) { struct i2c_adapter *adap = &dev->adapter; unsigned long irq_flags; int ret; init_completion(&dev->cmd_complete); dev->init = i2c_dw_init_master; dev->disable = i2c_dw_disable; dev->disable_int = i2c_dw_disable_int; ret = i2c_dw_set_reg_access(dev); if (ret) return ret; ret = i2c_dw_set_timings_master(dev); if (ret) return ret; ret = dev->init(dev); if (ret) return ret; snprintf(adap->name, sizeof(adap->name), "Synopsys DesignWare I2C adapter"); adap->retries = 3; adap->algo = &i2c_dw_algo; adap->quirks = &i2c_dw_quirks; adap->dev.parent = dev->dev; i2c_set_adapdata(adap, dev); if (dev->flags & ACCESS_NO_IRQ_SUSPEND) { irq_flags = IRQF_NO_SUSPEND; } else { irq_flags = IRQF_SHARED | IRQF_COND_SUSPEND; } i2c_dw_disable_int(dev); ret = devm_request_irq(dev->dev, dev->irq, i2c_dw_isr, irq_flags, dev_name(dev->dev), dev); if (ret) { dev_err(dev->dev, "failure requesting irq %i: %d\n", dev->irq, ret); return ret; } ret = i2c_dw_init_recovery_info(dev); if (ret) return ret; /* * Increment PM usage count during adapter registration in order to * avoid possible spurious runtime suspend when adapter device is * registered to the device core and immediate resume in case bus has * registered I2C slaves that do I2C transfers in their probe. */ pm_runtime_get_noresume(dev->dev); ret = i2c_add_numbered_adapter(adap); if (ret) dev_err(dev->dev, "failure adding adapter: %d\n", ret); pm_runtime_put_noidle(dev->dev); return ret; }
/* * registering functions to load algorithms at runtime * Prior to calling us, the 50MHz clock frequency and routing * must have been set up for the PSC indicated by the adapter. */ static int __devinit i2c_au1550_probe(struct platform_device *pdev) { struct i2c_au1550_data *priv; volatile psc_smb_t *sp; struct resource *r; u32 stat; int ret; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) { ret = -ENODEV; goto out; } priv = kzalloc(sizeof(struct i2c_au1550_data), GFP_KERNEL); if (!priv) { ret = -ENOMEM; goto out; } priv->ioarea = request_mem_region(r->start, r->end - r->start + 1, pdev->name); if (!priv->ioarea) { ret = -EBUSY; goto out_mem; } priv->psc_base = r->start; priv->xfer_timeout = 200; priv->ack_timeout = 200; priv->adap.id = I2C_HW_AU1550_PSC; priv->adap.nr = pdev->id; priv->adap.algo = &au1550_algo; priv->adap.algo_data = priv; priv->adap.dev.parent = &pdev->dev; strlcpy(priv->adap.name, "Au1xxx PSC I2C", sizeof(priv->adap.name)); /* Now, set up the PSC for SMBus PIO mode. */ sp = (volatile psc_smb_t *)priv->psc_base; sp->psc_ctrl = PSC_CTRL_DISABLE; au_sync(); sp->psc_sel = PSC_SEL_PS_SMBUSMODE; sp->psc_smbcfg = 0; au_sync(); sp->psc_ctrl = PSC_CTRL_ENABLE; au_sync(); do { stat = sp->psc_smbstat; au_sync(); } while ((stat & PSC_SMBSTAT_SR) == 0); sp->psc_smbcfg = (PSC_SMBCFG_RT_FIFO8 | PSC_SMBCFG_TT_FIFO8 | PSC_SMBCFG_DD_DISABLE); /* Divide by 8 to get a 6.25 MHz clock. The later protocol * timings are based on this clock. */ sp->psc_smbcfg |= PSC_SMBCFG_SET_DIV(PSC_SMBCFG_DIV8); sp->psc_smbmsk = PSC_SMBMSK_ALLMASK; au_sync(); /* Set the protocol timer values. See Table 71 in the * Au1550 Data Book for standard timing values. */ sp->psc_smbtmr = PSC_SMBTMR_SET_TH(0) | PSC_SMBTMR_SET_PS(15) | \ PSC_SMBTMR_SET_PU(15) | PSC_SMBTMR_SET_SH(15) | \ PSC_SMBTMR_SET_SU(15) | PSC_SMBTMR_SET_CL(15) | \ PSC_SMBTMR_SET_CH(15); au_sync(); sp->psc_smbcfg |= PSC_SMBCFG_DE_ENABLE; do { stat = sp->psc_smbstat; au_sync(); } while ((stat & PSC_SMBSTAT_DR) == 0); ret = i2c_add_numbered_adapter(&priv->adap); if (ret == 0) { platform_set_drvdata(pdev, priv); return 0; } /* disable the PSC */ sp->psc_smbcfg = 0; sp->psc_ctrl = PSC_CTRL_DISABLE; au_sync(); release_resource(priv->ioarea); kfree(priv->ioarea); out_mem: kfree(priv); out: return ret; }
static int i2c_pnx_probe(struct platform_device *pdev) { unsigned long tmp; int ret = 0; struct i2c_pnx_algo_data *alg_data; unsigned long freq; struct resource *res; u32 speed = I2C_PNX_SPEED_KHZ_DEFAULT * 1000; alg_data = devm_kzalloc(&pdev->dev, sizeof(*alg_data), GFP_KERNEL); if (!alg_data) return -ENOMEM; platform_set_drvdata(pdev, alg_data); alg_data->adapter.dev.parent = &pdev->dev; alg_data->adapter.algo = &pnx_algorithm; alg_data->adapter.algo_data = alg_data; alg_data->adapter.nr = pdev->id; alg_data->timeout = I2C_PNX_TIMEOUT_DEFAULT; #ifdef CONFIG_OF alg_data->adapter.dev.of_node = of_node_get(pdev->dev.of_node); if (pdev->dev.of_node) { of_property_read_u32(pdev->dev.of_node, "clock-frequency", &speed); /* * At this point, it is planned to add an OF timeout property. * As soon as there is a consensus about how to call and handle * this, sth. like the following can be put here: * * of_property_read_u32(pdev->dev.of_node, "timeout", * &alg_data->timeout); */ } #endif alg_data->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(alg_data->clk)) return PTR_ERR(alg_data->clk); init_timer(&alg_data->mif.timer); alg_data->mif.timer.function = i2c_pnx_timeout; alg_data->mif.timer.data = (unsigned long)alg_data; snprintf(alg_data->adapter.name, sizeof(alg_data->adapter.name), "%s", pdev->name); /* Register I/O resource */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); alg_data->ioaddr = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(alg_data->ioaddr)) return PTR_ERR(alg_data->ioaddr); ret = clk_prepare_enable(alg_data->clk); if (ret) return ret; freq = clk_get_rate(alg_data->clk); /* * Clock Divisor High This value is the number of system clocks * the serial clock (SCL) will be high. * For example, if the system clock period is 50 ns and the maximum * desired serial period is 10000 ns (100 kHz), then CLKHI would be * set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value * programmed into CLKHI will vary from this slightly due to * variations in the output pad's rise and fall times as well as * the deglitching filter length. */ tmp = (freq / speed) / 2 - 2; if (tmp > 0x3FF) tmp = 0x3FF; iowrite32(tmp, I2C_REG_CKH(alg_data)); iowrite32(tmp, I2C_REG_CKL(alg_data)); iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data)); if (wait_reset(alg_data)) { ret = -ENODEV; goto out_clock; } init_completion(&alg_data->mif.complete); alg_data->irq = platform_get_irq(pdev, 0); if (alg_data->irq < 0) { dev_err(&pdev->dev, "Failed to get IRQ from platform resource\n"); ret = alg_data->irq; goto out_clock; } ret = devm_request_irq(&pdev->dev, alg_data->irq, i2c_pnx_interrupt, 0, pdev->name, alg_data); if (ret) goto out_clock; /* Register this adapter with the I2C subsystem */ ret = i2c_add_numbered_adapter(&alg_data->adapter); if (ret < 0) { dev_err(&pdev->dev, "I2C: Failed to add bus\n"); goto out_clock; } dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n", alg_data->adapter.name, res->start, alg_data->irq); return 0; out_clock: clk_disable_unprepare(alg_data->clk); return ret; }
static int sh_mobile_i2c_probe(struct platform_device *dev) { struct sh_mobile_i2c_data *pd; struct i2c_adapter *adap; struct resource *res; const struct sh_mobile_dt_config *config; int ret; u32 bus_speed; pd = devm_kzalloc(&dev->dev, sizeof(struct sh_mobile_i2c_data), GFP_KERNEL); if (!pd) return -ENOMEM; pd->clk = devm_clk_get(&dev->dev, NULL); if (IS_ERR(pd->clk)) { dev_err(&dev->dev, "cannot get clock\n"); return PTR_ERR(pd->clk); } ret = sh_mobile_i2c_hook_irqs(dev, pd); if (ret) return ret; pd->dev = &dev->dev; platform_set_drvdata(dev, pd); res = platform_get_resource(dev, IORESOURCE_MEM, 0); pd->res = res; pd->reg = devm_ioremap_resource(&dev->dev, res); if (IS_ERR(pd->reg)) return PTR_ERR(pd->reg); ret = of_property_read_u32(dev->dev.of_node, "clock-frequency", &bus_speed); pd->bus_speed = (ret || !bus_speed) ? STANDARD_MODE : bus_speed; pd->clks_per_count = 1; /* Newer variants come with two new bits in ICIC */ if (resource_size(res) > 0x17) pd->flags |= IIC_FLAG_HAS_ICIC67; pm_runtime_enable(&dev->dev); pm_runtime_get_sync(&dev->dev); config = of_device_get_match_data(&dev->dev); if (config) { pd->clks_per_count = config->clks_per_count; ret = config->setup(pd); } else { ret = sh_mobile_i2c_init(pd); } pm_runtime_put_sync(&dev->dev); if (ret) return ret; /* Init DMA */ sg_init_table(&pd->sg, 1); pd->dma_direction = DMA_NONE; pd->dma_rx = pd->dma_tx = ERR_PTR(-EPROBE_DEFER); /* setup the private data */ adap = &pd->adap; i2c_set_adapdata(adap, pd); adap->owner = THIS_MODULE; adap->algo = &sh_mobile_i2c_algorithm; adap->quirks = &sh_mobile_i2c_quirks; adap->dev.parent = &dev->dev; adap->retries = 5; adap->nr = dev->id; adap->dev.of_node = dev->dev.of_node; strlcpy(adap->name, dev->name, sizeof(adap->name)); spin_lock_init(&pd->lock); init_waitqueue_head(&pd->wait); ret = i2c_add_numbered_adapter(adap); if (ret < 0) { sh_mobile_i2c_release_dma(pd); return ret; } dev_info(&dev->dev, "I2C adapter %d, bus speed %lu Hz\n", adap->nr, pd->bus_speed); return 0; }
static int i2c_lpc2k_probe(struct platform_device *dev) { struct lpc2k_i2c *i2c; struct resource *res; int ret, irq; unsigned long clkrate; res = platform_get_resource(dev, IORESOURCE_MEM, 0); irq = platform_get_irq(dev, 0); if (res == NULL || irq < 0) { dev_err(&dev->dev, "No resource data!\n"); return -ENODEV; } if (dev->id < 0 || dev->id >= LPC24XX_MAX_ADAPTERS) { dev_err(&dev->dev, "I2C bus number invalid (%d)\n", dev->id); return -ENODEV; } if (!request_mem_region(res->start, resource_size(res), res->name)) { dev_err(&dev->dev, "Memory region already used!\n"); return -ENOMEM; } i2c = kzalloc(sizeof(struct lpc2k_i2c), GFP_KERNEL); if (!i2c) { dev_err(&dev->dev, "Error allocating memory!\n"); ret = -ENOMEM; goto emalloc; } i2c->adap.owner = THIS_MODULE; init_waitqueue_head(&i2c->wait); i2c->adap.nr = dev->id; snprintf(i2c->adap.name, sizeof(i2c->adap.name), MODULE_NAME ".%u", i2c->adap.nr); i2c->clk = clk_get(&dev->dev, NULL); if (IS_ERR(i2c->clk)) { dev_err(&dev->dev, "Error getting clock!\n"); ret = PTR_ERR(i2c->clk); goto eclk; } i2c->reg_base = ioremap(res->start, resource_size(res)); if (!i2c->reg_base) { dev_err(&dev->dev, "Error mapping memory!\n"); ret = -EIO; goto eremap; } i2c->iobase = res->start; i2c->iosize = resource_size(res); i2c->irq = irq; clk_enable(i2c->clk); i2c->adap.algo = &i2c_lpc2k_algorithm; ret = request_irq(irq, i2c_lpc2k_handler, IRQF_DISABLED, i2c->adap.name, i2c); if (ret) goto ereqirq; disable_irq_nosync(irq); i2c_lpc2k_reset(i2c); i2c->adap.algo_data = i2c; i2c->adap.dev.parent = &dev->dev; ret = i2c_add_numbered_adapter(&i2c->adap); if (ret < 0) { dev_err(&dev->dev, "Failed to add bus!\n"); goto eadapt; } platform_set_drvdata(dev, i2c); printk(KERN_INFO "I2C: %s: LPC2K I2C adapter\n", dev_name(&i2c->adap.dev)); /* Place controller is a known state */ i2c_lpc2k_reset(i2c); /* Get I2C base clock rate */ clkrate = clk_get_rate(i2c->clk); if (!clkrate) { dev_warn(&dev->dev, "Can't get I2C base clock, using " "12MHz!\n"); clkrate = 12000000; } /* Setup I2C dividers to generate clock rate with 50% duty cycle */ clkrate = (clkrate / scl_frequency) / 2; i2c_writel(clkrate, i2c->reg_base + LPC24XX_I2SCLL); i2c_writel(clkrate, i2c->reg_base + LPC24XX_I2SCLH); return 0; eadapt: free_irq(irq, i2c); ereqirq: clk_disable(i2c->clk); iounmap(i2c->reg_base); eremap: clk_put(i2c->clk); eclk: kfree(i2c); emalloc: release_mem_region(res->start, resource_size(res)); 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; }
static int sh_mobile_i2c_probe(struct platform_device *dev) { struct sh_mobile_i2c_data *pd; struct i2c_adapter *adap; struct resource *res; char clk_name[8]; int size; int ret; pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL); if (pd == NULL) { dev_err(&dev->dev, "cannot allocate private data\n"); return -ENOMEM; } snprintf(clk_name, sizeof(clk_name), "i2c%d", dev->id); pd->clk = clk_get(&dev->dev, clk_name); if (IS_ERR(pd->clk)) { dev_err(&dev->dev, "cannot get clock \"%s\"\n", clk_name); ret = PTR_ERR(pd->clk); goto err; } ret = sh_mobile_i2c_hook_irqs(dev, 1); if (ret) { dev_err(&dev->dev, "cannot request IRQ\n"); goto err_clk; } pd->dev = &dev->dev; platform_set_drvdata(dev, pd); res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&dev->dev, "cannot find IO resource\n"); ret = -ENOENT; goto err_irq; } size = (res->end - res->start) + 1; pd->reg = ioremap(res->start, size); if (pd->reg == NULL) { dev_err(&dev->dev, "cannot map IO\n"); ret = -ENXIO; goto err_irq; } /* setup the private data */ adap = &pd->adap; i2c_set_adapdata(adap, pd); adap->owner = THIS_MODULE; adap->algo = &sh_mobile_i2c_algorithm; adap->dev.parent = &dev->dev; adap->retries = 5; adap->nr = dev->id; strlcpy(adap->name, dev->name, sizeof(adap->name)); spin_lock_init(&pd->lock); init_waitqueue_head(&pd->wait); ret = i2c_add_numbered_adapter(adap); if (ret < 0) { dev_err(&dev->dev, "cannot add numbered adapter\n"); goto err_all; } return 0; err_all: iounmap(pd->reg); err_irq: sh_mobile_i2c_hook_irqs(dev, 0); err_clk: clk_put(pd->clk); err: kfree(pd); return ret; }
/* * Instantiate a new instance of the I2C controller * @dev I2C controller platform device * @returns 0->success, <0->error code */ static int __devinit i2c_stm32_probe(struct platform_device *dev) { struct i2c_stm32 *c = NULL; struct i2c_stm32_data *d; struct resource *regs; int bus; int irq; int ret = 0; /* * Get the bus # from the platform device: */ bus = dev->id; if (! (0 <= bus && bus <= 2)) { dev_err(&dev->dev, "invalid bus number %d\n", bus); ret = -ENXIO; goto Error_release_nothing; } /* * Get the IRQ number from the platform device */ irq = platform_get_irq(dev, 0); if (irq < 0) { dev_err(&dev->dev, "invalid IRQ number %d\n", irq); ret = irq; goto Error_release_nothing; } /* * Get the register base from the platform device */ regs = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!regs) { dev_err(&dev->dev, "no register base provided\n"); ret = -ENXIO; goto Error_release_nothing; } /* * Allocate the controller-private data structure */ c = kzalloc(sizeof(struct i2c_stm32), GFP_KERNEL); if (!c) { dev_err(&dev->dev, "unable to allocate memory\n"); ret = -ENOMEM; goto Error_release_nothing; } c->dev = dev; c->bus = bus; /* * Request a memory region for the CSR block */ if (!request_mem_region(regs->start, resource_size(regs), regs->name)) { dev_err(&dev->dev, "registers already in use\n"); ret = -ENOMEM; goto Error_release_memory; } c->regs_base = regs->start; c->regs_size = resource_size(regs); /* * Map in the CSR block */ c->regs = ioremap(regs->start, resource_size(regs)); if (!c->regs) { dev_err(&dev->dev, "unable to map registers\n"); ret = -EINVAL; goto Error_release_mem_region; } /* * Register interrupt handler for events */ ret = request_irq(irq, i2c_stm32_irq, 0, dev_name(&dev->dev), c); if (ret) { dev_err(&dev->dev, "request for IRQ %d failed\n", irq); goto Error_release_regs; } disable_irq_nosync(irq); c->irq = irq; /* * Register interrupt handler for errors */ ret = request_irq(irq + 1, i2c_stm32_irq, 0, dev_name(&dev->dev), c); if (ret) { dev_err(&dev->dev, "request for IRQ %d failed\n", irq + 1); goto Error_release_irq1; } /* * Retrieve the private parameters */ d = (struct i2c_stm32_data *) platform_get_drvdata(dev); c->ref_clk = d->ref_clk; c->i2c_clk = d->i2c_clk; /* * Link the private data to dev */ platform_set_drvdata(dev, c); /* * Initialize the I2C adapter data structure */ c->adap.owner = THIS_MODULE; c->adap.nr = bus; snprintf(c->adap.name, sizeof(c->adap.name), "i2c_stm32.%u", bus); c->adap.algo = &i2c_stm32_algorithm; c->adap.algo_data = c; c->adap.dev.parent = &dev->dev; /* * Initialize the controller hardware */ ret = i2c_stm32_hw_init(c); if (ret) { goto Error_release_irq2; } /* * Set up the wait queue */ init_waitqueue_head(&c->wait); /* * Register the I2C adapter */ if (i2c_add_numbered_adapter(&c->adap)) { dev_err(&dev->dev, "unable to add adapter\n"); ret = -ENXIO; goto Error_release_hw; } /* * If we are here, we are successful */ dev_info(&dev->dev, "I2C Controller %s at %p,irq=%d\n", dev_name(&c->adap.dev), c->regs, c->irq); goto Done; /* * Error processing */ Error_release_hw: i2c_stm32_hw_release(c); Error_release_irq2: free_irq(c->irq + 1, c); Error_release_irq1: free_irq(c->irq, c); Error_release_regs: iounmap(c->regs); Error_release_mem_region: release_mem_region(regs->start, resource_size(regs)); Error_release_memory: kfree(c); platform_set_drvdata(dev, NULL); Error_release_nothing: Done: d_printk(1, "dev=%s,regs=%p,irq=%d,ref_clk=%d,i2c_clk=%d,ret=%d\n", dev_name(&dev->dev), c ? c->regs : NULL, c ? c->irq : 0, c ? c->ref_clk : 0, c ? c->i2c_clk : 0, ret); return ret; }
/** * xi2cps_probe - Platform registration call * @pdev: Handle to the platform device structure * * Returns zero on success, negative error otherwise * * This function does all the memory allocation and registration for the i2c * device. User can modify the address mode to 10 bit address mode using the * ioctl call with option I2C_TENBIT. */ static int xi2cps_probe(struct platform_device *pdev) { struct resource *r_mem = NULL; struct xi2cps *id; int ret = 0; const unsigned int *prop; /* * Allocate memory for xi2cps structure. * Initialize the structure to zero and set the platform data. * Obtain the resource base address from platform data and remap it. * Get the irq resource from platform data.Initialize the adapter * structure members and also xi2cps structure. */ id = devm_kzalloc(&pdev->dev, sizeof(*id), GFP_KERNEL); if (!id) return -ENOMEM; platform_set_drvdata(pdev, id); r_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); id->membase = devm_ioremap_resource(&pdev->dev, r_mem); if (IS_ERR(id->membase)) { dev_err(&pdev->dev, "ioremap failed\n"); return PTR_ERR(id->membase); } id->irq = platform_get_irq(pdev, 0); prop = of_get_property(pdev->dev.of_node, "bus-id", NULL); if (prop) { id->adap.nr = be32_to_cpup(prop); } else { dev_err(&pdev->dev, "couldn't determine bus-id\n"); return -ENXIO; } id->adap.dev.of_node = pdev->dev.of_node; id->adap.algo = (struct i2c_algorithm *) &xi2cps_algo; id->adap.timeout = 0x1F; /* Default timeout value */ id->adap.retries = 3; /* Default retry value. */ id->adap.algo_data = id; id->adap.dev.parent = &pdev->dev; snprintf(id->adap.name, sizeof(id->adap.name), "XILINX I2C at %08lx", (unsigned long)r_mem->start); id->cur_timeout = id->adap.timeout; id->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(id->clk)) { dev_err(&pdev->dev, "input clock not found.\n"); return PTR_ERR(id->clk); } ret = clk_prepare_enable(id->clk); if (ret) { dev_err(&pdev->dev, "Unable to enable clock.\n"); return ret; } id->clk_rate_change_nb.notifier_call = xi2cps_clk_notifier_cb; id->clk_rate_change_nb.next = NULL; if (clk_notifier_register(id->clk, &id->clk_rate_change_nb)) dev_warn(&pdev->dev, "Unable to register clock notifier.\n"); id->input_clk = (unsigned int)clk_get_rate(id->clk); prop = of_get_property(pdev->dev.of_node, "i2c-clk", NULL); if (prop) { id->i2c_clk = be32_to_cpup(prop); } else { ret = -ENXIO; dev_err(&pdev->dev, "couldn't determine i2c-clk\n"); goto err_clk_dis; } /* * Set Master Mode,Normal addressing mode (7 bit address), * Enable Transmission of Ack in Control Register. * Set the timeout and I2C clock and request the IRQ(ISR mapped). * Call to the i2c_add_numbered_adapter registers the adapter. */ xi2cps_writereg(0x0000000E, XI2CPS_CR_OFFSET); xi2cps_writereg(id->adap.timeout, XI2CPS_TIME_OUT_OFFSET); ret = xi2cps_setclk(id->i2c_clk, id); if (ret < 0) { dev_err(&pdev->dev, "invalid SCL clock: %dkHz\n", id->i2c_clk); ret = -EINVAL; goto err_clk_dis; } ret = devm_request_irq(&pdev->dev, id->irq, xi2cps_isr, 0, DRIVER_NAME, id); if (ret) { dev_err(&pdev->dev, "cannot get irq %d\n", id->irq); goto err_clk_dis; } ret = i2c_add_numbered_adapter(&id->adap); if (ret < 0) { dev_err(&pdev->dev, "reg adap failed: %d\n", ret); goto err_clk_dis; } dev_info(&pdev->dev, "%d kHz mmio %08lx irq %d\n", id->i2c_clk/1000, (unsigned long)r_mem->start, id->irq); return 0; err_clk_dis: clk_disable_unprepare(id->clk); return ret; }
static int sh_mobile_i2c_probe(struct platform_device *dev) { struct sh_mobile_i2c_data *pd; struct i2c_adapter *adap; struct resource *res; char clk_name[8]; int size; int ret; pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL); if (pd == NULL) { dev_err(&dev->dev, "cannot allocate private data\n"); return -ENOMEM; } snprintf(clk_name, sizeof(clk_name), "i2c%d", dev->id); pd->clk = clk_get(&dev->dev, clk_name); if (IS_ERR(pd->clk)) { dev_err(&dev->dev, "cannot get clock \"%s\"\n", clk_name); ret = PTR_ERR(pd->clk); goto err; } ret = sh_mobile_i2c_hook_irqs(dev, 1); if (ret) { dev_err(&dev->dev, "cannot request IRQ\n"); goto err_clk; } pd->dev = &dev->dev; platform_set_drvdata(dev, pd); res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&dev->dev, "cannot find IO resource\n"); ret = -ENOENT; goto err_irq; } size = resource_size(res); pd->reg = ioremap(res->start, size); if (pd->reg == NULL) { dev_err(&dev->dev, "cannot map IO\n"); ret = -ENXIO; goto err_irq; } /* The IIC blocks on SH-Mobile ARM processors * come with two new bits in ICIC. */ if (size > 0x17) pd->flags |= IIC_FLAG_HAS_ICIC67; /* Enable Runtime PM for this device. * * Also tell the Runtime PM core to ignore children * for this device since it is valid for us to suspend * this I2C master driver even though the slave devices * on the I2C bus may not be suspended. * * The state of the I2C hardware bus is unaffected by * the Runtime PM state. */ pm_suspend_ignore_children(&dev->dev, true); pm_runtime_enable(&dev->dev); /* setup the private data */ adap = &pd->adap; i2c_set_adapdata(adap, pd); adap->owner = THIS_MODULE; adap->algo = &sh_mobile_i2c_algorithm; adap->dev.parent = &dev->dev; adap->retries = 5; adap->nr = dev->id; strlcpy(adap->name, dev->name, sizeof(adap->name)); spin_lock_init(&pd->lock); init_waitqueue_head(&pd->wait); ret = i2c_add_numbered_adapter(adap); if (ret < 0) { dev_err(&dev->dev, "cannot add numbered adapter\n"); goto err_all; } return 0; err_all: iounmap(pd->reg); err_irq: sh_mobile_i2c_hook_irqs(dev, 0); err_clk: clk_put(pd->clk); err: kfree(pd); 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 i2c_jz_probe(struct platform_device *dev) { int ret = 0; struct i2c_jz *i2c; struct resource *res; unsigned int reg_tmp; i2c = kzalloc(sizeof(struct i2c_jz), GFP_KERNEL); if (!i2c) { printk("Error: Now we can not malloc memory for I2C!\n"); ret = -ENOMEM; goto ERR0; } i2c->adap.owner = THIS_MODULE; i2c->adap.algo = &i2c_jz_algorithm; i2c->adap.retries = 5; i2c->adap.timeout = 5; i2c->adap.algo_data = i2c; i2c->adap.dev.parent = &dev->dev; i2c->adap.nr = dev->id; sprintf(i2c->adap.name, "i2c%u", dev->id); i2c->clk = clk_get(&dev->dev, i2c->adap.name); if (!i2c->clk) { printk("Error: Now we can not get i2c%d clock!\n", dev->id); ret = -ENODEV; goto clk_failed; } res = platform_get_resource(dev, IORESOURCE_MEM, 0); i2c->iomem = ioremap(res->start, resource_size(res)); if (!i2c->iomem) { printk("Error: Now we can remap IO for I2C%d!\n", dev->id); ret = -ENOMEM; goto io_failed; } i2c->irq = platform_get_irq(dev, 0); ret = request_irq(i2c->irq, i2c_jz_irq, IRQF_DISABLED, dev_name(&dev->dev), i2c); if (ret) { printk("Error: Now we can request irq for I2C%d!\n", dev->id); ret = -ENODEV; goto irq_failed; } clk_enable(i2c->clk); res = platform_get_resource(dev, IORESOURCE_BUS, 0); i2c_set_speed(i2c, res->start * 1000); #if 0 reg_tmp = i2c_readl(i2c, I2C_DC); reg_tmp &= ~I2C_DC_STP; i2c_writel(i2c, I2C_DC, reg_tmp); #endif reg_tmp = i2c_readl(i2c, I2C_CTRL); reg_tmp |= I2C_CTRL_REST; i2c_writel(i2c, I2C_CTRL, reg_tmp); // for jgao WHY? // i2c_writel(i2c, I2C_FLT, 0xF); /*set filter*/ i2c_writel(i2c, I2C_INTM, 0x0); init_completion(&i2c->complete); ret = i2c_add_numbered_adapter(&i2c->adap); if (ret < 0) { dev_err(&(i2c->adap.dev), KERN_INFO "I2C: Failed to add bus\n"); goto adapt_failed; } platform_set_drvdata(dev, i2c); i2c_jz_enable(i2c); clk_disable(i2c->clk); #ifdef CONFIG_I2C_DEBUG_INFO ret = create_debug_sysfs_interface(&dev->dev); if (ret < 0) dev_err(&i2c->adap.dev, "create debug sysfs interface failed\n"); #endif return 0; adapt_failed: free_irq(i2c->irq, i2c); irq_failed: iounmap(i2c->iomem); io_failed: clk_put(i2c->clk); clk_failed: kfree(i2c); ERR0: return ret; }
static int __init i2c_imx_probe(struct platform_device *pdev) { struct imx_i2c_struct *i2c_imx; struct resource *res; struct imxi2c_platform_data *pdata; void __iomem *base; resource_size_t res_size; int irq; int ret; dev_dbg(&pdev->dev, "<%s>\n", __func__); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "can't get device resources\n"); return -ENOENT; } irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "can't get irq number\n"); return -ENOENT; } pdata = pdev->dev.platform_data; if (pdata && pdata->init) { ret = pdata->init(&pdev->dev); if (ret) return ret; } res_size = resource_size(res); if (!request_mem_region(res->start, res_size, DRIVER_NAME)) { ret = -EBUSY; goto fail0; } base = ioremap(res->start, res_size); if (!base) { dev_err(&pdev->dev, "ioremap failed\n"); ret = -EIO; goto fail1; } i2c_imx = kzalloc(sizeof(struct imx_i2c_struct), GFP_KERNEL); if (!i2c_imx) { dev_err(&pdev->dev, "can't allocate interface\n"); ret = -ENOMEM; goto fail2; } /* Setup i2c_imx driver structure */ strcpy(i2c_imx->adapter.name, pdev->name); i2c_imx->adapter.owner = THIS_MODULE; i2c_imx->adapter.algo = &i2c_imx_algo; i2c_imx->adapter.dev.parent = &pdev->dev; i2c_imx->adapter.nr = pdev->id; i2c_imx->irq = irq; i2c_imx->base = base; i2c_imx->res = res; /* Get I2C clock */ i2c_imx->clk = clk_get(&pdev->dev, "i2c_clk"); if (IS_ERR(i2c_imx->clk)) { ret = PTR_ERR(i2c_imx->clk); dev_err(&pdev->dev, "can't get I2C clock\n"); goto fail3; } /* Request IRQ */ ret = request_irq(i2c_imx->irq, i2c_imx_isr, 0, pdev->name, i2c_imx); if (ret) { dev_err(&pdev->dev, "can't claim irq %d\n", i2c_imx->irq); goto fail4; } /* Init queue */ init_waitqueue_head(&i2c_imx->queue); /* Set up adapter data */ i2c_set_adapdata(&i2c_imx->adapter, i2c_imx); /* Set up clock divider */ if (pdata && pdata->bitrate) i2c_imx_set_clk(i2c_imx, pdata->bitrate); else i2c_imx_set_clk(i2c_imx, IMX_I2C_BIT_RATE); /* Set up chip registers to defaults */ writeb(0, i2c_imx->base + IMX_I2C_I2CR); writeb(0, i2c_imx->base + IMX_I2C_I2SR); /* Add I2C adapter */ ret = i2c_add_numbered_adapter(&i2c_imx->adapter); if (ret < 0) { dev_err(&pdev->dev, "registration failed\n"); goto fail5; } /* Set up platform driver data */ platform_set_drvdata(pdev, i2c_imx); dev_dbg(&i2c_imx->adapter.dev, "claimed irq %d\n", i2c_imx->irq); dev_dbg(&i2c_imx->adapter.dev, "device resources from 0x%x to 0x%x\n", i2c_imx->res->start, i2c_imx->res->end); dev_dbg(&i2c_imx->adapter.dev, "allocated %d bytes at 0x%x \n", res_size, i2c_imx->res->start); dev_dbg(&i2c_imx->adapter.dev, "adapter name: \"%s\"\n", i2c_imx->adapter.name); dev_dbg(&i2c_imx->adapter.dev, "IMX I2C adapter registered\n"); return 0; /* Return OK */ fail5: free_irq(i2c_imx->irq, i2c_imx); fail4: clk_put(i2c_imx->clk); fail3: kfree(i2c_imx); fail2: iounmap(base); fail1: release_mem_region(res->start, resource_size(res)); fail0: if (pdata && pdata->exit) pdata->exit(&pdev->dev); return ret; /* Return error number */ }
static int __devinit i2c_pnx_probe(struct platform_device *pdev) { unsigned long tmp; int ret = 0; struct i2c_pnx_algo_data *alg_data; unsigned long freq; struct i2c_pnx_data *i2c_pnx = pdev->dev.platform_data; if (!i2c_pnx || !i2c_pnx->name) { dev_err(&pdev->dev, "%s: no platform data supplied\n", __func__); ret = -EINVAL; goto out; } alg_data = kzalloc(sizeof(*alg_data), GFP_KERNEL); if (!alg_data) { ret = -ENOMEM; goto err_kzalloc; } platform_set_drvdata(pdev, alg_data); strlcpy(alg_data->adapter.name, i2c_pnx->name, sizeof(alg_data->adapter.name)); alg_data->adapter.dev.parent = &pdev->dev; alg_data->adapter.algo = &pnx_algorithm; alg_data->adapter.algo_data = alg_data; alg_data->adapter.nr = pdev->id; alg_data->i2c_pnx = i2c_pnx; alg_data->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(alg_data->clk)) { ret = PTR_ERR(alg_data->clk); goto out_drvdata; } init_timer(&alg_data->mif.timer); alg_data->mif.timer.function = i2c_pnx_timeout; alg_data->mif.timer.data = (unsigned long)alg_data; /* */ if (!request_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE, pdev->name)) { dev_err(&pdev->dev, "I/O region 0x%08x for I2C already in use.\n", i2c_pnx->base); ret = -ENODEV; goto out_clkget; } alg_data->ioaddr = ioremap(i2c_pnx->base, I2C_PNX_REGION_SIZE); if (!alg_data->ioaddr) { dev_err(&pdev->dev, "Couldn't ioremap I2C I/O region\n"); ret = -ENOMEM; goto out_release; } ret = clk_enable(alg_data->clk); if (ret) goto out_unmap; freq = clk_get_rate(alg_data->clk); /* */ tmp = ((freq / 1000) / I2C_PNX_SPEED_KHZ) / 2 - 2; if (tmp > 0x3FF) tmp = 0x3FF; iowrite32(tmp, I2C_REG_CKH(alg_data)); iowrite32(tmp, I2C_REG_CKL(alg_data)); iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data)); if (wait_reset(I2C_PNX_TIMEOUT, alg_data)) { ret = -ENODEV; goto out_clock; } init_completion(&alg_data->mif.complete); ret = request_irq(i2c_pnx->irq, i2c_pnx_interrupt, 0, pdev->name, alg_data); if (ret) goto out_clock; /* */ ret = i2c_add_numbered_adapter(&alg_data->adapter); if (ret < 0) { dev_err(&pdev->dev, "I2C: Failed to add bus\n"); goto out_irq; } dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n", alg_data->adapter.name, i2c_pnx->base, i2c_pnx->irq); return 0; out_irq: free_irq(i2c_pnx->irq, alg_data); out_clock: clk_disable(alg_data->clk); out_unmap: iounmap(alg_data->ioaddr); out_release: release_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE); out_clkget: clk_put(alg_data->clk); out_drvdata: kfree(alg_data); err_kzalloc: platform_set_drvdata(pdev, NULL); out: return ret; }
static int __devinit i2c_pnx_probe(struct platform_device *pdev) { unsigned long tmp; int ret = 0; struct i2c_pnx_algo_data *alg_data; unsigned long freq; struct i2c_pnx_data *i2c_pnx = pdev->dev.platform_data; if (!i2c_pnx || !i2c_pnx->name) { dev_err(&pdev->dev, "%s: no platform data supplied\n", __func__); ret = -EINVAL; goto out; } alg_data = kzalloc(sizeof(*alg_data), GFP_KERNEL); if (!alg_data) { ret = -ENOMEM; goto err_kzalloc; } platform_set_drvdata(pdev, alg_data); strlcpy(alg_data->adapter.name, i2c_pnx->name, sizeof(alg_data->adapter.name)); alg_data->adapter.dev.parent = &pdev->dev; alg_data->adapter.algo = &pnx_algorithm; alg_data->adapter.algo_data = alg_data; alg_data->adapter.nr = pdev->id; alg_data->i2c_pnx = i2c_pnx; alg_data->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(alg_data->clk)) { ret = PTR_ERR(alg_data->clk); goto out_drvdata; } init_timer(&alg_data->mif.timer); alg_data->mif.timer.function = i2c_pnx_timeout; alg_data->mif.timer.data = (unsigned long)alg_data; /* Register I/O resource */ if (!request_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE, pdev->name)) { dev_err(&pdev->dev, "I/O region 0x%08x for I2C already in use.\n", i2c_pnx->base); ret = -ENODEV; goto out_clkget; } alg_data->ioaddr = ioremap(i2c_pnx->base, I2C_PNX_REGION_SIZE); if (!alg_data->ioaddr) { dev_err(&pdev->dev, "Couldn't ioremap I2C I/O region\n"); ret = -ENOMEM; goto out_release; } ret = clk_enable(alg_data->clk); if (ret) goto out_unmap; freq = clk_get_rate(alg_data->clk); /* * Clock Divisor High This value is the number of system clocks * the serial clock (SCL) will be high. * For example, if the system clock period is 50 ns and the maximum * desired serial period is 10000 ns (100 kHz), then CLKHI would be * set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value * programmed into CLKHI will vary from this slightly due to * variations in the output pad's rise and fall times as well as * the deglitching filter length. */ tmp = ((freq / 1000) / I2C_PNX_SPEED_KHZ) / 2 - 2; iowrite32(tmp, I2C_REG_CKH(alg_data)); iowrite32(tmp, I2C_REG_CKL(alg_data)); iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data)); if (wait_reset(I2C_PNX_TIMEOUT, alg_data)) { ret = -ENODEV; goto out_clock; } init_completion(&alg_data->mif.complete); ret = request_irq(i2c_pnx->irq, i2c_pnx_interrupt, 0, pdev->name, alg_data); if (ret) goto out_clock; /* Register this adapter with the I2C subsystem */ ret = i2c_add_numbered_adapter(&alg_data->adapter); if (ret < 0) { dev_err(&pdev->dev, "I2C: Failed to add bus\n"); goto out_irq; } dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n", alg_data->adapter.name, i2c_pnx->base, i2c_pnx->irq); return 0; out_irq: free_irq(i2c_pnx->irq, alg_data); out_clock: clk_disable(alg_data->clk); out_unmap: iounmap(alg_data->ioaddr); out_release: release_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE); out_clkget: clk_put(alg_data->clk); out_drvdata: kfree(alg_data); err_kzalloc: platform_set_drvdata(pdev, NULL); out: return ret; }
static int msm_i2c_probe(struct platform_device *pdev) { struct msm_i2c_dev *dev; struct resource *mem, *irq, *ioarea; struct msm_i2c_device_platform_data *pdata = pdev->dev.platform_data; int ret; int fs_div; int hs_div; int i2c_clk, i2c_clock; int clk_ctl; struct clk *clk; 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; } 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->base = ioremap(mem->start, (mem->end - mem->start) + 1); if (!dev->base) { ret = -ENOMEM; goto err_ioremap_failed; } spin_lock_init(&dev->lock); wake_lock_init(&dev->wakelock, WAKE_LOCK_SUSPEND, "i2c"); platform_set_drvdata(pdev, dev); if (pdata) { dev->clk_drv_str = pdata->clock_strength; dev->dat_drv_str = pdata->data_strength; if (pdata->i2c_clock < 100000 || pdata->i2c_clock > 400000) i2c_clock = 100000; else i2c_clock = pdata->i2c_clock; } else { dev->clk_drv_str = 0; dev->dat_drv_str = 0; i2c_clock = 100000; dev->skip_recover = 1; } if (!dev->skip_recover) msm_set_i2c_mux(false, NULL, NULL, dev->clk_drv_str, dev->dat_drv_str); clk_enable(clk); /* 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 / i2c_clock) / 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))); clk_disable(clk); i2c_set_adapdata(&dev->adapter, dev); dev->adapter.algo = &msm_i2c_algo; strncpy(dev->adapter.name, "MSM I2C adapter", sizeof(dev->adapter.name)); dev->adapter.nr = pdev->id; ret = i2c_add_numbered_adapter(&dev->adapter); if (ret) { dev_err(&pdev->dev, "i2c_add_adapter failed\n"); goto err_i2c_add_adapter_failed; } ret = request_irq(dev->irq, msm_i2c_interrupt, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TIMER, pdev->name, dev); if (ret) { dev_err(&pdev->dev, "request_irq failed\n"); goto err_request_irq_failed; } disable_irq(dev->irq); return 0; /* free_irq(dev->irq, dev); */ err_request_irq_failed: i2c_del_adapter(&dev->adapter); err_i2c_add_adapter_failed: 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; }
static int __devinit bcm5301x_i2c_probe(struct platform_device *pdev) { struct bcm5301x_i2c_data *pdata; struct i2c_adapter *adap; struct resource *res; int irq; bool fast; int rc; BCM5301X_MSG_INFO("probe"); res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) { BCM5301X_MSG_ERR("no resources"); rc = -EINVAL; goto fail_get_res; } irq = res->start; fast = res->end; if (irq <= 0) { BCM5301X_MSG_ERR("bad irqno %d", irq); rc = -EINVAL; goto fail_get_res; } BCM5301X_MSG_INFO("irqno %d fast %d", irq, fast); pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); if (pdata == NULL) { BCM5301X_MSG_ERR("failed to allocate data"); rc = -ENOMEM; goto fail_alloc; } pdata->irq = irq; pdata->fast = fast; init_completion(&pdata->done); adap = &pdata->adap; snprintf(adap->name, sizeof(adap->name), BCM5301X_CFG_DRV_NAME); adap->algo = &bcm5301x_algorithm; adap->algo_data = pdata; adap->dev.parent = &pdev->dev; adap->nr = pdev->id; platform_set_drvdata(pdev, pdata); rc = bcm5301x_hwinit(pdata); if (rc) { BCM5301X_MSG_ERR("hw init failed"); goto fail_hwinit; } rc = request_irq(irq, bcm5301x_i2c_irq, 0, BCM5301X_CFG_DRV_NAME, pdata); if (rc) { BCM5301X_MSG_ERR("failed to request irqno %d", irq); goto fail_request_irq; } rc = i2c_add_numbered_adapter(adap); if (rc) { BCM5301X_MSG_ERR("adapter registration failed"); goto fail_add_adapter; } rc = bcm5301x_bb_init(pdev, pdata); if (rc) { BCM5301X_MSG_ERR("bb init failed"); goto fail_bb_init; } printk(KERN_INFO"%s : adapter %d created\n", BCM5301X_CFG_DRV_NAME, adap->id); return 0; fail_bb_init: i2c_del_adapter(adap); fail_add_adapter: free_irq(irq, pdata); fail_request_irq: fail_hwinit: platform_set_drvdata(pdev, NULL); kfree(pdata); fail_alloc: fail_get_res: return rc; }
static int __devinit octeon_i2c_probe(struct platform_device *pdev) { int irq, result = 0; struct octeon_i2c *i2c; struct octeon_i2c_data *i2c_data; struct resource *res_mem; /* All adaptors have an irq. */ irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; i2c = kzalloc(sizeof(*i2c), GFP_KERNEL); if (!i2c) { dev_err(&pdev->dev, "kzalloc failed\n"); result = -ENOMEM; goto out; } i2c->dev = &pdev->dev; i2c_data = pdev->dev.platform_data; res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res_mem == NULL) { dev_err(i2c->dev, "found no memory resource\n"); result = -ENXIO; goto fail_region; } if (i2c_data == NULL) { dev_err(i2c->dev, "no I2C frequency data\n"); result = -ENXIO; goto fail_region; } i2c->twsi_phys = res_mem->start; i2c->regsize = resource_size(res_mem); i2c->twsi_freq = i2c_data->i2c_freq; i2c->sys_freq = i2c_data->sys_freq; if (!request_mem_region(i2c->twsi_phys, i2c->regsize, res_mem->name)) { dev_err(i2c->dev, "request_mem_region failed\n"); goto fail_region; } i2c->twsi_base = ioremap(i2c->twsi_phys, i2c->regsize); init_waitqueue_head(&i2c->queue); i2c->irq = irq; result = request_irq(i2c->irq, octeon_i2c_isr, 0, DRV_NAME, i2c); if (result < 0) { dev_err(i2c->dev, "failed to attach interrupt\n"); goto fail_irq; } result = octeon_i2c_initlowlevel(i2c); if (result) { dev_err(i2c->dev, "init low level failed\n"); goto fail_add; } result = octeon_i2c_setclock(i2c); if (result) { dev_err(i2c->dev, "clock init failed\n"); goto fail_add; } i2c->adap = octeon_i2c_ops; i2c->adap.dev.parent = &pdev->dev; i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0; i2c_set_adapdata(&i2c->adap, i2c); platform_set_drvdata(pdev, i2c); result = i2c_add_numbered_adapter(&i2c->adap); if (result < 0) { dev_err(i2c->dev, "failed to add adapter\n"); goto fail_add; } dev_info(i2c->dev, "version %s\n", DRV_VERSION); return result; fail_add: platform_set_drvdata(pdev, NULL); free_irq(i2c->irq, i2c); fail_irq: iounmap(i2c->twsi_base); release_mem_region(i2c->twsi_phys, i2c->regsize); fail_region: kfree(i2c); out: return result; };