本文整理汇总了C++中i2c_smbus_read_word_data函数的典型用法代码示例。如果您正苦于以下问题:C++ i2c_smbus_read_word_data函数的具体用法?C++ i2c_smbus_read_word_data怎么用?C++ i2c_smbus_read_word_data使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了i2c_smbus_read_word_data函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: raspberrypiI2CReadReg16
static int raspberrypiI2CReadReg16(int fd, int reg) {
return i2c_smbus_read_word_data(fd, reg);
}
示例2: read_r8d16
static int read_r8d16(void *client, u8 reg)
{
return i2c_smbus_read_word_data(client, reg);
}
示例3: fsa9485_detect_dev
static int fsa9485_detect_dev(struct fsa9485_usbsw *usbsw)
{
int device_type, ret;
unsigned int dev1, dev2, dev3, adc;
struct fsa9485_platform_data *pdata = usbsw->pdata;
struct i2c_client *client = usbsw->client;
#if defined(CONFIG_VIDEO_MHL_V1) || defined(CONFIG_VIDEO_MHL_V2)
// u8 mhl_ret = 0;
#endif
pr_info("%s", __func__);
device_type = i2c_smbus_read_word_data(client, FSA9485_REG_DEV_T1);
if (device_type < 0) {
dev_err(&client->dev, "%s: err %d\n", __func__, device_type);
return device_type;
}
dev1 = device_type & 0xff;
dev2 = device_type >> 8;
jig_state = (dev2 & DEV_T2_JIG_MASK) ? 1 : 0;
adc = i2c_smbus_read_byte_data(client, FSA9485_REG_ADC);
/* remove for right perform for lanhub / defence code for factory */
#if 0
if (usbsw->dock_attached && usbsw->previous_dock == FSA9485_NONE)
pdata->dock_cb(FSA9485_DETACHED_DOCK);
#endif
if (local_usbsw->dock_ready == 1) {
if (adc == 0x0f)
dev2 = DEV_INCOMPATIBLE;
else if (adc == 0x10)
dev2 = DEV_SMARTDOCK;
else if (adc == 0x12)
dev2 = DEV_AUDIO_DOCK;
#ifdef CONFIG_MUIC_FSA9485_SUPPORT_LANHUB
else if (adc == 0x13)
dev2 = DEV_LANHUB;
#endif
else if (adc == 0x14)
dev2 = DEV_CHARGING_CABLE;
else if (adc == 0x15){
dev2 = DEV_MMDOCK;
ret = i2c_smbus_read_byte_data(client,FSA9485_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client, FSA9485_REG_CTRL, ret & ~CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
mmdock_connect = 1;
}
}
dev3 = i2c_smbus_read_byte_data(client,
FSA9485_REG_RESERVED_1D);
if(dev3 < 0) {
dev_err(&client->dev, "%s: err %d\n", __func__, dev3);
return dev3;
}
dev3 = dev3 & 0x02;
dev_info(&client->dev, "dev1: 0x%02x, dev2: 0x%02x,dev3: 0x%02x, adc: 0x%02x\n",
dev1, dev2, dev3, adc);
/* Attached */
if (dev1 || dev2) {
/* USB */
if (dev1 & DEV_USB || dev2 & DEV_T2_USB_MASK) {
dev_info(&client->dev, "usb connect\n");
if (pdata->usb_cb)
pdata->usb_cb(FSA9485_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9485_REG_MANSW1, usbsw->mansw);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* USB_CDP */
} else if (dev1 & DEV_USB_CHG) {
dev_info(&client->dev, "usb_cdp connect\n");
if (pdata->usb_cdp_cb)
pdata->usb_cdp_cb(FSA9485_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9485_REG_MANSW1, usbsw->mansw);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* UART */
} else if (dev1 & DEV_T1_UART_MASK || dev2 & DEV_T2_UART_MASK) {
uart_connecting = 1;
dev_info(&client->dev, "uart connect\n");
i2c_smbus_write_byte_data(client,
//.........这里部分代码省略.........
示例4: tmp102_read_reg
/* SMBus specifies low byte first, but the TMP102 returns high byte first,
* so we have to swab16 the values */
static inline int tmp102_read_reg(struct i2c_client *client, u8 reg)
{
int result = i2c_smbus_read_word_data(client, reg);
return result < 0 ? result : swab16(result);
}
示例5: fsa9480_detect_dev
static void fsa9480_detect_dev(struct fsa9480_usbsw *usbsw)
{
int device_type, ret;
unsigned char val1, val2;
struct fsa9480_platform_data *pdata = usbsw->pdata;
struct i2c_client *client = usbsw->client;
device_type = i2c_smbus_read_word_data(client, FSA9480_REG_DEV_T1);
if (device_type < 0)
dev_err(&client->dev, "%s: err %d\n", __func__, device_type);
val1 = device_type & 0xff;
val2 = device_type >> 8;
dev_info(&client->dev, "dev1: 0x%x, dev2: 0x%x\n", val1, val2);
/* Attached */
if (val1 || val2) {
/* USB */
if (val1 & DEV_T1_USB_MASK || val2 & DEV_T2_USB_MASK) {
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, usbsw->mansw);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* UART */
} else if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_ATTACHED);
if (usbsw->mansw) {
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_UART);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
}
/* CHARGER */
} else if (val1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_ATTACHED);
/* JIG */
} else if (val2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_ATTACHED);
/* Desk Dock */
} else if (val2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_ATTACHED);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_MANSW1, SW_DHOST);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_read_byte_data(client,
FSA9480_REG_CTRL);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
ret = i2c_smbus_write_byte_data(client,
FSA9480_REG_CTRL, ret & ~CON_MANUAL_SW);
if (ret < 0)
dev_err(&client->dev,
"%s: err %d\n", __func__, ret);
/* Car Dock */
} else if (val2 & DEV_JIG_UART_ON) {
if (pdata->cardock_cb)
pdata->cardock_cb(FSA9480_ATTACHED);
}
/* Detached */
} else {
/* USB */
if (usbsw->dev1 & DEV_T1_USB_MASK ||
usbsw->dev2 & DEV_T2_USB_MASK) {
if (pdata->usb_cb)
pdata->usb_cb(FSA9480_DETACHED);
/* UART */
} else if (usbsw->dev1 & DEV_T1_UART_MASK ||
usbsw->dev2 & DEV_T2_UART_MASK) {
if (pdata->uart_cb)
pdata->uart_cb(FSA9480_DETACHED);
/* CHARGER */
} else if (usbsw->dev1 & DEV_T1_CHARGER_MASK) {
if (pdata->charger_cb)
pdata->charger_cb(FSA9480_DETACHED);
/* JIG */
} else if (usbsw->dev2 & DEV_T2_JIG_MASK) {
if (pdata->jig_cb)
pdata->jig_cb(FSA9480_DETACHED);
/* Desk Dock */
} else if (usbsw->dev2 & DEV_AV) {
if (pdata->deskdock_cb)
pdata->deskdock_cb(FSA9480_DETACHED);
//.........这里部分代码省略.........
示例6: main
//.........这里部分代码省略.........
}
if (maskp) {
vmask = strtol(maskp, &end, 0);
if (*end || vmask == 0) {
fprintf(stderr, "Error: Data value mask invalid!\n");
help();
}
if (((size == I2C_SMBUS_BYTE || size == I2C_SMBUS_BYTE_DATA)
&& vmask > 0xff) || vmask > 0xffff) {
fprintf(stderr, "Error: Data value mask out of range!\n");
help();
}
}
file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);
if (file < 0
|| check_funcs(file, size, pec)
|| set_slave_addr(file, address, force))
exit(1);
if (!yes && !confirm(filename, address, size, daddress,
value, vmask, block, len, pec))
exit(0);
if (vmask) {
int oldvalue;
switch (size) {
case I2C_SMBUS_BYTE:
oldvalue = i2c_smbus_read_byte(file);
break;
case I2C_SMBUS_WORD_DATA:
oldvalue = i2c_smbus_read_word_data(file, daddress);
break;
default:
oldvalue = i2c_smbus_read_byte_data(file, daddress);
}
if (oldvalue < 0) {
fprintf(stderr, "Error: Failed to read old value\n");
exit(1);
}
value = (value & vmask) | (oldvalue & ~vmask);
if (!yes) {
fprintf(stderr, "Old value 0x%0*x, write mask "
"0x%0*x: Will write 0x%0*x to register "
"0x%02x\n",
size == I2C_SMBUS_WORD_DATA ? 4 : 2, oldvalue,
size == I2C_SMBUS_WORD_DATA ? 4 : 2, vmask,
size == I2C_SMBUS_WORD_DATA ? 4 : 2, value,
daddress);
fprintf(stderr, "Continue? [Y/n] ");
fflush(stderr);
if (!user_ack(1)) {
fprintf(stderr, "Aborting on user request.\n");
exit(0);
}
}
}
if (pec && ioctl(file, I2C_PEC, 1) < 0) {
fprintf(stderr, "Error: Could not set PEC: %s\n",
示例7: main
int main() {
int file;
int adapter_nr = 1; /* probably dynamically determined */
char filename[20];
int addr = 0x69;
snprintf(filename, 19, "/dev/i2c-%d", adapter_nr);
file = open(filename, O_RDWR);
if (file < 0) {
/* ERROR HANDLING; you can check errno to see what went wrong */
printf("Failed to open the bus.\n");
exit(1);
}
unsigned long funcs;
if (ioctl(file, I2C_FUNCS, &funcs) < 0) {
printf("Failed to get funcs.\n");
}else{
printf("Funcs: %x\n", funcs);
}
if (ioctl(file,I2C_SLAVE, addr) < 0) {
printf("Failed to acquire bus access and/or talk to slave.\n");
exit(1);
}
char c;
int reg, value, res;
do {
scanf("%c", &c);
if (c != 'e') {
printf("Reg: ");
scanf("%d", ®);
}
switch (c) {
case 'w':
printf("Val: ");
scanf("%d", &value);
if (i2c_smbus_write_byte_data(file, reg, value) < 0)
printf("Error!\n");
break;
case 'W':
printf("Val: ");
scanf("%d", &value);
if (i2c_smbus_write_word_data(file, reg, value) < 0)
printf("Error!\n");
break;
case 'r':
res = i2c_smbus_read_byte_data(file, reg);
if (res < 0) {
printf("Error!\n");
}else{
printf("Res: %x\n", res);
}
break;
case 'R':
res = i2c_smbus_read_word_data(file, reg);
if (res < 0) {
printf("Error!\n");
}else{
printf("Res: %x\n", res);
}
break;
}
}while(c != 'e');
}
示例8: acpi_i2c_space_handler
static acpi_status
acpi_i2c_space_handler(u32 function, acpi_physical_address command,
u32 bits, u64 *value64,
void *handler_context, void *region_context)
{
struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
struct acpi_i2c_handler_data *data = handler_context;
struct acpi_connection_info *info = &data->info;
struct acpi_resource_i2c_serialbus *sb;
struct i2c_adapter *adapter = data->adapter;
struct i2c_client client;
struct acpi_resource *ares;
u32 accessor_type = function >> 16;
u8 action = function & ACPI_IO_MASK;
acpi_status ret = AE_OK;
int status;
ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
if (ACPI_FAILURE(ret))
return ret;
if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
ret = AE_BAD_PARAMETER;
goto err;
}
sb = &ares->data.i2c_serial_bus;
if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
ret = AE_BAD_PARAMETER;
goto err;
}
memset(&client, 0, sizeof(client));
client.adapter = adapter;
client.addr = sb->slave_address;
client.flags = 0;
if (sb->access_mode == ACPI_I2C_10BIT_MODE)
client.flags |= I2C_CLIENT_TEN;
switch (accessor_type) {
case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
if (action == ACPI_READ) {
status = i2c_smbus_read_byte(&client);
if (status >= 0) {
gsb->bdata = status;
status = 0;
}
} else {
status = i2c_smbus_write_byte(&client, gsb->bdata);
}
break;
case ACPI_GSB_ACCESS_ATTRIB_BYTE:
if (action == ACPI_READ) {
status = i2c_smbus_read_byte_data(&client, command);
if (status >= 0) {
gsb->bdata = status;
status = 0;
}
} else {
status = i2c_smbus_write_byte_data(&client, command,
gsb->bdata);
}
break;
case ACPI_GSB_ACCESS_ATTRIB_WORD:
if (action == ACPI_READ) {
status = i2c_smbus_read_word_data(&client, command);
if (status >= 0) {
gsb->wdata = status;
status = 0;
}
} else {
status = i2c_smbus_write_word_data(&client, command,
gsb->wdata);
}
break;
case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
if (action == ACPI_READ) {
status = i2c_smbus_read_block_data(&client, command,
gsb->data);
if (status >= 0) {
gsb->len = status;
status = 0;
}
} else {
status = i2c_smbus_write_block_data(&client, command,
gsb->len, gsb->data);
}
break;
case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
if (action == ACPI_READ) {
status = acpi_gsb_i2c_read_bytes(&client, command,
gsb->data, info->access_length);
if (status > 0)
status = 0;
} else {
//.........这里部分代码省略.........
示例9: update_params
static int
update_params(void)
{
int status;
int retval = 1;
static u64 first_failure = 0;
if (!ltc4100_attached) return 0;
down(&update_mutex);
status = i2c_smbus_read_word_data(&client_ltc4100, 0x13);
if (status != -1) {
if (first_failure) {
printk(KERN_DEBUG "Time between failures: %llu\n",
jiffies_64 - first_failure);
first_failure = 0;
}
last_update = jiffies_64;
onAC = (status & (1 << 15)) ? 1 : 0;
batteryPresent = (status & (1 << 14)) ? 1 : 0;
if (machine_is_ghi270()) {
batteryCharging =
pxa_gpio_get_value(GHI270_H_GPIO26_CHGEN)?1:0;
} else {
batteryCharging =
pxa_gpio_get_value(GHI270_HG_GPIO53_CHGEN)?1:0;
}
rsoc = 0;
voltage = 0;
temp = 0;
time = 0;
current_now = 0;
if (batteryPresent && bq20z80_attached) {
/* Only read the battery itself when it is there. */
int tmp;
tmp = i2c_smbus_read_word_data(&client_bq20z80, 0xd);
if (tmp != -1) {
/* Relative state of charge */
pr_debug("RSOC: %d\n", tmp);
rsoc = tmp;
} else printk(KERN_ERR "rsoc fail\n");
tmp = i2c_smbus_read_word_data(&client_bq20z80, 0x9);
if (tmp != -1) {
pr_debug("Voltage: %d\n", tmp);
voltage = tmp;
} else printk(KERN_ERR "voltage fail\n");
tmp = i2c_smbus_read_word_data(&client_bq20z80, 0x8);
if (tmp != -1) {
pr_debug("Temperature: %d\n", tmp);
temp = tmp;
} else printk(KERN_ERR "temp fail\n");
tmp = i2c_smbus_read_word_data(&client_bq20z80, 0x11);
if (tmp != -1) {
pr_debug("Time: %d\n", tmp);
time = tmp;
} else printk(KERN_ERR "time fail\n");
tmp = i2c_smbus_read_word_data(&client_bq20z80, 0xa);
if (tmp != -1) {
pr_debug("Current: %d\n", tmp);
current_now = -((short)tmp);
} else printk(KERN_ERR "current fail\n");
}
} else {
retval = 0;
if (!first_failure) {
/* There has been a problem with reading the LTC4100
* on the proto HG that I'm using. Hopefully others
* will not have this problem. The H does not, and
* the battery circuitry is the same.
*/
printk(KERN_DEBUG "First failure\n");
first_failure = jiffies_64;
}
}
up(&update_mutex);
return retval;
}
示例10: detect
static int
detect(struct i2c_adapter *adapter, int address, int kind)
{
int err = 0;
if (address == 9) {
/* LTC4100 */
if (!i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_WORD_DATA)) {
goto exit;
}
memset(&client_ltc4100, 0, sizeof(client_ltc4100));
i2c_set_clientdata(&client_ltc4100, &client_ltc4100);
client_ltc4100.addr = address;
client_ltc4100.adapter = adapter;
client_ltc4100.driver = &ghi270_driver;
strlcpy(client_ltc4100.name, "ghi270_ltc4100", I2C_NAME_SIZE);
if (0x2 !=
(err = i2c_smbus_read_word_data(&client_ltc4100, 0x11))) {
if (err != -1) {
printk(KERN_ERR "Did not read expected\n");
}
}
if ((err = i2c_attach_client(&client_ltc4100))) {
goto exit;
}
INIT_DELAYED_WORK(&battery_work, battery_work_callback);
if (!update_params()) {
mdelay(100);
if (!update_params()) {
mdelay(100);
if (!update_params()) {
printk(KERN_ERR "Battery update fail\n");
}
}
}
# ifdef CONFIG_POWER_SUPPLY
power_supply_register(0, &battery_info);
# endif
ltc4100_attached = 1;
} else {
/* bq20z80 */
if (bq20z80_attached) {
printk(KERN_ERR "Already Attached!!\n");
return 0;
}
memset(&client_bq20z80, 0, sizeof(client_bq20z80));
i2c_set_clientdata(&client_bq20z80, &client_bq20z80);
client_bq20z80.addr = address;
client_bq20z80.adapter = adapter;
client_bq20z80.driver = &ghi270_driver;
strlcpy(client_bq20z80.name, "ghi270_bq20z80", I2C_NAME_SIZE);
/* This device may not be on the i2c bus at any given time
* because it is in the battery itself. */
if ((err = i2c_attach_client(&client_bq20z80))) {
goto exit;
}
bq20z80_attached = 1;
}
return 0;
exit:
return err;
}
示例11: main
//.........这里部分代码省略.........
}
if (version) {
fprintf(stderr, "i2cget version %s\n", VERSION);
exit(0);
}
if (argc < flags + 3)
help();
i2cbus = lookup_i2c_bus(argv[flags+1]);
if (i2cbus < 0)
help();
address = parse_i2c_address(argv[flags+2]);
if (address < 0)
help();
if (argc > flags + 3) {
size = I2C_SMBUS_BYTE_DATA;
daddress = strtol(argv[flags+3], &end, 0);
if (*end || daddress < 0 || daddress > 0xff) {
fprintf(stderr, "Error: Data address invalid!\n");
help();
}
} else {
size = I2C_SMBUS_BYTE;
daddress = -1;
}
if (argc > flags + 4) {
switch (argv[flags+4][0]) {
case 'b': size = I2C_SMBUS_BYTE_DATA; break;
case 'w': size = I2C_SMBUS_WORD_DATA; break;
case 'c': size = I2C_SMBUS_BYTE; break;
default:
fprintf(stderr, "Error: Invalid mode!\n");
help();
}
pec = argv[flags+4][1] == 'p';
}
file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);
if (file < 0
|| check_funcs(file, size, daddress, pec)
|| set_slave_addr(file, address, force))
exit(1);
if (!yes && !confirm(filename, address, size, daddress, pec))
exit(0);
if (pec && ioctl(file, I2C_PEC, 1) < 0) {
fprintf(stderr, "Error: Could not set PEC: %s\n",
strerror(errno));
close(file);
exit(1);
}
switch (size) {
case I2C_SMBUS_BYTE:
if (daddress >= 0) {
#if 1
/*Use eepromer for large eeproms with two-byte addresses:*/
__u8 buf[2] = { (daddress >> 8) & 0x0ff, daddress & 0x0ff};
/* ioctl(file, BLKFLSBUF); // clear kernel read buffer*/
res =i2c_smbus_write_byte_data(file, buf[0], buf[1]);
#else
/*Use eeprom for small eeproms with one-byte addresses:*/
/* res = i2c_smbus_write_byte(file, daddress);*/
#endif
if (res < 0)
fprintf(stderr, "Warning - write failed\n");
}
/* ioctl(file, BLKFLSBUF); // clear kernel read buffer*/
res = i2c_smbus_read_byte(file);
break;
case I2C_SMBUS_WORD_DATA:
{
#if 1
/*Use eepromer for large eeproms with two-byte addresses:*/
/* __u8 buf[2] = { (daddress >> 8) & 0x0ff, daddress & 0x0ff};*/
__u8 buf[2] = { 0x00, 0x00};
/* ioctl(file, BLKFLSBUF); // clear kernel read buffer*/
res =i2c_smbus_write_byte_data(file, buf[0], buf[1]);
#endif
res = i2c_smbus_read_word_data(file, daddress);
}
break;
default: /* I2C_SMBUS_BYTE_DATA */
{
#if 1
/*Use eepromer for large eeproms with two-byte addresses:*/
/* __u8 buf[2] = { (daddress >> 8) & 0x0ff, daddress & 0x0ff};*/
__u8 buf[2] = { 0x00, 0x00};
/* ioctl(file, BLKFLSBUF); // clear kernel read buffer*/
res =i2c_smbus_write_byte_data(file, buf[0], buf[1]);
#endif
res = i2c_smbus_read_byte_data(file, daddress);
}
}
示例12: isp1301_get_u16
static inline int
isp1301_get_u16(struct isp1301 *isp, u8 reg)
{
return i2c_smbus_read_word_data(&isp->client, reg);
}
示例13: isp1301_probe
/* no error returns, they'd just make bus scanning stop */
static int isp1301_probe(struct i2c_adapter *bus, int address, int kind)
{
int status;
struct isp1301 *isp;
struct i2c_client *i2c;
if (the_transceiver)
return 0;
isp = kzalloc(sizeof *isp, GFP_KERNEL);
if (!isp)
return 0;
INIT_WORK(&isp->work, isp1301_work);
init_timer(&isp->timer);
isp->timer.function = isp1301_timer;
isp->timer.data = (unsigned long) isp;
isp->irq = -1;
isp->client.addr = address;
i2c_set_clientdata(&isp->client, isp);
isp->client.adapter = bus;
isp->client.driver = &isp1301_driver;
strlcpy(isp->client.name, DRIVER_NAME, I2C_NAME_SIZE);
i2c = &isp->client;
/* if this is a true probe, verify the chip ... */
if (kind < 0) {
status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
if (status != I2C_VENDOR_ID_PHILIPS) {
dev_dbg(&bus->dev, "addr %d not philips id: %d\n",
address, status);
goto fail1;
}
status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
dev_dbg(&bus->dev, "%d not isp1301, %d\n",
address, status);
goto fail1;
}
}
status = i2c_attach_client(i2c);
if (status < 0) {
dev_dbg(&bus->dev, "can't attach %s to device %d, err %d\n",
DRIVER_NAME, address, status);
fail1:
kfree(isp);
return 0;
}
isp->i2c_release = i2c->dev.release;
i2c->dev.release = isp1301_release;
/* initial development used chiprev 2.00 */
status = i2c_smbus_read_word_data(i2c, ISP1301_BCD_DEVICE);
dev_info(&i2c->dev, "chiprev %x.%02x, driver " DRIVER_VERSION "\n",
status >> 8, status & 0xff);
/* make like power-on reset */
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
~(OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN));
isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
#ifdef CONFIG_USB_OTG
status = otg_bind(isp);
if (status < 0) {
dev_dbg(&i2c->dev, "can't bind OTG\n");
goto fail2;
}
#endif
if (machine_is_omap_h2()) {
/* full speed signaling by default */
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
MC1_SPEED_REG);
isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
MC2_SPD_SUSP_CTRL);
/* IRQ wired at M14 */
omap_cfg_reg(M14_1510_GPIO2);
isp->irq = OMAP_GPIO_IRQ(2);
if (gpio_request(2, "isp1301") == 0)
gpio_direction_input(2);
isp->irq_type = IRQF_TRIGGER_FALLING;
}
isp->irq_type |= IRQF_SAMPLE_RANDOM;
status = request_irq(isp->irq, isp1301_irq,
isp->irq_type, DRIVER_NAME, isp);
//.........这里部分代码省略.........
示例14: ad7152_read_raw
static int ad7152_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2,
long mask)
{
struct ad7152_chip_info *chip = iio_priv(indio_dev);
int ret;
u8 regval = 0;
mutex_lock(&indio_dev->mlock);
switch (mask) {
case 0:
/* First set whether in differential mode */
regval = chip->setup[chan->channel];
if (chan->differential)
chip->setup[chan->channel] |= AD7152_SETUP_CAPDIFF;
else
chip->setup[chan->channel] &= ~AD7152_SETUP_CAPDIFF;
if (regval != chip->setup[chan->channel]) {
ret = i2c_smbus_write_byte_data(chip->client,
ad7152_addresses[chan->channel][AD7152_SETUP],
chip->setup[chan->channel]);
if (ret < 0)
goto out;
}
/* Make sure the channel is enabled */
if (chan->channel == 0)
regval = AD7152_CONF_CH1EN;
else
regval = AD7152_CONF_CH2EN;
/* Trigger a single read */
regval |= AD7152_CONF_MODE_SINGLE_CONV;
ret = i2c_smbus_write_byte_data(chip->client, AD7152_REG_CFG,
regval);
if (ret < 0)
goto out;
msleep(ad7152_filter_rate_table[chip->filter_rate_setup][1]);
/* Now read the actual register */
ret = i2c_smbus_read_word_data(chip->client,
ad7152_addresses[chan->channel][AD7152_DATA]);
if (ret < 0)
goto out;
*val = swab16(ret);
if (chan->differential)
*val -= 0x8000;
ret = IIO_VAL_INT;
break;
case IIO_CHAN_INFO_CALIBSCALE:
ret = i2c_smbus_read_word_data(chip->client,
ad7152_addresses[chan->channel][AD7152_GAIN]);
if (ret < 0)
goto out;
/* 1 + gain_val / 2^16 */
*val = 1;
*val2 = (15625 * swab16(ret)) / 1024;
ret = IIO_VAL_INT_PLUS_MICRO;
break;
case IIO_CHAN_INFO_CALIBBIAS:
ret = i2c_smbus_read_word_data(chip->client,
ad7152_addresses[chan->channel][AD7152_OFFS]);
if (ret < 0)
goto out;
*val = swab16(ret);
ret = IIO_VAL_INT;
break;
case IIO_CHAN_INFO_SCALE:
ret = i2c_smbus_read_byte_data(chip->client,
ad7152_addresses[chan->channel][AD7152_SETUP]);
if (ret < 0)
goto out;
*val = 0;
*val2 = ad7152_scale_table[ret >> 6];
ret = IIO_VAL_INT_PLUS_NANO;
break;
default:
ret = -EINVAL;
};
out:
mutex_unlock(&indio_dev->mlock);
return ret;
}
示例15: bma250_probe
static int bma250_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
int tempvalue;
struct bma250_data *data;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_INFO "i2c_check_functionality error\n");
goto exit;
}
data = kzalloc(sizeof(struct bma250_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
goto exit;
}
/* read chip id */
tempvalue = 0;
tempvalue = i2c_smbus_read_word_data(client, BMA250_CHIP_ID_REG);
if ((tempvalue&0x00FF) == BMA250_CHIP_ID) {
printk(KERN_INFO "Bosch Sensortec Device detected!\n" \
"BMA250 registered I2C driver!\n");
} else{
printk(KERN_INFO "Bosch Sensortec Device not found, \
i2c error %d \n", tempvalue);
err = -1;
goto kfree_exit;
}
i2c_set_clientdata(client, data);
data->bma250_client = client;
mutex_init(&data->mode_mutex);
mutex_init(&data->enable_mutex);
bma250_set_bandwidth(client, BMA250_BW_SET);
bma250_set_range(client, BMA250_RANGE_SET);
INIT_DELAYED_WORK(&data->work, bma250_work_func);
atomic_set(&data->delay, BMA250_DEFAULT_DELAY);
atomic_set(&data->enable, 0);
err = bma250_input_init(data);
if (err < 0)
goto kfree_exit;
err = sysfs_create_group(&data->input->dev.kobj,
&bma250_attribute_group);
if (err < 0)
goto error_sysfs;
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
data->early_suspend.suspend = bma250_early_suspend;
data->early_suspend.resume = bma250_late_resume;
register_early_suspend(&data->early_suspend);
#endif
err = bma250_set_mode(client, BMA250_MODE_SUSPEND);
if (err)
goto error_sysfs;
return 0;
error_sysfs:
bma250_input_delete(data);
kfree_exit:
kfree(data);
exit:
return err;
}