Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752855Ab0H0Lzw (ORCPT ); Fri, 27 Aug 2010 07:55:52 -0400 Received: from smtp.nokia.com ([192.100.105.134]:55758 "EHLO mgw-mx09.nokia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752241Ab0H0Lz3 (ORCPT ); Fri, 27 Aug 2010 07:55:29 -0400 From: Samu Onkalo To: linux-i2c@vger.kernel.org, linux-kernel@vger.kernel.org, akpm@linux-foundation.org Subject: [PATCH 1/3] drivers: misc: ak8974 / ami305 magnetometer driver Date: Fri, 27 Aug 2010 14:54:41 +0300 Message-Id: <1282910083-8629-2-git-send-email-samu.p.onkalo@nokia.com> X-Mailer: git-send-email 1.6.3.3 In-Reply-To: <1282910083-8629-1-git-send-email-samu.p.onkalo@nokia.com> References: <1282910083-8629-1-git-send-email-samu.p.onkalo@nokia.com> X-OriginalArrivalTime: 27 Aug 2010 11:54:50.0092 (UTC) FILETIME=[A73B2AC0:01CB45DE] X-Nokia-AV: Clean Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 20254 Lines: 786 Patch provides support for ak8974 / ami305 3-axis magnetometer chip. Results are provided via misc character device. Driver supports multiple instaces of the chip. Driver has PM and regulator framework support. Signed-off-by: Samu Onkalo --- drivers/misc/ak8974.c | 703 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/i2c/ak8974.h | 50 ++++ 2 files changed, 753 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/ak8974.c create mode 100644 include/linux/i2c/ak8974.h diff --git a/drivers/misc/ak8974.c b/drivers/misc/ak8974.c new file mode 100644 index 0000000..e480314 --- /dev/null +++ b/drivers/misc/ak8974.c @@ -0,0 +1,703 @@ +/* + * Driver for ak8974 (Asahi Kasei EMD Corporation) + * and ami305 (Aichi Steel) magnetometer chip. + * + * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Samu Onkalo + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * 16-bit registers are little-endian. LSB is at the address defined below + * and MSB is at the next higher address. + */ + +/* for AK8974 and AMI305 registers */ +#define AK8974_SELFTEST 0x0C +#define AK8974_INFO 0x0D +#define AK8974_WHOAMI 0x0F +#define AK8974_DATA_X 0x10 +#define AK8974_DATA_Y 0x12 +#define AK8974_DATA_Z 0x14 +#define AK8974_INT_SRC 0x16 +#define AK8974_STATUS 0x18 +#define AK8974_INT_CLEAR 0x1A +#define AK8974_CTRL1 0x1B +#define AK8974_CTRL2 0x1C +#define AK8974_CTRL3 0x1D +#define AK8974_INT_CTRL 0x1E +#define AK8974_OFFSET_X 0x20 +#define AK8974_OFFSET_Y 0x22 +#define AK8974_OFFSET_Z 0x24 +#define AK8974_INT_THRES 0x26 /* absolute any axis value threshold */ +#define AK8974_PRESET 0x30 +#define AK8974_TEMP 0x31 + +#define AK8974_SELFTEST_IDLE 0x55 +#define AK8974_SELFTEST_OK 0xAA + +#define AK8974_WHOAMI_VALUE_AMI305 0x47 +#define AK8974_WHOAMI_VALUE_AK8974 0x48 +#define AK8974_INT_X_HIGH 0x80 /* Axis over +threshold */ +#define AK8974_INT_Y_HIGH 0x40 +#define AK8974_INT_Z_HIGH 0x20 +#define AK8974_INT_X_LOW 0x10 /* Axis below -threshold */ +#define AK8974_INT_Y_LOW 0x08 +#define AK8974_INT_Z_LOW 0x04 +#define AK8974_INT_RANGE 0x02 /* Range overflow (any axis) */ + +#define AK8974_STATUS_DRDY 0x40 /* Data ready */ +#define AK8974_STATUS_OVERRUN 0x20 /* Data overrun */ +#define AK8974_STATUS_INT 0x10 /* Interrupt occurred */ + +#define AK8974_CTRL1_POWER 0x80 /* 0 = standby; 1 = active */ +#define AK8974_CTRL1_RATE 0x10 /* 0 = 10 Hz; 1 = 20 Hz */ +#define AK8974_CTRL1_FORCE_EN 0x02 /* 0 = normal; 1 = force */ +#define AK8974_CTRL1_MODE2 0x01 /* 0 */ + +#define AK8974_CTRL2_INT_EN 0x10 /* 1 = enable interrupts */ +#define AK8974_CTRL2_DRDY_EN 0x08 /* 1 = enable data ready signal */ +#define AK8974_CTRL2_DRDY_POL 0x04 /* 1 = data ready active high */ +#define AK8974_CTRL2_RESDEF (AK8974_CTRL2_DRDY_POL) + +#define AK8974_CTRL3_RESET 0x80 /* Software reset */ +#define AK8974_CTRL3_FORCE 0x40 /* Start forced measurement */ +#define AK8974_CTRL3_SELFTEST 0x10 /* Set selftest register */ +#define AK8974_CTRL3_RESDEF 0x00 + +#define AK8974_INT_CTRL_XEN 0x80 /* Enable interrupt for this axis */ +#define AK8974_INT_CTRL_YEN 0x40 +#define AK8974_INT_CTRL_ZEN 0x20 +#define AK8974_INT_CTRL_XYZEN 0xE0 +#define AK8974_INT_CTRL_POL 0x08 /* 0 = active low; 1 = active high */ +#define AK8974_INT_CTRL_PULSE 0x02 /* 0 = latched; 1 = pulse (50 usec) */ +#define AK8974_INT_CTRL_RESDEF (AK8974_INT_CTRL_XYZEN | AK8974_INT_CTRL_POL) + +#define AK8974_INT_SCR_MROI 0x02 + +#define AK8974_MAX_RANGE 2048 + +#define AK8974_POWERON_DELAY 50 +#define AK8974_ACTIVATE_DELAY 1 +#define AK8974_SELFTEST_DELAY 1 + +#define AK8974_MEASTIME 3 + +#define AK8974_PWR_ON 1 +#define AK8974_PWR_OFF 0 + +struct ak8974_chip { + struct miscdevice miscdev; + struct mutex lock; /* Serialize access to chip */ + struct mutex users_lock; + struct i2c_client *client; + struct regulator_bulk_data regs[2]; + struct work_struct work; + wait_queue_head_t misc_wait; + loff_t offset; + + int max_range; + int users; + + const char *id; + u8 info[2]; + + s16 x, y, z; /* Latest measurements */ + s8 axis_x; + s8 axis_y; + s8 axis_z; + bool valid; + + char name[20]; +}; + +static const char reg_avdd[] = "AVdd"; +static const char reg_dvdd[] = "DVdd"; +static atomic_t device_number = ATOMIC_INIT(0); + +static inline int ak8974_write(struct ak8974_chip *chip, u8 reg, u8 data) +{ + return i2c_smbus_write_byte_data(chip->client, reg, data); +} + +static inline int ak8974_read(struct ak8974_chip *chip, u8 reg) +{ + return i2c_smbus_read_byte_data(chip->client, reg); +} + +static inline int ak8974_read_block(struct ak8974_chip *chip, u8 reg, + u8 *data, u8 length) +{ + return i2c_smbus_read_i2c_block_data(chip->client, reg, length, data); +} + +static int ak8974_enable(struct ak8974_chip *chip, bool mode) +{ + int r, v; + + v = mode ? AK8974_CTRL1_POWER : 0; + v |= AK8974_CTRL1_FORCE_EN; + r = ak8974_write(chip, AK8974_CTRL1, v); + if (r < 0) + return r; + + if (mode) + msleep(AK8974_ACTIVATE_DELAY); + + return 0; +} + +static int ak8974_reset(struct ak8974_chip *chip) +{ + int r; + + /* Power on to get register access. Sets CTRL1 reg to reset state */ + r = ak8974_enable(chip, AK8974_PWR_ON); + r |= ak8974_write(chip, AK8974_CTRL2, AK8974_CTRL2_RESDEF); + r |= ak8974_write(chip, AK8974_CTRL3, AK8974_CTRL3_RESDEF); + r |= ak8974_write(chip, AK8974_INT_CTRL, AK8974_INT_CTRL_RESDEF); + + /* After reset, power off is default state */ + r |= ak8974_enable(chip, AK8974_PWR_OFF); + + return r; +} + +static int ak8974_configure(struct ak8974_chip *chip) +{ + int err; + + err = ak8974_write(chip, AK8974_CTRL2, AK8974_CTRL2_DRDY_EN | + AK8974_CTRL2_INT_EN); + err |= ak8974_write(chip, AK8974_CTRL3, 0); + err |= ak8974_write(chip, AK8974_INT_CTRL, AK8974_INT_CTRL_POL); + err |= ak8974_write(chip, AK8974_PRESET, 0); + + return err; +} + +static int ak8974_poll_drdy(struct ak8974_chip *chip) +{ + int timeout = 2; + int ret; + + do { + msleep(AK8974_MEASTIME); + ret = ak8974_read(chip, AK8974_STATUS); + if (ret < 0) + return ret; + if (ret & AK8974_STATUS_DRDY) + return 0; + } while (--timeout); + return ret; +} + +static int ak8974_trigmeas(struct ak8974_chip *chip) +{ + int ctrl3; + + /* Clear previous measurement overflow status */ + ak8974_read(chip, AK8974_INT_CLEAR); + + ctrl3 = ak8974_read(chip, AK8974_CTRL3); + if (ctrl3 < 0) + return ctrl3; + + return ak8974_write(chip, AK8974_CTRL3, ctrl3 | AK8974_CTRL3_FORCE); +} + +static int ak8974_getresult(struct ak8974_chip *chip, s16 *result) +{ + int ret; + int i; + + ret = ak8974_poll_drdy(chip); + /* Measurement overflow ? */ + ret |= ak8974_read(chip, AK8974_INT_SRC); + if (ret < 0) + return ret; + if (ret & AK8974_INT_SCR_MROI) + ret = -ERANGE; + else + ret = 0; + + ak8974_read_block(chip, AK8974_DATA_X, (u8 *)result, 6); + for (i = 0; i < 3; i++) + result[i] = le16_to_cpu(result[i]); + + return ret; +} + +static int ak8974_selftest(struct ak8974_chip *chip) +{ + int r; + int ret = -EIO; + + r = ak8974_read(chip, AK8974_SELFTEST); + if (r != AK8974_SELFTEST_IDLE) + goto out; + + r = ak8974_read(chip, AK8974_CTRL3); + if (r < 0) + goto out; + + r = ak8974_write(chip, AK8974_CTRL3, r | AK8974_CTRL3_SELFTEST); + if (r < 0) + goto out; + + msleep(AK8974_SELFTEST_DELAY); + + r = ak8974_read(chip, AK8974_SELFTEST); + if (r != AK8974_SELFTEST_OK) + goto out; + + r = ak8974_read(chip, AK8974_SELFTEST); + if (r == AK8974_SELFTEST_IDLE) + ret = 0; + +out: + return ret; +} + +static int ak8974_regulators_on(struct ak8974_chip *chip) +{ + int ret; + ret = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); + if (ret == 0) + msleep(AK8974_POWERON_DELAY); + + return ret; +} + +static inline void ak8974_regulators_off(struct ak8974_chip *chip) +{ + regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); +} + +static int ak8974_add_users(struct ak8974_chip *chip) +{ + int r = 0; + mutex_lock(&chip->users_lock); + + if (chip->users == 0) { + r = ak8974_regulators_on(chip); + if (r < 0) + goto release_lock; + r = ak8974_enable(chip, AK8974_PWR_ON); + if (r < 0) + goto fail2; + r = ak8974_configure(chip); + if (r < 0) + goto fail3; + } + chip->users++; + goto release_lock; +fail3: + ak8974_enable(chip, AK8974_PWR_OFF); +fail2: + ak8974_regulators_off(chip); +release_lock: + mutex_unlock(&chip->users_lock); + return r; +} + +static void ak8974_remove_users(struct ak8974_chip *chip) +{ + mutex_lock(&chip->users_lock); + + if (chip->users != 0) + chip->users--; + + if (chip->users == 0) { + ak8974_enable(chip, AK8974_PWR_OFF); + ak8974_regulators_off(chip); + } + mutex_unlock(&chip->users_lock); +} + +static int ak8974_get_axis(s8 axis, s16 hw_values[3]) +{ + if (axis > 0) + return hw_values[axis - 1]; + else + return -hw_values[-axis - 1]; +} + +static int ak8974_read_values(struct ak8974_chip *chip) +{ + s16 hw_values[3]; + int ret; + + mutex_lock(&chip->lock); + ak8974_trigmeas(chip); + ret = ak8974_getresult(chip, hw_values); + chip->x = ak8974_get_axis(chip->axis_x, hw_values); + chip->y = ak8974_get_axis(chip->axis_y, hw_values); + chip->z = ak8974_get_axis(chip->axis_z, hw_values); + chip->valid = (ret == 0) ? 1 : 0; + chip->offset += sizeof(struct ak8974_data); + mutex_unlock(&chip->lock); + wake_up_interruptible(&chip->misc_wait); + return 0; +} + +static void ak8974_work(struct work_struct *work) +{ + struct ak8974_chip *chip = container_of(work, + struct ak8974_chip, + work); + ak8974_read_values(chip); +} + +static int ak8974_misc_open(struct inode *inode, struct file *file) +{ + struct ak8974_chip *chip = container_of(file->private_data, + struct ak8974_chip, + miscdev); + file->f_pos = chip->offset; + return ak8974_add_users(chip); +} + +static int ak8974_misc_close(struct inode *inode, struct file *file) +{ + struct ak8974_chip *chip = container_of(file->private_data, + struct ak8974_chip, + miscdev); + ak8974_remove_users(chip); + return 0; +} + +static ssize_t ak8974_misc_read(struct file *file, char __user *buf, + size_t count, loff_t *offset) +{ + struct ak8974_chip *chip = container_of(file->private_data, + struct ak8974_chip, + miscdev); + struct ak8974_data data; + + if (count < sizeof(data)) + return -EINVAL; + + if (*offset >= chip->offset) { + schedule_work(&chip->work); + if (file->f_flags & O_NONBLOCK) + return -EAGAIN; + if (wait_event_interruptible(chip->misc_wait, + (*offset < chip->offset))) + return -ERESTARTSYS; + } + + mutex_lock(&chip->lock); + data.x = chip->x; + data.y = chip->y; + data.z = chip->z; + data.valid = chip->valid; + *offset = chip->offset; + mutex_unlock(&chip->lock); + + return copy_to_user(buf, &data, sizeof(data)) ? -EFAULT : sizeof(data); +} + +static ssize_t ak8974_show_selftest(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ak8974_chip *chip = dev_get_drvdata(dev); + int ret; + + ak8974_add_users(chip); + mutex_lock(&chip->lock); + ret = ak8974_selftest(chip); + mutex_unlock(&chip->lock); + ak8974_remove_users(chip); + + return sprintf(buf, "%s\n", ret ? "FAIL" : "OK"); +} + +static DEVICE_ATTR(selftest, S_IRUGO, ak8974_show_selftest, NULL); + +static ssize_t ak8974_show_chip_id(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ak8974_chip *chip = dev_get_drvdata(dev); + return sprintf(buf, "%s rev %d\n", chip->id, + chip->info[0] | (u16)chip->info[1] << 8); +} + +static DEVICE_ATTR(chip_id, S_IRUGO, ak8974_show_chip_id, NULL); + +static ssize_t ak8974_show_range(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ak8974_chip *chip = dev_get_drvdata(dev); + return sprintf(buf, "%d\n", chip->max_range); +} + +static DEVICE_ATTR(range, S_IRUGO, ak8974_show_range, NULL); + +static struct attribute *sysfs_attrs[] = { + &dev_attr_selftest.attr, + &dev_attr_range.attr, + &dev_attr_chip_id.attr, + NULL +}; + +static struct attribute_group ak8974_attribute_group = { + .attrs = sysfs_attrs +}; + +static const struct file_operations ak8974_fops = { + .owner = THIS_MODULE, + .llseek = no_llseek, + .read = ak8974_misc_read, + .open = ak8974_misc_open, + .release = ak8974_misc_close, +}; + +static int ak8974_detect(struct ak8974_chip *chip, const char *name) +{ + int whoiam; + whoiam = ak8974_read(chip, AK8974_WHOAMI); + + switch (whoiam) { + case AK8974_WHOAMI_VALUE_AMI305: + chip->id = chip->client->driver->id_table[0].name; + break; + case AK8974_WHOAMI_VALUE_AK8974: + chip->id = chip->client->driver->id_table[1].name; + break; + default: + dev_dbg(&chip->client->dev, "unsupported device\n"); + return -ENODEV; + } + + ak8974_read_block(chip, AK8974_INFO, chip->info, 2); + + chip->max_range = AK8974_MAX_RANGE; + + return 0; +} + +static int __devinit ak8974_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct ak8974_chip *chip; + struct ak8974_platform_data *pdata; + int err; + int x, y, z; + + chip = kzalloc(sizeof *chip, GFP_KERNEL); + if (!chip) + return -ENOMEM; + + i2c_set_clientdata(client, chip); + chip->client = client; + + pdata = client->dev.platform_data; + + x = AK8974_DEV_X; + y = AK8974_DEV_Y; + z = AK8974_DEV_Z; + + if (pdata) { + /* Remap axes */ + x = pdata->axis_x ? pdata->axis_x : x; + y = pdata->axis_y ? pdata->axis_y : y; + z = pdata->axis_z ? pdata->axis_z : z; + } + + if ((abs(x) > 3) || (abs(y) > 3) || (abs(z) > 3)) { + dev_err(&client->dev, "Incorrect platform data\n"); + err = -EINVAL; + goto fail1; + } + + chip->axis_x = x; + chip->axis_y = y; + chip->axis_z = z; + + mutex_init(&chip->lock); + mutex_init(&chip->users_lock); + init_waitqueue_head(&chip->misc_wait); + INIT_WORK(&chip->work, ak8974_work); + + chip->regs[0].supply = reg_avdd; + chip->regs[1].supply = reg_dvdd; + + err = regulator_bulk_get(&client->dev, + ARRAY_SIZE(chip->regs), chip->regs); + if (err < 0) { + dev_err(&client->dev, "Cannot get regulators\n"); + goto fail1; + } + + err = ak8974_regulators_on(chip); + if (err < 0) { + dev_err(&client->dev, "Cannot enable regulators\n"); + goto fail2; + } + + err = ak8974_detect(chip, id->name); + if (err < 0) { + dev_err(&client->dev, "Neither AK8974 nor ami305 found\n"); + goto fail3; + } + + snprintf(chip->name, sizeof(chip->name), "ak8974%d", + atomic_add_return(1, &device_number) - 1); + + err = ak8974_reset(chip); + if (err) { + dev_err(&client->dev, "Chip reset failed"); + goto fail3; + } + + ak8974_regulators_off(chip); + + chip->miscdev.minor = MISC_DYNAMIC_MINOR; + chip->miscdev.name = chip->name; + chip->miscdev.fops = &ak8974_fops; + chip->miscdev.parent = &chip->client->dev; + err = misc_register(&chip->miscdev); + if (err < 0) { + dev_err(&chip->client->dev, "Device registration failed\n"); + goto fail3; + } + + err = sysfs_create_group(&chip->client->dev.kobj, + &ak8974_attribute_group); + if (err) { + dev_err(&client->dev, "Sysfs registration failed\n"); + goto fail4; + } + + + return 0; +fail4: + misc_deregister(&chip->miscdev); +fail3: + ak8974_regulators_off(chip); +fail2: + regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); +fail1: + kfree(chip); + return err; +} + +static int __devexit ak8974_remove(struct i2c_client *client) +{ + struct ak8974_chip *chip = i2c_get_clientdata(client); + misc_deregister(&chip->miscdev); + cancel_work_sync(&chip->work); + sysfs_remove_group(&chip->client->dev.kobj, + &ak8974_attribute_group); + /* No users after sysfs removal and unregisterin of input device */ + regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); + kfree(chip); + return 0; +} + + +#ifdef CONFIG_PM +static int ak8974_suspend(struct i2c_client *client, pm_message_t mesg) +{ + struct ak8974_chip *chip = i2c_get_clientdata(client); + mutex_lock(&chip->users_lock); + if (chip->users > 0) + ak8974_enable(chip, AK8974_PWR_OFF); + mutex_unlock(&chip->users_lock); + return 0; +} + +static int ak8974_resume(struct i2c_client *client) +{ + struct ak8974_chip *chip = i2c_get_clientdata(client); + mutex_lock(&chip->users_lock); + if (chip->users > 0) + ak8974_enable(chip, AK8974_PWR_ON); + mutex_unlock(&chip->users_lock); + return 0; +} + +static void ak8974_shutdown(struct i2c_client *client) +{ + struct ak8974_chip *chip = i2c_get_clientdata(client); + + mutex_lock(&chip->users_lock); + if (chip->users > 0) + ak8974_enable(chip, AK8974_PWR_OFF); + + mutex_unlock(&chip->users_lock); +} + +#else +#define ak8974_suspend NULL +#define ak8974_shutdown NULL +#define ak8974_resume NULL +#endif + +static const struct i2c_device_id ak8974_id[] = { + {"ami305", 0 }, + {"ak8974", 0 }, + {} +}; + +MODULE_DEVICE_TABLE(i2c, ak8974_id); + +static struct i2c_driver ak8974_driver = { + .driver = { + .name = "ak8974", + .owner = THIS_MODULE, + }, + .suspend = ak8974_suspend, + .shutdown = ak8974_shutdown, + .resume = ak8974_resume, + .probe = ak8974_probe, + .remove = __devexit_p(ak8974_remove), + .id_table = ak8974_id, +}; + +static int __init ak8974_init(void) +{ + return i2c_add_driver(&ak8974_driver); +} + +static void __exit ak8974_exit(void) +{ + i2c_del_driver(&ak8974_driver); +} + + +MODULE_DESCRIPTION("AK8974/5 and AMI305 3-axis magnetometer driver"); +MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); +MODULE_LICENSE("GPL v2"); + +module_init(ak8974_init); +module_exit(ak8974_exit); diff --git a/include/linux/i2c/ak8974.h b/include/linux/i2c/ak8974.h new file mode 100644 index 0000000..b991404 --- /dev/null +++ b/include/linux/i2c/ak8974.h @@ -0,0 +1,50 @@ +/* + * Driver for ak8974 (Asahi Kasei EMD Corporation) + * and ami305 (Aichi Steel) magnetometer chip. + * + * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Samu Onkalo + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifndef __LINUX_I2C_AK8974_H +#define __LINUX_I2C_AK8974_H + +#define AK8974_NO_MAP 0 +#define AK8974_DEV_X 1 +#define AK8974_DEV_Y 2 +#define AK8974_DEV_Z 3 +#define AK8974_INV_DEV_X -1 +#define AK8974_INV_DEV_Y -2 +#define AK8974_INV_DEV_Z -3 + +struct ak8974_platform_data { + s8 axis_x; + s8 axis_y; + s8 axis_z; +}; + +/* Device name: /dev/ak8974n, where n is a running number */ +struct ak8974_data { + __s16 x; + __s16 y; + __s16 z; + __u16 valid; +} __attribute__((packed)); + +#endif -- 1.6.3.3 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/