static int __init i2c_bitvelle_init(void) { printk(KERN_INFO "i2c-velleman.o: i2c Velleman K8000 adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); if (base==0) { /* probe some values */ base=DEFAULT_BASE; bit_velle_data.data=(void*)DEFAULT_BASE; if (bit_velle_init()==0) { if(i2c_bit_add_bus(&bit_velle_ops) < 0) return -ENODEV; } else { return -ENODEV; } } else { bit_velle_data.data=(void*)base; if (bit_velle_init()==0) { if(i2c_bit_add_bus(&bit_velle_ops) < 0) return -ENODEV; } else { return -ENODEV; } } printk(KERN_DEBUG "i2c-velleman.o: found device at %#x.\n",base); return 0; }
int __init i2c_bitelv_init(void) { printk(KERN_INFO "i2c-elv.o: i2c ELV parallel port adapter module version %s (%s)\n", I2C_VERSION, I2C_DATE); if (base==0) { /* probe some values */ base=DEFAULT_BASE; bit_elv_data.data=(void*)DEFAULT_BASE; if (bit_elv_init()==0) { if(i2c_bit_add_bus(&bit_elv_ops) < 0) return -ENODEV; } else { return -ENODEV; } } else { bit_elv_ops.data=(void*)base; if (bit_elv_init()==0) { if(i2c_bit_add_bus(&bit_elv_ops) < 0) return -ENODEV; } else { return -ENODEV; } } printk(KERN_DEBUG "i2c-elv.o: found device at %#x.\n",base); return 0; }
static int __init i2c_bitvelle_init(void) { printk("i2c-velleman.o: i2c Velleman K8000 adapter module\n"); if (base==0) { /* probe some values */ base=DEFAULT_BASE; bit_velle_data.data=(void*)DEFAULT_BASE; if (bit_velle_init()==0) { if(i2c_bit_add_bus(&bit_velle_ops) < 0) return -ENODEV; } else { return -ENODEV; } } else { bit_velle_data.data=(void*)base; if (bit_velle_init()==0) { if(i2c_bit_add_bus(&bit_velle_ops) < 0) return -ENODEV; } else { return -ENODEV; } } printk("i2c-velleman.o: found device at %#x.\n",base); return 0; }
int __init i2c_bitelv_init(void) { printk("i2c-elv.o: i2c ELV parallel port adapter module\n"); if (base==0) { /* probe some values */ base=DEFAULT_BASE; bit_elv_data.data=(void*)DEFAULT_BASE; if (bit_elv_init()==0) { if(i2c_bit_add_bus(&bit_elv_ops) < 0) return -ENODEV; } else { return -ENODEV; } } else { bit_elv_ops.data=(void*)base; if (bit_elv_init()==0) { if(i2c_bit_add_bus(&bit_elv_ops) < 0) return -ENODEV; } else { return -ENODEV; } } printk("i2c-elv.o: found device at %#x.\n",base); return 0; }
/* init + register i2c algo-bit adapter */ int init_cx18_i2c(struct cx18 *cx) { int i; CX18_DEBUG_I2C("i2c init\n"); 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 (read_reg(CX18_REG_I2C_2_WR) != 0x0003c02f) { /* Reset/Unreset I2C hardware block */ write_reg(0x10000000, 0xc71004); /* Clock select 220MHz */ write_reg_sync(0x10001000, 0xc71024); /* Clock Enable */ } /* courtesy of Steven Toth <*****@*****.**> */ write_reg_sync(0x00c00000, 0xc7001c); mdelay(10); write_reg_sync(0x00c000c0, 0xc7001c); mdelay(10); write_reg_sync(0x00c00000, 0xc7001c); write_reg_sync(0x00c00000, 0xc730c8); /* Set to edge-triggered intrs. */ write_reg_sync(0x00c00000, 0xc730c4); /* Clear any stale intrs */ /* Hw I2C1 Clock Freq ~100kHz */ write_reg_sync(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 */ write_reg_sync(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 savage_setup_i2c_bus(struct savagefb_i2c_chan *chan, const char *name) { int rc = 0; if (chan->par) { strcpy(chan->adapter.name, name); chan->adapter.owner = THIS_MODULE; chan->adapter.id = I2C_HW_B_SAVAGE; chan->adapter.algo_data = &chan->algo; chan->adapter.dev.parent = &chan->par->pcidev->dev; chan->algo.udelay = 10; chan->algo.timeout = 20; chan->algo.data = chan; i2c_set_adapdata(&chan->adapter, chan); /* Raise SCL and SDA */ chan->algo.setsda(chan, 1); chan->algo.setscl(chan, 1); udelay(20); rc = i2c_bit_add_bus(&chan->adapter); if (rc == 0) dev_dbg(&chan->par->pcidev->dev, "I2C bus %s registered.\n", name); else dev_warn(&chan->par->pcidev->dev, "Failed to register I2C bus %s.\n", name); } else chan->par = NULL; return rc; }
/* * adapter initialisation */ static int i2c_register_bus(struct pci_dev *dev, struct s_i2c_bus *p, u8 *mmvga, u32 i2c_reg) { int ret; p->adap.owner = THIS_MODULE; p->adap.id = I2C_HW_B_S3VIA; p->adap.algo_data = &p->algo; p->adap.dev.parent = &dev->dev; p->algo.setsda = bit_s3via_setsda; p->algo.setscl = bit_s3via_setscl; p->algo.getsda = bit_s3via_getsda; p->algo.getscl = bit_s3via_getscl; p->algo.udelay = CYCLE_DELAY; p->algo.mdelay = CYCLE_DELAY; p->algo.timeout = TIMEOUT; p->algo.data = p; p->mmvga = mmvga; p->i2c_reg = i2c_reg; ret = i2c_bit_add_bus(&p->adap); if (ret) { return ret; } p->adap_ok = 1; return 0; }
static int radeon_setup_i2c_bus(struct radeon_i2c_chan *chan, const char *name) { int rc; snprintf(chan->adapter.name, sizeof(chan->adapter.name), "radeonfb %s", name); chan->adapter.owner = THIS_MODULE; chan->adapter.algo_data = &chan->algo; chan->adapter.dev.parent = &chan->rinfo->pdev->dev; chan->algo.setsda = radeon_gpio_setsda; chan->algo.setscl = radeon_gpio_setscl; chan->algo.getsda = radeon_gpio_getsda; chan->algo.getscl = radeon_gpio_getscl; chan->algo.udelay = 10; chan->algo.timeout = 20; chan->algo.data = chan; i2c_set_adapdata(&chan->adapter, chan); /* Raise SCL and SDA */ radeon_gpio_setsda(chan, 1); radeon_gpio_setscl(chan, 1); udelay(20); rc = i2c_bit_add_bus(&chan->adapter); if (rc == 0) dev_dbg(&chan->rinfo->pdev->dev, "I2C bus %s registered.\n", name); else dev_warn(&chan->rinfo->pdev->dev, "Failed to register I2C bus %s.\n", name); return rc; }
static int scx200_i2c_init(void) { pr_debug("NatSemi SCx200 I2C Driver\n"); if (!scx200_gpio_present()) { pr_err("no SCx200 gpio pins available\n"); return -ENODEV; } pr_debug("SCL=GPIO%02u, SDA=GPIO%02u\n", scl, sda); if (scl == -1 || sda == -1 || scl == sda) { pr_err("scl and sda must be specified\n"); return -EINVAL; } /* Configure GPIOs as open collector outputs */ scx200_gpio_configure(scl, ~2, 5); scx200_gpio_configure(sda, ~2, 5); if (i2c_bit_add_bus(&scx200_i2c_ops) < 0) { pr_err("adapter %s registration failed\n", scx200_i2c_ops.name); return -ENODEV; } return 0; }
static int __init ixdp2400_i2c_init(void) { if(machine_is_ixdp2400()) { int i = 0; /* * GPIO2 needs to be high for SDA to work on this board */ gpio_line_set(IXDP2400_GPIO_HIGH, 1); gpio_line_config(IXDP2400_GPIO_HIGH, GPIO_OUT); ixdp2400_gpio.sda_gpio = IXDP2400_GPIO_SCL; ixdp2400_gpio.scl_gpio = IXDP2400_GPIO_SDA; gpio_line_config(ixdp2400_gpio.sda_gpio, GPIO_OUT); gpio_line_config(ixdp2400_gpio.scl_gpio, GPIO_OUT); gpio_line_set(ixdp2400_gpio.scl_gpio, 0); gpio_line_set(ixdp2400_gpio.sda_gpio, 0); gpio_line_config(ixdp2400_gpio.scl_gpio, GPIO_IN); for(i = 0; i < 10; i++); gpio_line_config(ixdp2400_gpio.sda_gpio, GPIO_IN); } if (i2c_bit_add_bus(&ixdp2400_i2c_adapter)) { printk("i2c-ixdp2400: I2C adapter registration failed\n"); return -EIO; } else printk("i2c-ixdp2400: I2C bus initialized\n"); return 0; }
static int i810_setup_i2c_bus(struct i810fb_i2c_chan *chan, const char *name) { int rc; strcpy(chan->adapter.name, name); chan->adapter.owner = THIS_MODULE; chan->adapter.algo_data = &chan->algo; chan->adapter.dev.parent = &chan->par->dev->dev; chan->algo.setsda = i810i2c_setsda; chan->algo.setscl = i810i2c_setscl; chan->algo.getsda = i810i2c_getsda; chan->algo.getscl = i810i2c_getscl; chan->algo.udelay = 10; chan->algo.timeout = (HZ/2); chan->algo.data = chan; i2c_set_adapdata(&chan->adapter, chan); /* Raise SCL and SDA */ chan->algo.setsda(chan, 1); chan->algo.setscl(chan, 1); udelay(20); rc = i2c_bit_add_bus(&chan->adapter); if (rc == 0) dev_dbg(&chan->par->dev->dev, "I2C bus %s registered.\n",name); else { dev_warn(&chan->par->dev->dev, "Failed to register I2C bus " "%s.\n", name); chan->par = NULL; } return rc; }
int __init i2c_savage4_init(void) { int res; printk("i2c-savage4.o version %s (%s)\n", LM_VERSION, LM_DATE); savage4_initialized = 0; if ((res = savage4_setup())) { printk ("i2c-savage4.o: Savage4 not detected, module not inserted.\n"); savage4_cleanup(); return res; } if ((res = i2c_bit_add_bus(&savage4_i2c_adapter))) { printk("i2c-savage4.o: I2C adapter registration failed\n"); } else { printk("i2c-savage4.o: I2C bus initialized\n"); savage4_initialized |= INIT2; } /* if ((res = i2c_bit_add_bus(&savage4_ddc_adapter))) { printk("i2c-savage4.o: DDC adapter registration failed\n"); } else { printk("i2c-savage4.o: DDC bus initialized\n"); savage4_initialized |= INIT3; } */ if(!(savage4_initialized & (INIT2 /* | INIT3 */ ))) { printk("i2c-savage4.o: Both registrations failed, module not inserted\n"); savage4_cleanup(); return res; } return 0; }
static int scx200_i2c_init(void) { pr_debug(NAME ": NatSemi SCx200 I2C Driver\n"); if (!scx200_gpio_present()) { ; return -ENODEV; } pr_debug(NAME ": SCL=GPIO%02u, SDA=GPIO%02u\n", scl, sda); if (scl == -1 || sda == -1 || scl == sda) { ; return -EINVAL; } /* Configure GPIOs as open collector outputs */ scx200_gpio_configure(scl, ~2, 5); scx200_gpio_configure(sda, ~2, 5); if (i2c_bit_add_bus(&scx200_i2c_ops) < 0) { // printk(KERN_ERR NAME ": adapter %s registration failed\n", ; return -ENODEV; } return 0; }
static #else extern #endif int __init i2c_via_init(void) { printk("i2c-via.o version %s (%s)\n", LM_VERSION, LM_DATE); if (find_via() < 0) { printk("i2c-via.o: Error while reading PCI configuration\n"); return -ENODEV; } if (check_region(I2C_DIR, IOSPACE) < 0) { printk("i2c-via.o: IO 0x%x-0x%x already in use\n", I2C_DIR, I2C_DIR + IOSPACE); return -EBUSY; } else { request_region(I2C_DIR, IOSPACE, IOTEXT); outb(inb(I2C_DIR) & ~(I2C_SDA | I2C_SCL), I2C_DIR); outb(inb(I2C_OUT) & ~(I2C_SDA | I2C_SCL), I2C_OUT); } if (i2c_bit_add_bus(&bit_via_ops) == 0) { printk("i2c-via.o: Module succesfully loaded\n"); return 0; } else { release_region(I2C_DIR, IOSPACE); printk ("i2c-via.o: Algo-bit error, couldn't register bus\n"); return -ENODEV; } }
static int riva_setup_i2c_bus(struct riva_i2c_chan *chan, const char *name) { int rc; strcpy(chan->adapter.name, name); chan->adapter.owner = THIS_MODULE; chan->adapter.id = I2C_ALGO_RIVA; chan->adapter.algo_data = &chan->algo; chan->adapter.dev.parent = &chan->par->pdev->dev; chan->algo.setsda = riva_gpio_setsda; chan->algo.setscl = riva_gpio_setscl; chan->algo.getsda = riva_gpio_getsda; chan->algo.getscl = riva_gpio_getscl; chan->algo.udelay = 40; chan->algo.timeout = msecs_to_jiffies(2); chan->algo.data = chan; i2c_set_adapdata(&chan->adapter, chan); /* Raise SCL and SDA */ riva_gpio_setsda(chan, 1); riva_gpio_setscl(chan, 1); udelay(20); rc = i2c_bit_add_bus(&chan->adapter); if (rc == 0) dev_dbg(&chan->par->pdev->dev, "I2C bus %s registered.\n", name); else dev_warn(&chan->par->pdev->dev, "Failed to register I2C bus %s.\n", name); return rc; }
static int i2c_versatile_probe(struct platform_device *dev) { struct i2c_versatile *i2c; struct resource *r; int ret; r = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!r) { ret = -EINVAL; goto err_out; } if (!request_mem_region(r->start, r->end - r->start + 1, "versatile-i2c")) { ret = -EBUSY; goto err_out; } i2c = kzalloc(sizeof(struct i2c_versatile), GFP_KERNEL); if (!i2c) { ret = -ENOMEM; goto err_release; } i2c->base = ioremap(r->start, r->end - r->start + 1); if (!i2c->base) { ret = -ENOMEM; goto err_free; } writel(SCL | SDA, i2c->base + I2C_CONTROLS); i2c->adap.owner = THIS_MODULE; strlcpy(i2c->adap.name, "Versatile I2C adapter", sizeof(i2c->adap.name)); i2c->adap.algo_data = &i2c->algo; i2c->adap.dev.parent = &dev->dev; i2c->algo = i2c_versatile_algo; i2c->algo.data = i2c; if (dev->id >= 0) { /* static bus numbering */ i2c->adap.nr = dev->id; ret = i2c_bit_add_numbered_bus(&i2c->adap); } else /* dynamic bus numbering */ ret = i2c_bit_add_bus(&i2c->adap); if (ret >= 0) { platform_set_drvdata(dev, i2c); return 0; } iounmap(i2c->base); err_free: kfree(i2c); err_release: release_mem_region(r->start, r->end - r->start + 1); err_out: return ret; }
int nouveau_i2c_port_create_(struct nouveau_object *parent, struct nouveau_object *engine, struct nouveau_oclass *oclass, u8 index, const struct i2c_algorithm *algo, int size, void **pobject) { struct nouveau_device *device = nv_device(parent); struct nouveau_i2c *i2c = (void *)engine; struct nouveau_i2c_port *port; int ret; ret = nouveau_object_create_(parent, engine, oclass, 0, size, pobject); port = *pobject; if (ret) return ret; snprintf(port->adapter.name, sizeof(port->adapter.name), "nouveau-%s-%d", device->name, index); port->adapter.owner = THIS_MODULE; port->adapter.dev.parent = &device->pdev->dev; port->index = index; i2c_set_adapdata(&port->adapter, i2c); if ( algo == &nouveau_i2c_bit_algo && !nouveau_boolopt(device->cfgopt, "NvI2C", CSTMSEL)) { struct i2c_algo_bit_data *bit; bit = kzalloc(sizeof(*bit), GFP_KERNEL); if (!bit) return -ENOMEM; bit->udelay = 10; bit->timeout = usecs_to_jiffies(2200); bit->data = port; bit->pre_xfer = nouveau_i2c_pre_xfer; bit->setsda = nouveau_i2c_setsda; bit->setscl = nouveau_i2c_setscl; bit->getsda = nouveau_i2c_getsda; bit->getscl = nouveau_i2c_getscl; port->adapter.algo_data = bit; ret = i2c_bit_add_bus(&port->adapter); } else { port->adapter.algo_data = port; port->adapter.algo = algo; ret = i2c_add_adapter(&port->adapter); } /* drop port's i2c subdev refcount, i2c handles this itself */ if (ret == 0) { list_add_tail(&port->head, &i2c->ports); atomic_dec(&parent->refcount); atomic_dec(&engine->refcount); } return ret; }
int nouveau_i2c_port_create_(struct nouveau_object *parent, struct nouveau_object *engine, struct nouveau_oclass *oclass, u8 index, const struct i2c_algorithm *algo, const struct nouveau_i2c_func *func, int size, void **pobject) { struct nouveau_device *device = nv_device(engine); struct nouveau_i2c *i2c = (void *)engine; struct nouveau_i2c_port *port; int ret; ret = nouveau_object_create_(parent, engine, oclass, 0, size, pobject); port = *pobject; if (ret) return ret; snprintf(port->adapter.name, sizeof(port->adapter.name), "nouveau-%s-%d", device->name, index); port->adapter.owner = THIS_MODULE; port->adapter.dev.parent = nv_device_base(device); port->index = index; port->aux = -1; port->func = func; mutex_init(&port->mutex); if ( algo == &nouveau_i2c_bit_algo && !nouveau_boolopt(device->cfgopt, "NvI2C", CSTMSEL)) { struct i2c_algo_bit_data *bit; bit = kzalloc(sizeof(*bit), GFP_KERNEL); if (!bit) return -ENOMEM; bit->udelay = 10; bit->timeout = usecs_to_jiffies(2200); bit->data = port; bit->pre_xfer = nouveau_i2c_pre_xfer; bit->post_xfer = nouveau_i2c_post_xfer; bit->setsda = nouveau_i2c_setsda; bit->setscl = nouveau_i2c_setscl; bit->getsda = nouveau_i2c_getsda; bit->getscl = nouveau_i2c_getscl; port->adapter.algo_data = bit; ret = i2c_bit_add_bus(&port->adapter); } else { port->adapter.algo_data = port; port->adapter.algo = algo; ret = i2c_add_adapter(&port->adapter); } if (ret == 0) list_add_tail(&port->head, &i2c->ports); return ret; }
static void i2c_parport_attach (struct parport *port) { struct i2c_par *adapter; adapter = kmalloc(sizeof(struct i2c_par), GFP_KERNEL); if (adapter == NULL) { printk(KERN_ERR "i2c-parport: Failed to kmalloc\n"); return; } memset(adapter, 0x00, sizeof(struct i2c_par)); pr_debug("i2c-parport: attaching to %s\n", port->name); adapter->pdev = parport_register_device(port, "i2c-parport", NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL); if (!adapter->pdev) { printk(KERN_ERR "i2c-parport: Unable to register with parport\n"); goto ERROR0; } /* Fill the rest of the structure */ adapter->adapter = parport_adapter; adapter->algo_data = parport_algo_data; if (!adapter_parm[type].getscl.val) adapter->algo_data.getscl = NULL; adapter->algo_data.data = port; adapter->adapter.algo_data = &adapter->algo_data; if (parport_claim_or_block(adapter->pdev) < 0) { printk(KERN_ERR "i2c-parport: Could not claim parallel port\n"); goto ERROR1; } /* Reset hardware to a sane state (SCL and SDA high) */ parport_setsda(port, 1); parport_setscl(port, 1); /* Other init if needed (power on...) */ if (adapter_parm[type].init.val) line_set(port, 1, &adapter_parm[type].init); parport_release(adapter->pdev); if (i2c_bit_add_bus(&adapter->adapter) < 0) { printk(KERN_ERR "i2c-parport: Unable to register with I2C\n"); goto ERROR1; } /* Add the new adapter to the list */ adapter->next = adapter_list; adapter_list = adapter; return; ERROR1: parport_unregister_device(adapter->pdev); ERROR0: kfree(adapter); }
static int i2c_bus_reg(struct i2c_bit_adapter* b, struct matrox_fb_info* minfo) { int err; b->adapter.data = minfo; b->adapter.algo_data = &b->bac; b->bac.data = minfo; err = i2c_bit_add_bus(&b->adapter); b->initialized = !err; return err; }
static int __devinit hydra_probe(struct pci_dev *dev, const struct pci_device_id *id) { unsigned int base_addr; base_addr = dev->resource[0].start; hydra_base = (unsigned long) ioremap(base_addr, 0x100); pdregw(0); /* clear SCLK_OE and SDAT_OE */ return i2c_bit_add_bus(&bit_hydra_ops); }
static int __devinit voodoo3_probe(struct pci_dev *dev, const struct pci_device_id *id) { int retval; retval = config_v3(dev); if (retval) return retval; /* set up the sysfs linkage to our parent device */ voodoo3_i2c_adapter.dev.parent = &dev->dev; voodoo3_ddc_adapter.dev.parent = &dev->dev; retval = i2c_bit_add_bus(&voodoo3_i2c_adapter); if (retval) return retval; retval = i2c_bit_add_bus(&voodoo3_ddc_adapter); if (retval) i2c_del_adapter(&voodoo3_i2c_adapter); return retval; }
static int __devinit i810_probe(struct pci_dev *dev, const struct pci_device_id *id) { int retval; retval = config_i810(dev); if (retval) return retval; dev_info(&dev->dev, "i810/i815 i2c device found.\n"); /* set up the sysfs linkage to our parent device */ i810_i2c_adapter.dev.parent = &dev->dev; i810_ddc_adapter.dev.parent = &dev->dev; retval = i2c_bit_add_bus(&i810_i2c_adapter); if (retval) return retval; retval = i2c_bit_add_bus(&i810_ddc_adapter); if (retval) i2c_bit_del_bus(&i810_i2c_adapter); return retval; }
static int __init i2c_tsunami_init(void) { printk("i2c-tsunami.o version %s (%s)\n", LM_VERSION, LM_DATE); if (hwrpb->sys_type != ST_DEC_TSUNAMI) { printk("i2c-tsunami.o: not Tsunami based system (%ld), module not inserted.\n", hwrpb->sys_type); return -ENXIO; } else { printk("i2c-tsunami.o: using Cchip MPD at 0x%lx.\n", (long) &TSUNAMI_cchip->mpd); } return i2c_bit_add_bus(&tsunami_i2c_adapter); }
static int __init i2c_ioc_init(void) { int ret; force_ones = FORCE_ONES | SCL | SDA; ret = i2c_bit_add_bus(&ioc_ops); if (ret >= 0) misc_register(&rtc_dev); return ret; }
static int __devinit savage4_probe(struct pci_dev *dev, const struct pci_device_id *id) { int retval; retval = config_s4(dev); if (retval) return retval; /* set up the sysfs linkage to our parent device */ savage4_i2c_adapter.dev.parent = &dev->dev; return i2c_bit_add_bus(&savage4_i2c_adapter); }
/* init + register i2c algo-bit adapter */ int cx88_i2c_init(struct cx88_core *core, struct pci_dev *pci) { /* Prevents usage of invalid delay values */ 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); return core->i2c_rc; }
static int ixp4xx_i2c_probe(struct device *dev) { int err; struct platform_device *plat_dev = to_platform_device(dev); struct ixp4xx_i2c_pins *gpio = plat_dev->dev.platform_data; struct ixp4xx_i2c_data *drv_data = kmalloc(sizeof(struct ixp4xx_i2c_data), GFP_KERNEL); if(!drv_data) return -ENOMEM; memzero(drv_data, sizeof(struct ixp4xx_i2c_data)); drv_data->gpio_pins = gpio; /* * We could make a lot of these structures static, but * certain platforms may have multiple GPIO-based I2C * buses for various device domains, so we need per-device * algo_data->data. */ drv_data->algo_data.data = gpio; drv_data->algo_data.setsda = ixp4xx_bit_setsda; drv_data->algo_data.setscl = ixp4xx_bit_setscl; drv_data->algo_data.getsda = ixp4xx_bit_getsda; drv_data->algo_data.getscl = ixp4xx_bit_getscl; drv_data->algo_data.udelay = 10; drv_data->algo_data.mdelay = 10; drv_data->algo_data.timeout = 100; drv_data->adapter.id = I2C_HW_B_IXP4XX, drv_data->adapter.algo_data = &drv_data->algo_data, drv_data->adapter.dev.parent = &plat_dev->dev; gpio_line_config(gpio->scl_pin, IXP4XX_GPIO_IN); gpio_line_config(gpio->sda_pin, IXP4XX_GPIO_IN); gpio_line_set(gpio->scl_pin, 0); gpio_line_set(gpio->sda_pin, 0); if ((err = i2c_bit_add_bus(&drv_data->adapter) != 0)) { printk(KERN_ERR "ERROR: Could not install %s\n", dev->bus_id); kfree(drv_data); return err; } dev_set_drvdata(&plat_dev->dev, drv_data); return 0; }
static int __devinit vt586b_probe(struct pci_dev *dev, const struct pci_device_id *id) { u16 base; u8 rev; int res; if (pm_io_base) { dev_err(&dev->dev, "i2c-via: Will only support one host\n"); return -ENODEV; } pci_read_config_byte(dev, PM_CFG_REVID, &rev); switch (rev) { case 0x00: base = PM_CFG_IOBASE0; break; case 0x01: case 0x10: base = PM_CFG_IOBASE1; break; default: base = PM_CFG_IOBASE1; /* later revision */ } pci_read_config_word(dev, base, &pm_io_base); pm_io_base &= (0xff << 8); if (!request_region(I2C_DIR, IOSPACE, vt586b_driver.name)) { dev_err(&dev->dev, "IO 0x%x-0x%x already in use\n", I2C_DIR, I2C_DIR + IOSPACE); return -ENODEV; } outb(inb(I2C_DIR) & ~(I2C_SDA | I2C_SCL), I2C_DIR); outb(inb(I2C_OUT) & ~(I2C_SDA | I2C_SCL), I2C_OUT); /* set up the sysfs linkage to our parent device */ vt586b_adapter.dev.parent = &dev->dev; res = i2c_bit_add_bus(&vt586b_adapter); if ( res < 0 ) { release_region(I2C_DIR, IOSPACE); pm_io_base = 0; return res; } return 0; }
static struct i2c_adapter * intel_gpio_create(struct drm_i915_private *dev_priv, u32 pin) { static const int map_pin_to_reg[] = { 0, GPIOB, GPIOA, GPIOC, GPIOD, GPIOE, 0, GPIOF, }; struct intel_gpio *gpio; if (pin >= ARRAY_SIZE(map_pin_to_reg) || !map_pin_to_reg[pin]) return NULL; gpio = kzalloc(sizeof(struct intel_gpio), GFP_KERNEL); if (gpio == NULL) return NULL; gpio->reg = map_pin_to_reg[pin]; if (HAS_PCH_SPLIT(dev_priv->dev)) gpio->reg += PCH_GPIOA - GPIOA; gpio->dev_priv = dev_priv; snprintf(gpio->adapter.name, sizeof(gpio->adapter.name), "i915 GPIO%c", "?BACDE?F"[pin]); gpio->adapter.owner = THIS_MODULE; gpio->adapter.algo_data = &gpio->algo; gpio->adapter.dev.parent = &dev_priv->dev->pdev->dev; gpio->algo.setsda = set_data; gpio->algo.setscl = set_clock; gpio->algo.getsda = get_data; gpio->algo.getscl = get_clock; gpio->algo.udelay = I2C_RISEFALL_TIME; gpio->algo.timeout = usecs_to_jiffies(2200); gpio->algo.data = gpio; if (i2c_bit_add_bus(&gpio->adapter)) goto out_free; return &gpio->adapter; out_free: kfree(gpio); return NULL; }