static struct wf_lm75_sensor *wf_lm75_create(struct i2c_adapter *adapter, u8 addr, int ds1775, const char *loc) { struct wf_lm75_sensor *lm; int rc; DBG("wf_lm75: creating %s device at address 0x%02x\n", ds1775 ? "ds1775" : "lm75", addr); lm = kzalloc(sizeof(struct wf_lm75_sensor), GFP_KERNEL); if (lm == NULL) return NULL; /* Usual rant about sensor names not beeing very consistent in * the device-tree, oh well ... * Add more entries below as you deal with more setups */ if (!strcmp(loc, "Hard drive") || !strcmp(loc, "DRIVE BAY")) lm->sens.name = "hd-temp"; else if (!strcmp(loc, "Incoming Air Temp")) lm->sens.name = "incoming-air-temp"; else if (!strcmp(loc, "ODD Temp")) lm->sens.name = "optical-drive-temp"; else if (!strcmp(loc, "HD Temp")) lm->sens.name = "hard-drive-temp"; else goto fail; lm->inited = 0; lm->sens.ops = &wf_lm75_ops; lm->ds1775 = ds1775; lm->i2c.addr = (addr >> 1) & 0x7f; lm->i2c.adapter = adapter; lm->i2c.driver = &wf_lm75_driver; strncpy(lm->i2c.name, lm->sens.name, I2C_NAME_SIZE-1); rc = i2c_attach_client(&lm->i2c); if (rc) { printk(KERN_ERR "windfarm: failed to attach %s %s to i2c," " err %d\n", ds1775 ? "ds1775" : "lm75", lm->i2c.name, rc); goto fail; } if (wf_register_sensor(&lm->sens)) { i2c_detach_client(&lm->i2c); goto fail; } return lm; fail: kfree(lm); return NULL; }
/* If the i2c layer weren't so broken, we could pass this kind of data around */ static int ak4671_codec_probe(struct i2c_adapter *adap, int addr, int kind) { struct snd_soc_device *socdev = ak4671_socdev; struct ak4671_setup_data *setup = socdev->codec_data; struct snd_soc_codec *codec = socdev->codec; struct i2c_client *i2c; int ret; if (addr != setup->i2c_address) return -ENODEV; ak4671_client.adapter = adap; ak4671_client.addr = addr; i2c = kmemdup(&ak4671_client, sizeof(ak4671_client), GFP_KERNEL); if (i2c == NULL) return -ENOMEM; i2c_set_clientdata(i2c, codec); codec->control_data = i2c; ret = i2c_attach_client(i2c); if (ret < 0) { printk(KERN_ERR "failed to attach codec at addr %x\n", addr); goto err; } ret = ak4671_init(socdev); if (ret < 0) { printk(KERN_ERR "failed to initialise AK4671\n"); goto err; } set_registers(codec, MM_AUDIO_PLAYBACK_SPK); #if 0 // i2c test p("---> 0x01 = 0x%02x\n", ak4671_read(codec, 0x01)); ak4671_write(codec, 0x01, 0x78); P("---> 0x01 = 0x%02x\n", ak4671_read(codec, 0x01)); P("---> 0x02 = 0x%02x\n", ak4671_read(codec, 0x02)); ak4671_write(codec, 0x02, 0x01); P("---> 0x02 = 0x%02x\n", ak4671_read(codec, 0x02)); P("---> 0x03 = 0x%02x\n", ak4671_read(codec, 0x03)); ak4671_write(codec, 0x03, 0x03); P("---> 0x03 = 0x%02x\n", ak4671_read(codec, 0x03)); #endif return ret; err: kfree(i2c); return ret; }
static int tda9840_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *client; int result = 0; int byte = 0x0; /* let's see whether this adapter can support what we need */ if ( 0 == i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA|I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) { return 0; } /* allocate memory for client structure */ client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (0 == client) { printk("tda9840.o: not enough kernel memory.\n"); return -ENOMEM; } memset(client, 0, sizeof(struct i2c_client)); /* fill client structure */ sprintf(client->name,"tda9840 (0x%02x)", address); client->id = tda9840_id++; client->flags = 0; client->addr = address; client->adapter = adapter; client->driver = &driver; i2c_set_clientdata(client, NULL); /* tell the i2c layer a new client has arrived */ if (0 != (result = i2c_attach_client(client))) { kfree(client); return result; } /* set initial values for level & stereo - adjustment, mode */ byte = 0; if ( 0 != (result = tda9840_command(client, TDA9840_LEVEL_ADJUST, &byte))) { printk("tda9840.o: could not initialize ic #1. continuing anyway. (result:%d)\n",result); } if ( 0 != (result = tda9840_command(client, TDA9840_STEREO_ADJUST, &byte))) { printk("tda9840.o: could not initialize ic #2. continuing anyway. (result:%d)\n",result); } byte = TDA9840_SET_MONO; if ( 0 != (result = tda9840_command(client, TDA9840_SWITCH, &byte))) { printk("tda9840.o: could not initialize ic #3. continuing anyway. (result:%d)\n",result); } printk("tda9840.o: detected @ 0x%02x on adapter %s\n",2*address,&client->adapter->name[0]); return 0; }
static int tvp5150_detect_client(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *c; struct tvp5150 *core; int rv; if (debug) printk( KERN_INFO "tvp5150.c: detecting tvp5150 client on address 0x%x\n", address << 1); client_template.adapter = adapter; client_template.addr = address; /* Check if the adapter supports the needed features */ if (!i2c_check_functionality (adapter, I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) return 0; c = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (!c) return -ENOMEM; memcpy(c, &client_template, sizeof(struct i2c_client)); core = kzalloc(sizeof(struct tvp5150), GFP_KERNEL); if (!core) { kfree(c); return -ENOMEM; } i2c_set_clientdata(c, core); rv = i2c_attach_client(c); core->norm = V4L2_STD_ALL; /* Default is autodetect */ core->route.input = TVP5150_COMPOSITE1; core->enable = 1; core->bright = 128; core->contrast = 128; core->hue = 0; core->sat = 128; if (rv) { kfree(c); kfree(core); return rv; } if (debug > 1) dump_reg(c); return 0; }
static int uor_i2c_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *client; // printk("uor.c:uor_i2c_detect() --oql\n"); client = kzalloc(sizeof(*client), GFP_KERNEL); if (client == NULL) { printk("uor.c:uor_i2c_detect() client ==null--oql\n"); return -ENOMEM; } client->adapter = adapter; client->addr = address; client->driver = &uor_i2c_driver; client->Channel = I2C_CH0; client->mode = NORMALMODE; client->speed = 100;// 80;// 400; client->addressBit = I2C_7BIT_ADDRESS_8BIT_REG; i2c_set_clientdata(client, &ts); ts.client = client; // save the client we get i2c_attach_client(client); if(Init_UOR_HW() < 0) printk(KERN_ERR "uor.c: Init_UOR_HW() fail in uor_init()!\n"); return 0; }
static int isp1301_detect_client(struct i2c_adapter *adapter, int address, int kind) { isp1301_i2c_client.adapter = adapter; if (i2c_attach_client(&isp1301_i2c_client)) { isp1301_i2c_client.adapter = NULL; printk(KERN_ERR "isp1301_attach: i2c_attach_client failed\n"); return -1; } printk(KERN_INFO "isp1301 Detected\n"); return 0; }
static int ds1374_probe(struct i2c_adapter *adapter, int address, int kind) { struct ds1374 *ds1374; struct i2c_client *client; int ret; ds1374 = kzalloc(sizeof(struct ds1374), GFP_KERNEL); if (!ds1374) return -ENOMEM; client = &ds1374->client; client->addr = address; client->adapter = adapter; client->driver = &ds1374_driver; client->flags = 0; strlcpy(client->name, "ds1374", I2C_NAME_SIZE); i2c_set_clientdata(client, ds1374); mutex_init(&ds1374->mutex); ret = i2c_attach_client(client); if (ret) goto attach_failed; ret = ds1374_check_rtc_status(client); if (ret) goto status_failed; ds1374->rtc = rtc_device_register(client->name, &client->dev, &ds1374_rtc_ops, THIS_MODULE); if (IS_ERR(ds1374->rtc)) { ret = PTR_ERR(ds1374->rtc); dev_err(&client->dev, "unable to register the class device\n"); goto rtc_register_failed; } return 0; rtc_register_failed: status_failed: i2c_detach_client(client); attach_failed: i2c_set_clientdata(client, NULL); kfree(ds1374); printk(KERN_ERR "ds1374: failed to probe\n"); return ret; }
static int at24cxx_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *new_client; printk("at24cxx_detect\n"); /* 构构一个i2c_client结构体: 以后收改数据时会用到它 */ new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); new_client->addr = address; new_client->adapter = adapter; new_client->driver = &at24cxx_driver; strcpy(new_client->name, "at24cxx"); i2c_attach_client(new_client); return 0; }
static int wis_saa7115_detect(struct i2c_adapter *adapter, int addr, int kind) { struct i2c_client *client; struct wis_saa7115 *dec; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return 0; client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (client == NULL) return -ENOMEM; memcpy(client, &wis_saa7115_client_templ, sizeof(wis_saa7115_client_templ)); client->adapter = adapter; client->addr = addr; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) client->id = wis_saa7115_i2c_id++; #endif dec = kmalloc(sizeof(struct wis_saa7115), GFP_KERNEL); if (dec == NULL) { kfree(client); return -ENOMEM; } dec->norm = VIDEO_MODE_NTSC; dec->brightness = 128; dec->contrast = 64; dec->saturation = 64; dec->hue = 0; i2c_set_clientdata(client, dec); printk(KERN_DEBUG "wis-saa7115: initializing SAA7115 at address %d on %s\n", addr, adapter->name); if (write_regs(client, initial_registers) < 0) { printk(KERN_ERR "wis-saa7115: error initializing SAA7115\n"); kfree(client); kfree(dec); return 0; } i2c_attach_client(client); return 0; }
/* This function is called by i2c_detect */ static int pca9539_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *new_client; struct pca9539_data *data; int err = 0; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) goto exit; /* OK. For now, we presume we have a valid client. We now create the client structure, even though we cannot fill it completely yet. */ if (!(data = kmalloc(sizeof(struct pca9539_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct pca9539_data)); new_client = &data->client; i2c_set_clientdata(new_client, data); new_client->addr = address; new_client->adapter = adapter; new_client->driver = &pca9539_driver; new_client->flags = 0; /* Detection: the pca9539 only has 8 registers (0-7). A read of 7 should succeed, but a read of 8 should fail. */ if ((i2c_smbus_read_byte_data(new_client, 7) < 0) || (i2c_smbus_read_byte_data(new_client, 8) >= 0)) goto exit_kfree; strlcpy(new_client->name, "pca9539", I2C_NAME_SIZE); /* Tell the I2C layer a new client has arrived */ if ((err = i2c_attach_client(new_client))) goto exit_kfree; /* Register sysfs hooks (don't care about failure) */ sysfs_create_group(&new_client->dev.kobj, &pca9539_defattr_group); return 0; exit_kfree: kfree(data); exit: return err; }
static int si4709_i2c_probe(struct i2c_adapter *adapter, int address, int kind) { int err = 0; printk("----- %s %d\n", __func__, __LINE__); Si4709_i2c_client.addr = address; Si4709_i2c_client.adapter = adapter; Si4709_i2c_client.driver = &Si4709_i2c_driver; if ((err = i2c_attach_client(&Si4709_i2c_client))) return err; Si4709_probe(&Si4709_i2c_client); return 0; }
static int irrtc_detect_client(struct i2c_adapter * adapter, int address, int kind) { int ret = 0; struct i2c_client* client = NULL; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE)) { dbg("ERROR returned from i2c_check_functionality"); ret = -1; goto out; } if (!(client = kmalloc(sizeof(*client), GFP_KERNEL))) { dbg("ERROR error returned from kmalloc"); ret = -ENOMEM; goto out; } memset(client, 0, sizeof(struct i2c_client)); client->addr = address; client->adapter = adapter; client->driver = &irrtc_driver; client->flags = I2C_M_IGNORE_NAK; strcpy(client->name, "irrtc"); if ((ret = i2c_attach_client(client)) != 0) { dbg("%s Unable to attach client.\n", pname); kfree(client); ret = -1; goto out; } irrtc_client = client; #if 0 printk("Reading remote ID\n"); printk("Register:Value 0x%02X:0x%02X\n", 0x36, i2c_read(0x36)); #endif out: return ret; }
/* tvp7002_i2c_attach_client : This function is used to attach i2c client */ static int tvp7002_i2c_attach_client(struct i2c_client *client, struct i2c_driver *driver, struct i2c_adapter *adap, int addr) { int err = 0; if (client->adapter) { err = -EBUSY; /* our client is already attached */ } else { client->addr = addr; client->driver = driver; client->adapter = adap; err = i2c_attach_client(client); if (err) { client->adapter = NULL; } } return err; }
/* this function is called by i2c_probe */ static int tea6420_detect(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *client; int err = 0, i = 0; /* let's see whether this adapter can support what we need */ if (0 == i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE)) { return 0; } /* allocate memory for client structure */ client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (0 == client) { return -ENOMEM; } memset(client, 0x0, sizeof(struct i2c_client)); /* fill client structure */ memcpy(client, &client_template, sizeof(struct i2c_client)); client->addr = address; client->adapter = adapter; /* tell the i2c layer a new client has arrived */ if (0 != (err = i2c_attach_client(client))) { kfree(client); return err; } /* set initial values: set "mute"-input to all outputs at gain 0 */ err = 0; for (i = 1; i < 5; i++) { err += tea6420_switch(client, 6, i, 0); } if (err) { dprintk("could not initialize tea6420\n"); kfree(client); return -ENODEV; } printk("tea6420: detected @ 0x%02x on adapter %s\n", address, &client->adapter->name[0]); return 0; }
static int isp1301_attach(struct i2c_adapter *adap, int addr, int kind) { struct i2c_client *c; c = (struct i2c_client *)kzalloc(sizeof(*c), GFP_KERNEL); if (!c) return -ENOMEM; strcpy(c->name, "isp1301"); c->flags = 0; c->addr = addr; c->adapter = adap; c->driver = &isp1301_driver; isp1301_i2c_client = c; return i2c_attach_client(c); }
static int at24cxx_detect(struct i2c_adapter *adapter, int address, int kind) { printk("at24cxx_detect\n"); /* 构构一个i2c_client结构体: 以后收改数据时会用到它 */ at24cxx_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); at24cxx_client->addr = address; at24cxx_client->adapter = adapter; at24cxx_client->driver = &at24cxx_driver; strcpy(at24cxx_client->name, "at24cxx"); i2c_attach_client(at24cxx_client); major = register_chrdev(0, "at24cxx", &at24cxx_fops); cls = class_create(THIS_MODULE, "at24cxx"); class_device_create(cls, NULL, MKDEV(major, 0), NULL, "at24cxx"); /* /dev/at24cxx */ return 0; }
static int opt_attach(struct i2c_adapter *adap, int addr, int kind) { struct i2c_client *c; int ret,err=0; gprintk("\n"); if ( !i2c_check_functionality(adap,I2C_FUNC_SMBUS_BYTE_DATA) ) { printk(KERN_INFO "byte op is not permited.\n"); return err; } c = kzalloc(sizeof(struct i2c_client),GFP_KERNEL); if (!c) { printk("kzalloc error \n"); return -ENOMEM; } memset(c, 0, sizeof(struct i2c_client)); strncpy(c->name,"gp2a",I2C_NAME_SIZE); c->addr = addr; c->adapter = adap; c->driver = &opt_i2c_driver; c->flags = I2C_DF_NOTIFY | I2C_M_IGNORE_NAK; if ((ret = i2c_attach_client(c)) < 0) { printk("i2c_attach_client error\n"); goto error; } opt_i2c_client = c; gprintk("\n"); return ret; error: printk("in %s , ret = %d \n",__func__,ret); kfree(c); return err; }
static int i2c_acc_kr3dm_probe_client(struct i2c_adapter *adapter, int address, int kind) { struct i2c_client *new_client; int err = 0; if ( !i2c_check_functionality(adapter,I2C_FUNC_SMBUS_BYTE_DATA) ) { printk(KERN_INFO "byte op is not permited.\n"); goto ERROR0; } new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL ); if ( !new_client ) { err = -ENOMEM; goto ERROR0; } new_client->addr = address; new_client->adapter = adapter; new_client->driver = &acc_kr3dm_i2c_driver; new_client->flags = I2C_DF_NOTIFY | I2C_M_IGNORE_NAK; g_client = new_client; strlcpy(new_client->name, "kr3dm", I2C_NAME_SIZE); if ((err = i2c_attach_client(new_client))) goto ERROR1; #ifdef DEBUG printk("i2c_acc_kr3dm_probe_client() completed!!!!!!!!!!!!!!!!!!\n"); #endif return 0; ERROR1: printk("i2c_acc_kr3dm_probe_client() ERROR1\n"); kfree(new_client); ERROR0: printk("i2c_acc_kr3dm_probe_client() ERROR0\n"); return err; }
static int ak4183_i2c_probe(struct i2c_adapter *bus, int address, int kind) { int ret; D("enter!\n"); ak4183_i2c_client.adapter = bus; ak4183_i2c_client.addr= AK4183_I2C_ADDR >> 1; ak4183_i2c_client.mode = NORMALMODE; ak4183_i2c_client.Channel = I2C_CH1; ak4183_i2c_client.addressBit = I2C_7BIT_ADDRESS_8BIT_REG; ak4183_i2c_client.speed = 60; ret = i2c_attach_client(&ak4183_i2c_client); if (ret < 0){ E("i2c_attach_client err!\n"); } return ret; }
static int ov3640_attach(struct i2c_adapter *adap, int addr, int kind) { struct i2c_client *c; c = kmalloc(sizeof(*c), GFP_KERNEL); if (!c) return -ENOMEM; memset(c, 0, sizeof(struct i2c_client)); strcpy(c->name, "ov3640"); c->addr = addr; c->adapter = adap; c->driver = &ov3640_i2c_driver; ov3640_data.client = c; printk("ov3640 attached successfully\n"); return i2c_attach_client(c); }
//------------------------------- tda9887_attach ------------------------------- static int tda9887_attach(struct i2c_adapter *adap, int addr, unsigned short flags, int kind) { struct tda9887 *t; client_template.adapter = adap; client_template.addr = addr; CPK(printk("tda9887: chip found @ 0x%x\n", addr<<1)); if (NULL == (t = (struct tda9887*)kmalloc(sizeof(*t), GFP_KERNEL))) return -ENOMEM; memset(t,0,sizeof(*t)); t->client = client_template; t->pinnacle_id = -1; t->tvnorm=VIDEO_MODE_PAL; i2c_set_clientdata(&t->client,t); #ifdef TARGET_OS2 rmDeviceStruct.DevDescriptName=(PSZ)"TDA9887"; #endif i2c_attach_client(&t->client); MOD_INC_USE_COUNT; return 0; }
static int s5k3ba_attach(struct i2c_adapter *adap, int addr, int kind) { struct i2c_client *c; c = kmalloc(sizeof(*c), GFP_KERNEL); if (!c) return -ENOMEM; memset(c, 0, sizeof(struct i2c_client)); strcpy(c->name, "s5k3ba"); c->addr = addr; c->adapter = adap; c->driver = &s5k3ba_i2c_driver; s5k3ba_data.client = c; info("s5k3ba attached successfully\n"); return i2c_attach_client(c); }
/*! * @brief Handles the addition of an I2C adapter capable of supporting the KeyV Chip * * This function is called by the I2C driver when an adapter has been added to the * system that can support communications with the KeyV Chip. The function will * attempt to register a I2C client structure with the adapter so that communication * can start. If the client is successfully registered, the KeyV initialization * function will be called to do any register writes required at power-up. * * @param adap A pointer to I2C adapter * * @return This function returns 0 if successful */ static int adapter_attach (struct i2c_adapter *adap) { int retval; /* Allocate memory for client structure */ keyv_i2c_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); memset(keyv_i2c_client, 0, (sizeof(struct i2c_client))); if(keyv_i2c_client == NULL) { return -ENOMEM; } /* Fill in the required fields */ keyv_i2c_client->adapter = adap; keyv_i2c_client->addr = KEYV_ADDR; keyv_i2c_client->driver = &driver; /* Register our client */ retval = i2c_attach_client(keyv_i2c_client); if(retval != 0) { /* Request failed, free the memory that we allocated */ kfree(keyv_i2c_client); keyv_i2c_client = NULL; } /* else we are registered */ else { /* Initialize KeyV registers now */ if(keyv_reg_init != NULL) { (*keyv_reg_init)(); } } return retval; }
static int conf_attach(struct i2c_adapter *adap, int addr, unsigned short flags,int kind) { struct i2c_client *c; c = (struct i2c_client *)kmalloc(sizeof(*c), GFP_KERNEL); if (!c) return -ENOMEM; memset (c, 0, sizeof(*c)); strcpy(c->name, conf_driver.name); c->id = conf_driver.id; c->flags = 0; c->addr = addr; c->adapter = adap; c->driver = &conf_driver; c->data = NULL; conf_client = c; return i2c_attach_client(c); }
static int s5k4xa_attach(struct i2c_adapter *adap, int addr, int kind) { struct i2c_client *c; c = kmalloc(sizeof(*c), GFP_KERNEL); if (!c) return -ENOMEM; memset(c, 0, sizeof(struct i2c_client)); strcpy(c->name, "S5K4XA"); c->addr = addr; c->adapter = adap; c->driver = &sensor_driver; c->data = &data; data.sensor = c; s3c_camif_register_sensor(c); return i2c_attach_client(c); }
/******************************************************************************* ** Driver Functions *******************************************************************************/ static int eeprom_attach( struct i2c_adapter *adap, int addr, int unused ) { DBG("Attaching client.\n" ) ; eeprom_client = kmalloc( sizeof( *eeprom_client), GFP_KERNEL ); if( !eeprom_client ){ return -ENOMEM; } strcpy( eeprom_client->name, "AT24Cx" ); eeprom_client->id = eeprom_driver.id; eeprom_client->flags = 0; eeprom_client->addr = addr; eeprom_client->adapter = adap; eeprom_client->driver = &eeprom_driver; #if 0 eeprom_client->data = NULL; #endif return i2c_attach_client( eeprom_client ); }
static int tda9887_attach(struct i2c_adapter *adap, int addr, unsigned short flags, int kind) { struct tda9887 *t; client_template.adapter = adap; client_template.addr = addr; printk("tda9887: chip found @ 0x%x\n", addr<<1); if (NULL == (t = kmalloc(sizeof(*t), GFP_KERNEL))) return -ENOMEM; memset(t,0,sizeof(*t)); t->client = client_template; t->pinnacle_id = -1; t->tvnorm=VIDEO_MODE_PAL; i2c_set_clientdata(&t->client, t); i2c_attach_client(&t->client); MOD_INC_USE_COUNT; return 0; }
static int keywest_attach_adapter(struct i2c_adapter *adapter) { int err; struct i2c_client *new_client; if (! keywest_ctx) return -EINVAL; if (strncmp(i2c_device_name(adapter), "mac-io", 6)) return 0; /* ignored */ new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); if (! new_client) return -ENOMEM; new_client->addr = keywest_ctx->addr; i2c_set_clientdata(new_client, keywest_ctx); new_client->adapter = adapter; new_client->driver = &keywest_driver; new_client->flags = 0; strcpy(i2c_device_name(new_client), keywest_ctx->name); keywest_ctx->client = new_client; /* Tell the i2c layer a new client has arrived */ if (i2c_attach_client(new_client)) { snd_printk(KERN_ERR "tumbler: cannot attach i2c client\n"); err = -ENODEV; goto __err; } return 0; __err: kfree(new_client); keywest_ctx->client = NULL; return err; }
static int tas_detect_client(struct i2c_adapter *adapter, int address) { static const char *client_name = "tas Digital Equalizer"; struct i2c_client *new_client; int rc = -ENODEV; if (!driver_hooks) { printk(KERN_ERR "tas_detect_client called with no hooks !\n"); return -ENODEV; } new_client = kmalloc(sizeof(*new_client), GFP_KERNEL); if (!new_client) return -ENOMEM; memset(new_client, 0, sizeof(*new_client)); new_client->addr = address; new_client->adapter = adapter; new_client->driver = &tas_driver; strlcpy(new_client->name, client_name, DEVICE_NAME_SIZE); if (driver_hooks->init(new_client)) goto bail; /* Tell the i2c layer a new client has arrived */ if (i2c_attach_client(new_client)) { driver_hooks->uninit(dev_get_drvdata(&new_client->dev)); goto bail; } tas_client = new_client; return 0; bail: tas_client = NULL; kfree(new_client); return rc; }
static int wis_tw2804_detect(struct i2c_adapter *adapter, int addr, int kind) { struct i2c_client *client; struct wis_tw2804 *dec; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return 0; client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL); if (client == NULL) return -ENOMEM; memcpy(client, &wis_tw2804_client_templ, sizeof(wis_tw2804_client_templ)); client->adapter = adapter; client->addr = addr; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) client->id = wis_tw2804_i2c_id++; #endif dec = kmalloc(sizeof(struct wis_tw2804), GFP_KERNEL); if (dec == NULL) { kfree(client); return -ENOMEM; } dec->channel = -1; dec->norm = VIDEO_MODE_NTSC; dec->brightness = 128; dec->contrast = 128; dec->saturation = 128; dec->hue = 128; i2c_set_clientdata(client, dec); printk(KERN_DEBUG "wis-tw2804: creating TW2804 at address %d on %s\n", addr, adapter->name); i2c_attach_client(client); return 0; }