static int xiic_i2c_probe(struct platform_device *pdev) { struct xiic_i2c *i2c; struct xiic_i2c_platform_data *pdata; struct resource *res; int ret, irq; u8 i; u32 sr; i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); if (!i2c) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2c->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(i2c->base)) return PTR_ERR(i2c->base); irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; pdata = dev_get_platdata(&pdev->dev); /* hook up driver to tree */ platform_set_drvdata(pdev, i2c); i2c->adap = xiic_adapter; i2c_set_adapdata(&i2c->adap, i2c); i2c->adap.dev.parent = &pdev->dev; i2c->adap.dev.of_node = pdev->dev.of_node; spin_lock_init(&i2c->lock); init_waitqueue_head(&i2c->wait); ret = devm_request_irq(&pdev->dev, irq, xiic_isr, 0, pdev->name, i2c); if (ret < 0) { dev_err(&pdev->dev, "Cannot claim IRQ\n"); return ret; } /* * Detect endianness * Try to reset the TX FIFO. Then check the EMPTY flag. If it is not * set, assume that the endianness was wrong and swap. */ i2c->endianness = LITTLE; xiic_setreg32(i2c, XIIC_CR_REG_OFFSET, XIIC_CR_TX_FIFO_RESET_MASK); /* Reset is cleared in xiic_reinit */ sr = xiic_getreg32(i2c, XIIC_SR_REG_OFFSET); if (!(sr & XIIC_SR_TX_FIFO_EMPTY_MASK)) i2c->endianness = BIG; xiic_reinit(i2c); /* add i2c adapter to i2c tree */ ret = i2c_add_adapter(&i2c->adap); if (ret) { dev_err(&pdev->dev, "Failed to add adapter\n"); xiic_deinit(i2c); return ret; } if (pdata) { /* add in known devices to the bus */ for (i = 0; i < pdata->num_devices; i++) i2c_new_device(&i2c->adap, pdata->devices + i); } return 0; }
static int __devinit xiic_i2c_probe(struct platform_device *pdev) { struct xiic_i2c *i2c; struct xiic_i2c_platform_data *pdata; struct resource *res; int ret, irq; u8 i; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) goto resource_missing; irq = platform_get_irq(pdev, 0); if (irq < 0) goto resource_missing; pdata = (struct xiic_i2c_platform_data *) pdev->dev.platform_data; if (!pdata) return -EINVAL; i2c = kzalloc(sizeof(*i2c), GFP_KERNEL); if (!i2c) return -ENOMEM; if (!request_mem_region(res->start, resource_size(res), pdev->name)) { dev_err(&pdev->dev, "Memory region busy\n"); ret = -EBUSY; goto request_mem_failed; } i2c->base = ioremap(res->start, resource_size(res)); if (!i2c->base) { dev_err(&pdev->dev, "Unable to map registers\n"); ret = -EIO; goto map_failed; } /* hook up driver to tree */ platform_set_drvdata(pdev, i2c); i2c->adap = xiic_adapter; i2c_set_adapdata(&i2c->adap, i2c); i2c->adap.dev.parent = &pdev->dev; xiic_reinit(i2c); spin_lock_init(&i2c->lock); init_waitqueue_head(&i2c->wait); ret = request_irq(irq, xiic_isr, 0, pdev->name, i2c); if (ret) { dev_err(&pdev->dev, "Cannot claim IRQ\n"); goto request_irq_failed; } /* add i2c adapter to i2c tree */ ret = i2c_add_adapter(&i2c->adap); if (ret) { dev_err(&pdev->dev, "Failed to add adapter\n"); goto add_adapter_failed; } /* add in known devices to the bus */ for (i = 0; i < pdata->num_devices; i++) i2c_new_device(&i2c->adap, pdata->devices + i); return 0; add_adapter_failed: free_irq(irq, i2c); request_irq_failed: xiic_deinit(i2c); iounmap(i2c->base); map_failed: release_mem_region(res->start, resource_size(res)); request_mem_failed: kfree(i2c); return ret; resource_missing: dev_err(&pdev->dev, "IRQ or Memory resource is missing\n"); return -ENOENT; }
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; }
static int aat28xx_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id) { struct lge_backlight_platform_data *pdata; struct aat28xx_driver_data *drvdata; struct backlight_device *bd; int err; dprintk("start, client addr=0x%x\n", i2c_dev->addr); pdata = i2c_dev->dev.platform_data; if(!pdata) return -EINVAL; drvdata = kzalloc(sizeof(struct aat28xx_driver_data), GFP_KERNEL); if (!drvdata) { dev_err(&i2c_dev->dev, "failed to allocate memory\n"); return -ENOMEM; } if (pdata && pdata->platform_init) pdata->platform_init(); drvdata->client = i2c_dev; drvdata->gpio = pdata->gpio; drvdata->max_intensity = LCD_LED_MAX; if (pdata->max_current > 0) drvdata->max_intensity = pdata->max_current; drvdata->intensity = LCD_LED_MIN; drvdata->mode = NORMAL_MODE; drvdata->state = UNINIT_STATE; drvdata->version = pdata->version; if(aat28xx_setup_version(drvdata) != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } if (drvdata->gpio && gpio_request(drvdata->gpio, "aat28xx_en") != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } bd = backlight_device_register("aat28xx-bl", &i2c_dev->dev, NULL, &aat28xx_ops, NULL); if (bd == NULL) { eprintk("entering aat28xx probe function error \n"); if (gpio_is_valid(drvdata->gpio)) gpio_free(drvdata->gpio); kfree(drvdata); return -1; } bd->props.power = FB_BLANK_UNBLANK; bd->props.brightness = drvdata->intensity; bd->props.max_brightness = drvdata->max_intensity; drvdata->bd = bd; #ifdef CONFIG_BACKLIGHT_LEDS_CLASS if (led_classdev_register(&i2c_dev->dev, &aat28xx_led_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &aat28xx_led_dev; err = device_create_file(drvdata->led->dev, &dev_attr_alc); err = device_create_file(drvdata->led->dev, &dev_attr_reg); err = device_create_file(drvdata->led->dev, &dev_attr_drvstat); } #endif i2c_set_clientdata(i2c_dev, drvdata); i2c_set_adapdata(i2c_dev->adapter, i2c_dev); aat28xx_device_init(drvdata); aat28xx_send_intensity(drvdata, DEFAULT_BRIGHTNESS); #ifdef CONFIG_HAS_EARLYSUSPEND drvdata->early_suspend.suspend = aat28xx_early_suspend; drvdata->early_suspend.resume = aat28xx_late_resume; drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40; register_early_suspend(&drvdata->early_suspend); #endif aat28xx_ref = drvdata; eprintk("done\n"); return 0; }
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; }
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 __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 */ }
int nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index) { struct drm_nouveau_private *dev_priv = dev->dev_private; struct nouveau_i2c_chan *i2c; int ret; if (entry->chan) return -EEXIST; if (dev_priv->card_type == NV_50 && entry->read >= NV50_I2C_PORTS) { NV_ERROR(dev, "unknown i2c port %d\n", entry->read); return -EINVAL; } i2c = kzalloc(sizeof(*i2c), GFP_KERNEL); if (i2c == NULL) return -ENOMEM; switch (entry->port_type) { case 0: i2c->algo.bit.setsda = nv04_i2c_setsda; i2c->algo.bit.setscl = nv04_i2c_setscl; i2c->algo.bit.getsda = nv04_i2c_getsda; i2c->algo.bit.getscl = nv04_i2c_getscl; i2c->rd = entry->read; i2c->wr = entry->write; break; case 4: i2c->algo.bit.setsda = nv4e_i2c_setsda; i2c->algo.bit.setscl = nv4e_i2c_setscl; i2c->algo.bit.getsda = nv4e_i2c_getsda; i2c->algo.bit.getscl = nv4e_i2c_getscl; i2c->rd = 0x600800 + entry->read; i2c->wr = 0x600800 + entry->write; break; case 5: i2c->algo.bit.setsda = nv50_i2c_setsda; i2c->algo.bit.setscl = nv50_i2c_setscl; i2c->algo.bit.getsda = nv50_i2c_getsda; i2c->algo.bit.getscl = nv50_i2c_getscl; i2c->rd = nv50_i2c_port[entry->read]; i2c->wr = i2c->rd; break; case 6: i2c->rd = entry->read; i2c->wr = entry->write; break; default: NV_ERROR(dev, "DCB I2C port type %d unknown\n", entry->port_type); kfree(i2c); return -EINVAL; } snprintf(i2c->adapter.name, sizeof(i2c->adapter.name), "nouveau-%s-%d", pci_name(dev->pdev), index); i2c->adapter.owner = THIS_MODULE; i2c->adapter.dev.parent = &dev->pdev->dev; i2c->dev = dev; i2c_set_adapdata(&i2c->adapter, i2c); if (entry->port_type < 6) { i2c->adapter.algo_data = &i2c->algo.bit; i2c->algo.bit.udelay = 40; i2c->algo.bit.timeout = usecs_to_jiffies(5000); i2c->algo.bit.data = i2c; ret = i2c_bit_add_bus(&i2c->adapter); } else { i2c->adapter.algo_data = &i2c->algo.dp; i2c->algo.dp.running = false; i2c->algo.dp.address = 0; i2c->algo.dp.aux_ch = nouveau_dp_i2c_aux_ch; ret = i2c_dp_aux_add_bus(&i2c->adapter); } if (ret) { NV_ERROR(dev, "Failed to register i2c %d\n", index); kfree(i2c); return ret; } entry->chan = i2c; return 0; }
static int __init scx200_acb_create(int base, int index) { struct scx200_acb_iface *iface; struct i2c_adapter *adapter; int rc = 0; char description[64]; iface = kmalloc(sizeof(*iface), GFP_KERNEL); if (!iface) { printk(KERN_ERR NAME ": can't allocate memory\n"); rc = -ENOMEM; goto errout; } memset(iface, 0, sizeof(*iface)); adapter = &iface->adapter; i2c_set_adapdata(adapter, iface); snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index); adapter->owner = THIS_MODULE; adapter->id = I2C_ALGO_SMBUS; adapter->algo = &scx200_acb_algorithm; init_MUTEX(&iface->sem); snprintf(description, sizeof(description), "NatSemi SCx200 ACCESS.bus [%s]", adapter->name); if (request_region(base, 8, description) == 0) { dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n", base, base + 8-1); rc = -EBUSY; goto errout; } iface->base = base; rc = scx200_acb_probe(iface); if (rc) { dev_warn(&adapter->dev, "probe failed\n"); goto errout; } scx200_acb_reset(iface); if (i2c_add_adapter(adapter) < 0) { dev_err(&adapter->dev, "failed to register\n"); rc = -ENODEV; goto errout; } lock_kernel(); iface->next = scx200_acb_list; scx200_acb_list = iface; unlock_kernel(); return 0; errout: if (iface) { if (iface->base) release_region(iface->base, 8); kfree(iface); } return rc; }
static int i2c_lpc2k_probe(struct platform_device *pdev) { struct lpc2k_i2c *i2c; struct resource *res; u32 bus_clk_rate; u32 scl_high; u32 clkrate; int ret; i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); if (!i2c) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2c->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(i2c->base)) return PTR_ERR(i2c->base); i2c->irq = platform_get_irq(pdev, 0); if (i2c->irq < 0) { dev_err(&pdev->dev, "can't get interrupt resource\n"); return i2c->irq; } init_waitqueue_head(&i2c->wait); i2c->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(i2c->clk)) { dev_err(&pdev->dev, "error getting clock\n"); return PTR_ERR(i2c->clk); } ret = clk_prepare_enable(i2c->clk); if (ret) { dev_err(&pdev->dev, "unable to enable clock.\n"); return ret; } ret = devm_request_irq(&pdev->dev, i2c->irq, i2c_lpc2k_handler, 0, dev_name(&pdev->dev), i2c); if (ret < 0) { dev_err(&pdev->dev, "can't request interrupt.\n"); goto fail_clk; } disable_irq_nosync(i2c->irq); /* Place controller is a known state */ i2c_lpc2k_reset(i2c); ret = of_property_read_u32(pdev->dev.of_node, "clock-frequency", &bus_clk_rate); if (ret) bus_clk_rate = 100000; /* 100 kHz default clock rate */ clkrate = clk_get_rate(i2c->clk); if (clkrate == 0) { dev_err(&pdev->dev, "can't get I2C base clock\n"); ret = -EINVAL; goto fail_clk; } /* Setup I2C dividers to generate clock with proper duty cycle */ clkrate = clkrate / bus_clk_rate; if (bus_clk_rate <= 100000) scl_high = (clkrate * I2C_STD_MODE_DUTY) / 100; else if (bus_clk_rate <= 400000) scl_high = (clkrate * I2C_FAST_MODE_DUTY) / 100; else scl_high = (clkrate * I2C_FAST_MODE_PLUS_DUTY) / 100; writel(scl_high, i2c->base + LPC24XX_I2SCLH); writel(clkrate - scl_high, i2c->base + LPC24XX_I2SCLL); platform_set_drvdata(pdev, i2c); i2c_set_adapdata(&i2c->adap, i2c); i2c->adap.owner = THIS_MODULE; strlcpy(i2c->adap.name, "LPC2K I2C adapter", sizeof(i2c->adap.name)); i2c->adap.algo = &i2c_lpc2k_algorithm; i2c->adap.dev.parent = &pdev->dev; i2c->adap.dev.of_node = pdev->dev.of_node; ret = i2c_add_adapter(&i2c->adap); if (ret < 0) goto fail_clk; dev_info(&pdev->dev, "LPC2K I2C adapter\n"); return 0; fail_clk: clk_disable_unprepare(i2c->clk); return ret; }
int cx88_i2c_init(struct cx88_core *core, struct pci_dev *pci) { if (i2c_udelay<5) i2c_udelay=5; memcpy(&core->i2c_algo, &cx8800_i2c_algo_template, sizeof(core->i2c_algo)); core->i2c_adap.dev.parent = &pci->dev; strlcpy(core->i2c_adap.name,core->name,sizeof(core->i2c_adap.name)); core->i2c_adap.owner = THIS_MODULE; core->i2c_adap.id = I2C_HW_B_CX2388x; core->i2c_algo.udelay = i2c_udelay; core->i2c_algo.data = core; i2c_set_adapdata(&core->i2c_adap, &core->v4l2_dev); core->i2c_adap.algo_data = &core->i2c_algo; core->i2c_client.adapter = &core->i2c_adap; strlcpy(core->i2c_client.name, "cx88xx internal", I2C_NAME_SIZE); cx8800_bit_setscl(core,1); cx8800_bit_setsda(core,1); core->i2c_rc = i2c_bit_add_bus(&core->i2c_adap); if (0 == core->i2c_rc) { static u8 tuner_data[] = { 0x0b, 0xdc, 0x86, 0x52 }; static struct i2c_msg tuner_msg = { .flags = 0, .addr = 0xc2 >> 1, .buf = tuner_data, .len = 4 }; dprintk(1, "i2c register ok\n"); switch( core->boardnr ) { case CX88_BOARD_HAUPPAUGE_HVR1300: case CX88_BOARD_HAUPPAUGE_HVR3000: case CX88_BOARD_HAUPPAUGE_HVR4000: printk("%s: i2c init: enabling analog demod on HVR1300/3000/4000 tuner\n", core->name); i2c_transfer(core->i2c_client.adapter, &tuner_msg, 1); break; default: break; } if (i2c_scan) do_i2c_scan(core->name,&core->i2c_client); } else printk("%s: i2c register FAILED\n", core->name); if (0 == core->i2c_rc) { struct i2c_board_info info; const unsigned short addr_list[] = { 0x18, 0x6b, 0x71, I2C_CLIENT_END }; memset(&info, 0, sizeof(struct i2c_board_info)); strlcpy(info.type, "ir_video", I2C_NAME_SIZE); i2c_new_probed_device(&core->i2c_adap, &info, addr_list); } return core->i2c_rc; }
static int rt9396_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id) { struct lge_backlight_platform_data *pdata; struct rt9396_driver_data *drvdata; struct backlight_device *bd; int err; rt9396_powerstate = NORMAL_STATE; dprintk("start, client addr=0x%x\n", i2c_dev->addr); pdata = i2c_dev->dev.platform_data; if(!pdata) return -EINVAL; drvdata = kzalloc(sizeof(struct rt9396_driver_data), GFP_KERNEL); if (!drvdata) { dev_err(&i2c_dev->dev, "failed to allocate memory\n"); return -ENOMEM; } if (pdata && pdata->platform_init) pdata->platform_init(); drvdata->client = i2c_dev; drvdata->gpio = pdata->gpio; drvdata->max_intensity = LCD_LED_MAX; if (pdata->max_current > 0) drvdata->max_intensity = pdata->max_current; drvdata->intensity = LCD_LED_MIN; drvdata->mode = NORMAL_MODE; drvdata->state = UNINIT_STATE; drvdata->version = pdata->version; if(rt9396_setup_version(drvdata) != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } if (drvdata->gpio && gpio_request(drvdata->gpio, "rt9396_en") != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } gpio_tlmm_config(GPIO_CFG(drvdata->gpio, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); bd = backlight_device_register("rt9396-bl", &i2c_dev->dev, NULL, &rt9396_ops, NULL); if (bd == NULL) { eprintk("entering rt9396 probe function error \n"); kfree(drvdata); return -1; } bd->props.power = FB_BLANK_UNBLANK; bd->props.brightness = drvdata->intensity; bd->props.max_brightness = drvdata->max_intensity; drvdata->bd = bd; if (led_classdev_register(&i2c_dev->dev, &rt9396_led_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &rt9396_led_dev; err = device_create_file(drvdata->led->dev, &dev_attr_alc); err = device_create_file(drvdata->led->dev, &dev_attr_reg); err = device_create_file(drvdata->led->dev, &dev_attr_drvstat); err = device_create_file(drvdata->led->dev, &dev_attr_chargerlogo); } // [Caio99BR][[email protected]] Workaround for bug of screen still awake after lock #ifndef CONFIG_MACH_LGE_2ND_GEN_KK_WORKAROUD if (led_classdev_register(&i2c_dev->dev, &rt9396_keyled_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &rt9396_keyled_dev; } #endif i2c_set_clientdata(i2c_dev, drvdata); i2c_set_adapdata(i2c_dev->adapter, i2c_dev); rt9396_device_init(drvdata); rt9396_send_intensity(drvdata, RT9396BL_DEFAULT_BRIGHTNESS); #ifdef CONFIG_HAS_EARLYSUSPEND drvdata->early_suspend.suspend = rt9396_early_suspend; drvdata->early_suspend.resume = rt9396_late_resume; drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40; register_early_suspend(&drvdata->early_suspend); #endif rt9396_ref = drvdata; eprintk("done\n"); return 0; }
int usbvision_i2c_register(struct usb_usbvision *usbvision) { static unsigned short saa711x_addrs[] = { 0x4a >> 1, 0x48 >> 1, /* */ 0x42 >> 1, 0x40 >> 1, /* */ I2C_CLIENT_END }; if (usbvision->registered_i2c) return 0; memcpy(&usbvision->i2c_adap, &i2c_adap_template, sizeof(struct i2c_adapter)); sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name, usbvision->dev->bus->busnum, usbvision->dev->devpath); PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name); usbvision->i2c_adap.dev.parent = &usbvision->dev->dev; i2c_set_adapdata(&usbvision->i2c_adap, &usbvision->v4l2_dev); if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) { printk(KERN_ERR "usbvision_i2c_register: can't write reg\n"); return -EBUSY; } PDEBUG(DBG_I2C, "I2C debugging is enabled [i2c]"); PDEBUG(DBG_I2C, "ALGO debugging is enabled [i2c]"); /* */ usbvision->i2c_adap.algo = &usbvision_algo; usbvision->i2c_adap.timeout = 100; /* */ usbvision->i2c_adap.retries = 3; /* */ i2c_add_adapter(&usbvision->i2c_adap); PDEBUG(DBG_I2C, "i2c bus for %s registered", usbvision->i2c_adap.name); /* */ switch (usbvision_device_data[usbvision->dev_model].codec) { case CODEC_SAA7113: case CODEC_SAA7111: /* */ mdelay(10); v4l2_i2c_new_subdev(&usbvision->v4l2_dev, &usbvision->i2c_adap, "saa7115_auto", 0, saa711x_addrs); break; } if (usbvision_device_data[usbvision->dev_model].tuner == 1) { struct v4l2_subdev *sd; enum v4l2_i2c_tuner_type type; struct tuner_setup tun_setup; sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev, &usbvision->i2c_adap, "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); /* */ type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev, &usbvision->i2c_adap, "tuner", 0, v4l2_i2c_tuner_addrs(type)); if (sd == NULL) return -ENODEV; if (usbvision->tuner_type != -1) { tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; tun_setup.type = usbvision->tuner_type; tun_setup.addr = v4l2_i2c_subdev_addr(sd); call_all(usbvision, tuner, s_type_addr, &tun_setup); } } usbvision->registered_i2c = 1; return 0; }
static int create_iface(struct device_node *np, struct device *dev) { unsigned long steps, *psteps, *prate; unsigned bsteps, tsize, i, nchan, addroffset; struct keywest_iface* iface; int rc; psteps = (unsigned long *)get_property(np, "AAPL,address-step", NULL); steps = psteps ? (*psteps) : 0x10; /* Hrm... maybe we can be smarter here */ for (bsteps = 0; (steps & 0x01) == 0; bsteps++) steps >>= 1; if (!strcmp(np->parent->name, "uni-n")) { nchan = 2; addroffset = 3; } else { addroffset = 0; nchan = 1; } tsize = sizeof(struct keywest_iface) + (sizeof(struct keywest_chan) + 4) * nchan; iface = (struct keywest_iface *) kmalloc(tsize, GFP_KERNEL); if (iface == NULL) { printk(KERN_ERR "i2c-keywest: can't allocate inteface !\n"); return -ENOMEM; } memset(iface, 0, tsize); init_MUTEX(&iface->sem); spin_lock_init(&iface->lock); init_completion(&iface->complete); iface->bsteps = bsteps; iface->chan_count = nchan; iface->state = state_idle; iface->irq = np->intrs[0].line; iface->channels = (struct keywest_chan *) (((unsigned long)(iface + 1) + 3UL) & ~3UL); iface->base = (unsigned long)ioremap(np->addrs[0].address + addroffset, np->addrs[0].size); if (iface->base == 0) { printk(KERN_ERR "i2c-keywest: can't map inteface !\n"); kfree(iface); return -ENOMEM; } init_timer(&iface->timeout_timer); iface->timeout_timer.function = keywest_timeout; iface->timeout_timer.data = (unsigned long)iface; /* Select interface rate */ iface->cur_mode = KW_I2C_MODE_100KHZ; prate = (unsigned long *)get_property(np, "AAPL,i2c-rate", NULL); if (prate) switch(*prate) { case 100: iface->cur_mode = KW_I2C_MODE_100KHZ; break; case 50: iface->cur_mode = KW_I2C_MODE_50KHZ; break; case 25: iface->cur_mode = KW_I2C_MODE_25KHZ; break; default: printk(KERN_WARNING "i2c-keywest: unknown rate %ldKhz, using 100KHz\n", *prate); } /* Select standard sub mode */ iface->cur_mode |= KW_I2C_MODE_STANDARDSUB; /* Write mode */ write_reg(reg_mode, iface->cur_mode); /* Switch interrupts off & clear them*/ write_reg(reg_ier, 0x00); write_reg(reg_isr, KW_I2C_IRQ_MASK); /* Request chip interrupt */ rc = request_irq(iface->irq, keywest_irq, 0, "keywest i2c", iface); if (rc) { printk(KERN_ERR "i2c-keywest: can't get IRQ %d !\n", iface->irq); iounmap((void *)iface->base); kfree(iface); return -ENODEV; } dev_set_drvdata(dev, iface); for (i=0; i<nchan; i++) { struct keywest_chan* chan = &iface->channels[i]; u8 addr; sprintf(chan->adapter.name, "%s %d", np->parent->name, i); chan->iface = iface; chan->chan_no = i; chan->adapter.id = I2C_ALGO_SMBUS; chan->adapter.algo = &keywest_algorithm; chan->adapter.algo_data = NULL; chan->adapter.client_register = NULL; chan->adapter.client_unregister = NULL; i2c_set_adapdata(&chan->adapter, chan); chan->adapter.dev.parent = dev; rc = i2c_add_adapter(&chan->adapter); if (rc) { printk("i2c-keywest.c: Adapter %s registration failed\n", chan->adapter.name); i2c_set_adapdata(&chan->adapter, NULL); } if (probe) { printk("Probe: "); for (addr = 0x00; addr <= 0x7f; addr++) { if (i2c_smbus_xfer(&chan->adapter,addr, 0,0,0,I2C_SMBUS_QUICK,NULL) >= 0) printk("%02x ", addr); } printk("\n"); } } printk(KERN_INFO "Found KeyWest i2c on \"%s\", %d channel%s, stepping: %d bits\n", np->parent->name, nchan, nchan > 1 ? "s" : "", bsteps); return 0; }
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 octeon_i2c_probe(struct platform_device *pdev) { int irq, result = 0; struct octeon_i2c *i2c; struct resource *res_mem; /* All adaptors have an irq. */ irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); if (!i2c) { dev_err(&pdev->dev, "kzalloc failed\n"); result = -ENOMEM; goto out; } i2c->dev = &pdev->dev; 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 out; } i2c->twsi_phys = res_mem->start; i2c->regsize = resource_size(res_mem); /* * "clock-rate" is a legacy binding, the official binding is * "clock-frequency". Try the official one first and then * fall back if it doesn't exist. */ if (of_property_read_u32(pdev->dev.of_node, "clock-frequency", &i2c->twsi_freq) && of_property_read_u32(pdev->dev.of_node, "clock-rate", &i2c->twsi_freq)) { dev_err(i2c->dev, "no I2C 'clock-rate' or 'clock-frequency' property\n"); result = -ENXIO; goto out; } i2c->sys_freq = octeon_get_io_clock_rate(); if (!devm_request_mem_region(&pdev->dev, i2c->twsi_phys, i2c->regsize, res_mem->name)) { dev_err(i2c->dev, "request_mem_region failed\n"); goto out; } i2c->twsi_base = devm_ioremap(&pdev->dev, i2c->twsi_phys, i2c->regsize); init_waitqueue_head(&i2c->queue); i2c->irq = irq; result = devm_request_irq(&pdev->dev, i2c->irq, octeon_i2c_isr, 0, DRV_NAME, i2c); if (result < 0) { dev_err(i2c->dev, "failed to attach interrupt\n"); goto out; } result = octeon_i2c_initlowlevel(i2c); if (result) { dev_err(i2c->dev, "init low level failed\n"); goto out; } result = octeon_i2c_setclock(i2c); if (result) { dev_err(i2c->dev, "clock init failed\n"); goto out; } i2c->adap = octeon_i2c_ops; i2c->adap.dev.parent = &pdev->dev; i2c->adap.dev.of_node = pdev->dev.of_node; i2c_set_adapdata(&i2c->adap, i2c); platform_set_drvdata(pdev, i2c); result = i2c_add_adapter(&i2c->adap); if (result < 0) { dev_err(i2c->dev, "failed to add adapter\n"); goto out; } dev_info(i2c->dev, "version %s\n", DRV_VERSION); of_i2c_register_devices(&i2c->adap); return 0; out: return result; };
static int riic_i2c_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct riic_dev *riic; struct i2c_adapter *adap; struct resource *res; u32 bus_rate = 0; int i, ret; riic = devm_kzalloc(&pdev->dev, sizeof(*riic), GFP_KERNEL); if (!riic) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); riic->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(riic->base)) return PTR_ERR(riic->base); riic->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(riic->clk)) { dev_err(&pdev->dev, "missing controller clock"); return PTR_ERR(riic->clk); } for (i = 0; i < ARRAY_SIZE(riic_irqs); i++) { res = platform_get_resource(pdev, IORESOURCE_IRQ, riic_irqs[i].res_num); if (!res) return -ENODEV; ret = devm_request_irq(&pdev->dev, res->start, riic_irqs[i].isr, 0, riic_irqs[i].name, riic); if (ret) { dev_err(&pdev->dev, "failed to request irq %s\n", riic_irqs[i].name); return ret; } } adap = &riic->adapter; i2c_set_adapdata(adap, riic); strlcpy(adap->name, "Renesas RIIC adapter", sizeof(adap->name)); adap->owner = THIS_MODULE; adap->algo = &riic_algo; adap->dev.parent = &pdev->dev; adap->dev.of_node = pdev->dev.of_node; init_completion(&riic->msg_done); of_property_read_u32(np, "clock-frequency", &bus_rate); ret = riic_init_hw(riic, bus_rate); if (ret) return ret; ret = i2c_add_adapter(adap); if (ret) { dev_err(&pdev->dev, "failed to add adapter\n"); return ret; } platform_set_drvdata(pdev, riic); dev_info(&pdev->dev, "registered with %dHz bus speed\n", bus_rate); return 0; }
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; }
/* Platform driver interface */ static int zd1301_demod_probe(struct platform_device *pdev) { struct zd1301_demod_dev *dev; struct zd1301_demod_platform_data *pdata = pdev->dev.platform_data; int ret; dev_dbg(&pdev->dev, "\n"); if (!pdata) { ret = -EINVAL; dev_err(&pdev->dev, "cannot proceed without platform data\n"); goto err; } if (!pdev->dev.parent->driver) { ret = -EINVAL; dev_dbg(&pdev->dev, "no parent device\n"); goto err; } dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { ret = -ENOMEM; goto err; } /* Setup the state */ dev->pdev = pdev; dev->gain = zd1301_demod_gain; /* Sleep */ ret = zd1301_demod_wreg(dev, 0x6840, 0x21); if (ret) goto err_kfree; ret = zd1301_demod_wreg(dev, 0x6a38, 0x07); if (ret) goto err_kfree; /* Create I2C adapter */ strlcpy(dev->adapter.name, "ZyDAS ZD1301 demod", sizeof(dev->adapter.name)); dev->adapter.algo = &zd1301_demod_i2c_algorithm; dev->adapter.algo_data = NULL; dev->adapter.dev.parent = pdev->dev.parent; i2c_set_adapdata(&dev->adapter, dev); ret = i2c_add_adapter(&dev->adapter); if (ret) { dev_err(&pdev->dev, "I2C adapter add failed %d\n", ret); goto err_kfree; } /* Create dvb frontend */ memcpy(&dev->frontend.ops, &zd1301_demod_ops, sizeof(dev->frontend.ops)); dev->frontend.demodulator_priv = dev; platform_set_drvdata(pdev, dev); dev_info(&pdev->dev, "ZyDAS ZD1301 demod attached\n"); return 0; err_kfree: kfree(dev); err: dev_dbg(&pdev->dev, "failed=%d\n", ret); return ret; }
/* init + register i2c algo-bit adapter */ int init_cx18_i2c(struct cx18 *cx) { int i; CX18_DEBUG_I2C("i2c init\n"); /* Sanity checks for the I2C hardware arrays. They must be the * same size and GPIO/CX23418 must be the last entries. */ if (ARRAY_SIZE(hw_driverids) != ARRAY_SIZE(hw_addrs) || ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) || CX18_HW_GPIO != (1 << (ARRAY_SIZE(hw_addrs) - 2)) || CX18_HW_CX23418 != (1 << (ARRAY_SIZE(hw_addrs) - 1)) || hw_driverids[ARRAY_SIZE(hw_addrs) - 1]) { CX18_ERR("Mismatched I2C hardware arrays\n"); return -ENODEV; } for (i = 0; i < 2; i++) { memcpy(&cx->i2c_adap[i], &cx18_i2c_adap_template, sizeof(struct i2c_adapter)); memcpy(&cx->i2c_algo[i], &cx18_i2c_algo_template, sizeof(struct i2c_algo_bit_data)); cx->i2c_algo_cb_data[i].cx = cx; cx->i2c_algo_cb_data[i].bus_index = i; cx->i2c_algo[i].data = &cx->i2c_algo_cb_data[i]; cx->i2c_adap[i].algo_data = &cx->i2c_algo[i]; sprintf(cx->i2c_adap[i].name + strlen(cx->i2c_adap[i].name), " #%d-%d", cx->num, i); i2c_set_adapdata(&cx->i2c_adap[i], cx); memcpy(&cx->i2c_client[i], &cx18_i2c_client_template, sizeof(struct i2c_client)); sprintf(cx->i2c_client[i].name + strlen(cx->i2c_client[i].name), "%d", i); cx->i2c_client[i].adapter = &cx->i2c_adap[i]; cx->i2c_adap[i].dev.parent = &cx->dev->dev; } if (cx18_read_reg(cx, CX18_REG_I2C_2_WR) != 0x0003c02f) { /* Reset/Unreset I2C hardware block */ /* Clock select 220MHz */ cx18_write_reg_expect(cx, 0x10000000, 0xc71004, 0x00000000, 0x10001000); /* Clock Enable */ cx18_write_reg_expect(cx, 0x10001000, 0xc71024, 0x00001000, 0x10001000); } /* courtesy of Steven Toth <*****@*****.**> */ cx18_write_reg_expect(cx, 0x00c00000, 0xc7001c, 0x00000000, 0x00c000c0); mdelay(10); cx18_write_reg_expect(cx, 0x00c000c0, 0xc7001c, 0x000000c0, 0x00c000c0); mdelay(10); cx18_write_reg_expect(cx, 0x00c00000, 0xc7001c, 0x00000000, 0x00c000c0); mdelay(10); /* Set to edge-triggered intrs. */ cx18_write_reg(cx, 0x00c00000, 0xc730c8); /* Clear any stale intrs */ cx18_write_reg_expect(cx, HW2_I2C1_INT|HW2_I2C2_INT, HW2_INT_CLR_STATUS, ~(HW2_I2C1_INT|HW2_I2C2_INT), HW2_I2C1_INT|HW2_I2C2_INT); /* Hw I2C1 Clock Freq ~100kHz */ cx18_write_reg(cx, 0x00021c0f & ~4, CX18_REG_I2C_1_WR); cx18_setscl(&cx->i2c_algo_cb_data[0], 1); cx18_setsda(&cx->i2c_algo_cb_data[0], 1); /* Hw I2C2 Clock Freq ~100kHz */ cx18_write_reg(cx, 0x00021c0f & ~4, CX18_REG_I2C_2_WR); cx18_setscl(&cx->i2c_algo_cb_data[1], 1); cx18_setsda(&cx->i2c_algo_cb_data[1], 1); cx18_reset_i2c_slaves_gpio(cx); return i2c_bit_add_bus(&cx->i2c_adap[0]) || i2c_bit_add_bus(&cx->i2c_adap[1]); }
static int wmt_i2c_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct wmt_i2c_dev *i2c_dev; struct i2c_adapter *adap; struct resource *res; int err; u32 clk_rate; i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL); if (!i2c_dev) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2c_dev->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(i2c_dev->base)) return PTR_ERR(i2c_dev->base); i2c_dev->irq = irq_of_parse_and_map(np, 0); if (!i2c_dev->irq) { dev_err(&pdev->dev, "irq missing or invalid\n"); return -EINVAL; } i2c_dev->clk = of_clk_get(np, 0); if (IS_ERR(i2c_dev->clk)) { dev_err(&pdev->dev, "unable to request clock\n"); return PTR_ERR(i2c_dev->clk); } i2c_dev->mode = I2C_MODE_STANDARD; err = of_property_read_u32(np, "clock-frequency", &clk_rate); if ((!err) && (clk_rate == 400000)) i2c_dev->mode = I2C_MODE_FAST; i2c_dev->dev = &pdev->dev; err = devm_request_irq(&pdev->dev, i2c_dev->irq, wmt_i2c_isr, 0, "i2c", i2c_dev); if (err) { dev_err(&pdev->dev, "failed to request irq %i\n", i2c_dev->irq); return err; } adap = &i2c_dev->adapter; i2c_set_adapdata(adap, i2c_dev); strlcpy(adap->name, "WMT I2C adapter", sizeof(adap->name)); adap->owner = THIS_MODULE; adap->algo = &wmt_i2c_algo; adap->dev.parent = &pdev->dev; adap->dev.of_node = pdev->dev.of_node; init_completion(&i2c_dev->complete); err = wmt_i2c_reset_hardware(i2c_dev); if (err) { dev_err(&pdev->dev, "error initializing hardware\n"); return err; } err = i2c_add_adapter(adap); if (err) { dev_err(&pdev->dev, "failed to add adapter\n"); return err; } platform_set_drvdata(pdev, i2c_dev); return 0; }
/* init + register i2c algo-bit adapter */ int cobalt_i2c_init(struct cobalt *cobalt) { int i, err; int status; int prescale; unsigned long start_time; cobalt_dbg(1, "i2c init\n"); /* Define I2C clock prescaler */ prescale = ((ALT_CPU_FREQ) / (5 * I2C_FREQUENCY)) - 1; for (i = 0; i < COBALT_NUM_ADAPTERS; i++) { struct cobalt_i2c_regs __iomem *regs = cobalt_i2c_regs(cobalt, i); struct i2c_adapter *adap = &cobalt->i2c_adap[i]; /* Disable I2C */ iowrite8(M00018_CTR_BITMAP_EN_MSK, ®s->cr_sr); iowrite8(0, ®s->ctr); iowrite8(0, ®s->cr_sr); start_time = jiffies; do { if (time_after(jiffies, start_time + HZ)) { if (cobalt_ignore_err) { adap->dev.parent = NULL; return 0; } return -ETIMEDOUT; } status = ioread8(®s->cr_sr); } while (status & M00018_SR_BITMAP_TIP_MSK); /* Disable I2C */ iowrite8(0, ®s->ctr); iowrite8(0, ®s->cr_sr); /* Calculate i2c prescaler */ iowrite8(prescale & 0xff, ®s->prerlo); iowrite8((prescale >> 8) & 0xff, ®s->prerhi); /* Enable I2C, interrupts disabled */ iowrite8(M00018_CTR_BITMAP_EN_MSK, ®s->ctr); /* Setup algorithm for adapter */ cobalt->i2c_data[i].cobalt = cobalt; cobalt->i2c_data[i].regs = regs; *adap = cobalt_i2c_adap_template; adap->algo = &cobalt_algo; adap->algo_data = &cobalt->i2c_data[i]; adap->retries = 3; sprintf(adap->name + strlen(adap->name), " #%d-%d", cobalt->instance, i); i2c_set_adapdata(adap, &cobalt->v4l2_dev); adap->dev.parent = &cobalt->pci_dev->dev; err = i2c_add_adapter(adap); if (err) { if (cobalt_ignore_err) { adap->dev.parent = NULL; return 0; } while (i--) i2c_del_adapter(&cobalt->i2c_adap[i]); return err; } cobalt_info("registered bus %s\n", adap->name); } return 0; }
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 __init i2c_davinci_init(void) { int status; struct device *dev = NULL; DEB0("%s %s", __TIME__, __DATE__); DEB1("i2c_davinci_init()"); if (cpu_is_davinci_dm6467()) davinci_i2c_expander_op (0x3A, I2C_INT_DM646X, 0); /* * NOTE: On DaVinci EVM, the i2c bus frequency is set to 20kHz * so that the MSP430, which is doing software i2c, has * some extra processing time */ if (machine_is_davinci_evm()) i2c_davinci_busFreq = 20; else if (machine_is_davinci_dm6467_evm()) i2c_davinci_busFreq = 100; else if (i2c_davinci_busFreq > 200) i2c_davinci_busFreq = 400; /*Fast mode */ else i2c_davinci_busFreq = 100; /*Standard mode */ i2c_clock = clk_get (dev, "I2CCLK"); if (IS_ERR(i2c_clock)) return -1; clk_use (i2c_clock); clk_enable (i2c_clock); i2c_davinci_inputClock = clk_get_rate (i2c_clock); DEB1 ("IP CLOCK = %ld", i2c_davinci_inputClock); memset(&i2c_davinci_dev, 0, sizeof(i2c_davinci_dev)); init_waitqueue_head(&i2c_davinci_dev.cmd_wait); i2c_davinci_dev.regs = (davinci_i2cregsovly)I2C_BASE; status = (int)request_region(I2C_BASE, I2C_IOSIZE, MODULE_NAME); if (!status) { i2c_err("I2C is already in use\n"); return -ENODEV; } status = request_irq(IRQ_I2C, i2c_davinci_isr, 0, "i2c", &i2c_davinci_dev); if (status) { i2c_err("failed to request I2C IRQ"); goto do_release_region; } i2c_set_adapdata(&i2c_davinci_adap, &i2c_davinci_dev); status = i2c_add_adapter(&i2c_davinci_adap); if (status) { i2c_err("failed to add adapter"); goto do_free_irq; } i2c_davinci_reset(&i2c_davinci_dev); if (driver_register(&davinci_i2c_driver) != 0) printk(KERN_ERR "Driver register failed for davinci_i2c\n"); if (platform_device_register(&davinci_i2c_device) != 0) { printk(KERN_ERR "Device register failed for i2c\n"); driver_unregister(&davinci_i2c_driver); } return 0; do_free_irq: free_irq(IRQ_I2C, &i2c_davinci_dev); do_release_region: release_region(I2C_BASE, I2C_IOSIZE); return status; }
static int xiic_i2c_probe(struct platform_device *pdev) { struct xiic_i2c *i2c; struct xiic_i2c_platform_data *pdata; struct resource *res; int ret, irq; u8 i; u32 sr; i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); if (!i2c) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); i2c->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(i2c->base)) return PTR_ERR(i2c->base); irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; pdata = dev_get_platdata(&pdev->dev); /* hook up driver to tree */ platform_set_drvdata(pdev, i2c); i2c->adap = xiic_adapter; i2c_set_adapdata(&i2c->adap, i2c); i2c->adap.dev.parent = &pdev->dev; i2c->adap.dev.of_node = pdev->dev.of_node; mutex_init(&i2c->lock); init_waitqueue_head(&i2c->wait); i2c->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(i2c->clk)) { dev_err(&pdev->dev, "input clock not found.\n"); return PTR_ERR(i2c->clk); } ret = clk_prepare_enable(i2c->clk); if (ret) { dev_err(&pdev->dev, "Unable to enable clock.\n"); return ret; } i2c->dev = &pdev->dev; pm_runtime_enable(i2c->dev); pm_runtime_set_autosuspend_delay(i2c->dev, XIIC_PM_TIMEOUT); pm_runtime_use_autosuspend(i2c->dev); pm_runtime_set_active(i2c->dev); ret = devm_request_threaded_irq(&pdev->dev, irq, xiic_isr, xiic_process, IRQF_ONESHOT, pdev->name, i2c); if (ret < 0) { dev_err(&pdev->dev, "Cannot claim IRQ\n"); goto err_clk_dis; } /* * Detect endianness * Try to reset the TX FIFO. Then check the EMPTY flag. If it is not * set, assume that the endianness was wrong and swap. */ i2c->endianness = LITTLE; xiic_setreg32(i2c, XIIC_CR_REG_OFFSET, XIIC_CR_TX_FIFO_RESET_MASK); /* Reset is cleared in xiic_reinit */ sr = xiic_getreg32(i2c, XIIC_SR_REG_OFFSET); if (!(sr & XIIC_SR_TX_FIFO_EMPTY_MASK)) i2c->endianness = BIG; xiic_reinit(i2c); /* add i2c adapter to i2c tree */ ret = i2c_add_adapter(&i2c->adap); if (ret) { xiic_deinit(i2c); goto err_clk_dis; } if (pdata) { /* add in known devices to the bus */ for (i = 0; i < pdata->num_devices; i++) i2c_new_device(&i2c->adap, pdata->devices + i); } return 0; err_clk_dis: pm_runtime_set_suspended(&pdev->dev); pm_runtime_disable(&pdev->dev); clk_disable_unprepare(i2c->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 = (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; }
static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap) { int ret; struct dvb_usb_device *d = adap_to_d(adap); struct rtl28xxu_priv *priv = d_to_priv(d); struct dvb_frontend *fe = NULL; struct i2c_board_info info; struct i2c_client *client; dev_dbg(&d->udev->dev, "%s:\n", __func__); memset(&info, 0, sizeof(struct i2c_board_info)); switch (priv->tuner) { case TUNER_RTL2832_FC0012: fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap, &rtl2832u_fc0012_config); /* since fc0012 includs reading the signal strength delegate * that to the tuner driver */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; /* attach SDR */ dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap, &rtl28xxu_rtl2832_fc0012_config, NULL); break; case TUNER_RTL2832_FC0013: fe = dvb_attach(fc0013_attach, adap->fe[0], &d->i2c_adap, 0xc6>>1, 0, FC_XTAL_28_8_MHZ); /* fc0013 also supports signal strength reading */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; /* attach SDR */ dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap, &rtl28xxu_rtl2832_fc0013_config, NULL); break; case TUNER_RTL2832_E4000: { struct v4l2_subdev *sd; struct i2c_adapter *i2c_adap_internal = rtl2832_get_private_i2c_adapter(adap->fe[0]); struct e4000_config e4000_config = { .fe = adap->fe[0], .clock = 28800000, }; strlcpy(info.type, "e4000", I2C_NAME_SIZE); info.addr = 0x64; info.platform_data = &e4000_config; request_module(info.type); client = i2c_new_device(priv->demod_i2c_adapter, &info); if (client == NULL || client->dev.driver == NULL) break; if (!try_module_get(client->dev.driver->owner)) { i2c_unregister_device(client); break; } priv->i2c_client_tuner = client; sd = i2c_get_clientdata(client); i2c_set_adapdata(i2c_adap_internal, d); /* attach SDR */ dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], i2c_adap_internal, &rtl28xxu_rtl2832_e4000_config, sd); } break; case TUNER_RTL2832_FC2580: fe = dvb_attach(fc2580_attach, adap->fe[0], &d->i2c_adap, &rtl2832u_fc2580_config); break; case TUNER_RTL2832_TUA9001: /* enable GPIO1 and GPIO4 as output */ ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_DIR, 0x00, 0x12); if (ret) goto err; ret = rtl28xx_wr_reg_mask(d, SYS_GPIO_OUT_EN, 0x12, 0x12); if (ret) goto err; fe = dvb_attach(tua9001_attach, adap->fe[0], &d->i2c_adap, &rtl2832u_tua9001_config); break; case TUNER_RTL2832_R820T: fe = dvb_attach(r820t_attach, adap->fe[0], &d->i2c_adap, &rtl2832u_r820t_config); /* Use tuner to get the signal strength */ adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; /* attach SDR */ dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap, &rtl28xxu_rtl2832_r820t_config, NULL); break; case TUNER_RTL2832_R828D: fe = dvb_attach(r820t_attach, adap->fe[0], priv->demod_i2c_adapter, &rtl2832u_r828d_config); adap->fe[0]->ops.read_signal_strength = adap->fe[0]->ops.tuner_ops.get_rf_strength; if (adap->fe[1]) { fe = dvb_attach(r820t_attach, adap->fe[1], priv->demod_i2c_adapter, &rtl2832u_r828d_config); adap->fe[1]->ops.read_signal_strength = adap->fe[1]->ops.tuner_ops.get_rf_strength; } /* attach SDR */ dvb_attach_sdr(rtl2832_sdr_attach, adap->fe[0], &d->i2c_adap, &rtl28xxu_rtl2832_r820t_config, NULL); break; default: dev_err(&d->udev->dev, "%s: unknown tuner=%d\n", KBUILD_MODNAME, priv->tuner); } if (fe == NULL && priv->i2c_client_tuner == NULL) { ret = -ENODEV; goto err; } return 0; err: dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); return ret; } static int rtl2832u_tuner_detach(struct dvb_usb_adapter *adap) { struct dvb_usb_device *d = adap_to_d(adap); struct rtl28xxu_priv *priv = d_to_priv(d); struct i2c_client *client; dev_dbg(&d->udev->dev, "%s:\n", __func__); /* remove I2C tuner */ client = priv->i2c_client_tuner; if (client) { module_put(client->dev.driver->owner); i2c_unregister_device(client); } return 0; } static int rtl28xxu_init(struct dvb_usb_device *d) { int ret; u8 val; dev_dbg(&d->udev->dev, "%s:\n", __func__); /* init USB endpoints */ ret = rtl28xx_rd_reg(d, USB_SYSCTL_0, &val); if (ret) goto err; /* enable DMA and Full Packet Mode*/ val |= 0x09; ret = rtl28xx_wr_reg(d, USB_SYSCTL_0, val); if (ret) goto err; /* set EPA maximum packet size to 0x0200 */ ret = rtl28xx_wr_regs(d, USB_EPA_MAXPKT, "\x00\x02\x00\x00", 4); if (ret) goto err; /* change EPA FIFO length */ ret = rtl28xx_wr_regs(d, USB_EPA_FIFO_CFG, "\x14\x00\x00\x00", 4); if (ret) goto err; return ret; err: dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); return ret; }
static int uniphier_i2c_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct uniphier_i2c_priv *priv; struct resource *regs; u32 bus_speed; unsigned long clk_rate; int irq, ret; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->membase = devm_ioremap_resource(dev, regs); if (IS_ERR(priv->membase)) return PTR_ERR(priv->membase); irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "failed to get IRQ number\n"); return irq; } if (of_property_read_u32(dev->of_node, "clock-frequency", &bus_speed)) bus_speed = UNIPHIER_I2C_DEFAULT_SPEED; if (!bus_speed || bus_speed > UNIPHIER_I2C_MAX_SPEED) { dev_err(dev, "invalid clock-frequency %d\n", bus_speed); return -EINVAL; } priv->clk = devm_clk_get(dev, NULL); if (IS_ERR(priv->clk)) { dev_err(dev, "failed to get clock\n"); return PTR_ERR(priv->clk); } ret = clk_prepare_enable(priv->clk); if (ret) return ret; clk_rate = clk_get_rate(priv->clk); if (!clk_rate) { dev_err(dev, "input clock rate should not be zero\n"); ret = -EINVAL; goto disable_clk; } init_completion(&priv->comp); priv->adap.owner = THIS_MODULE; priv->adap.algo = &uniphier_i2c_algo; priv->adap.dev.parent = dev; priv->adap.dev.of_node = dev->of_node; strlcpy(priv->adap.name, "UniPhier I2C", sizeof(priv->adap.name)); priv->adap.bus_recovery_info = &uniphier_i2c_bus_recovery_info; i2c_set_adapdata(&priv->adap, priv); platform_set_drvdata(pdev, priv); uniphier_i2c_hw_init(priv, bus_speed, clk_rate); ret = devm_request_irq(dev, irq, uniphier_i2c_interrupt, 0, pdev->name, priv); if (ret) { dev_err(dev, "failed to request irq %d\n", irq); goto disable_clk; } ret = i2c_add_adapter(&priv->adap); disable_clk: if (ret) clk_disable_unprepare(priv->clk); 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 = IO_ADDRESS(res->start); /* * Request the I2C interrupt */ mxc_i2c->irq = platform_get_irq(pdev, 0); if (mxc_i2c->irq < 0) { ret = mxc_i2c->irq; goto err1; } ret = request_irq(mxc_i2c->irq, mxc_i2c_handler, 0, pdev->name, mxc_i2c); if (ret < 0) { goto err1; } 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 */ strcpy(mxc_i2c->adap.name, MXC_ADAPTER_NAME); mxc_i2c->adap.id = 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); if ((ret = i2c_add_adapter(&mxc_i2c->adap)) < 0) { goto err2; } printk(KERN_INFO "MXC I2C driver\n"); return 0; err2: free_irq(mxc_i2c->irq, mxc_i2c); gpio_i2c_inactive(id); err1: dev_err(&pdev->dev, "failed to probe i2c adapter\n"); kfree(mxc_i2c); return ret; }
static int __devinit ocores_i2c_probe(struct platform_device *pdev) { struct ocores_i2c *i2c; struct ocores_i2c_platform_data *pdata; struct resource *res, *res2; int ret; int i; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; res2 = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res2) return -ENODEV; i2c = devm_kzalloc(&pdev->dev, sizeof(*i2c), GFP_KERNEL); if (!i2c) return -ENOMEM; if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res), pdev->name)) { dev_err(&pdev->dev, "Memory region busy\n"); return -EBUSY; } i2c->base = devm_ioremap_nocache(&pdev->dev, res->start, resource_size(res)); if (!i2c->base) { dev_err(&pdev->dev, "Unable to map registers\n"); return -EIO; } pdata = pdev->dev.platform_data; if (pdata) { i2c->regstep = pdata->regstep; i2c->clock_khz = pdata->clock_khz; } else { ret = ocores_i2c_of_probe(pdev, i2c); if (ret) return ret; } ocores_init(i2c); init_waitqueue_head(&i2c->wait); ret = devm_request_irq(&pdev->dev, res2->start, ocores_isr, 0, pdev->name, i2c); if (ret) { dev_err(&pdev->dev, "Cannot claim IRQ\n"); return ret; } /* hook up driver to tree */ platform_set_drvdata(pdev, i2c); i2c->adap = ocores_adapter; i2c_set_adapdata(&i2c->adap, i2c); i2c->adap.dev.parent = &pdev->dev; i2c->adap.dev.of_node = pdev->dev.of_node; /* add i2c adapter to i2c tree */ ret = i2c_add_adapter(&i2c->adap); if (ret) { dev_err(&pdev->dev, "Failed to add adapter\n"); return ret; } /* add in known devices to the bus */ if (pdata) { for (i = 0; i < pdata->num_devices; i++) i2c_new_device(&i2c->adap, pdata->devices + i); } return 0; }