lkml.org 
[lkml]   [2008]   [Jun]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [lm-sensors] [PATCH 2.6.25.4] hwmon: HP Mobile Data Protection System 3D ACPI driver
Yan Burman wrote:
> +==================
> +
> +Supported chips:
> +
> + * STMicroelectronics LIS3LV02DL and LIS3LV02DQ
> +
These chips are connected to either I2C or SPI - This is the 4th driver for
(apparently) these same chips:

http://docwiki.gumstix.org/Lis3lv02dq_spi.c
http://svn.openmoko.org/branches/src/target/kernel/2.6.24.x/patches/lis302dl.patch

http://article.gmane.org/gmane.linux.kernel.spi.devel/1010

> + depends on ACPI && INPUT && X86
>


> +/* The actual chip is STMicroelectronics LIS3LV02DL or LIS3LV02DQ
> + * that seems to be connected via SPI */
>
Perhaps it would make more sense implement support for SPI
bus on the laptop and use the SPI interface directly instead or
routing via the ACPI hiding layer?

> +
> +#define MDPS_WHO_AM_I 0x0F /*r 00111010 */
> +#define MDPS_OFFSET_X 0x16 /*rw */
> +#define MDPS_OFFSET_Y 0x17 /*rw */
> +#define MDPS_OFFSET_Z 0x18 /*rw */
> +#define MDPS_GAIN_X 0x19 /*rw */
> +#define MDPS_GAIN_Y 0x1A /*rw */
> +#define MDPS_GAIN_Z 0x1B /*rw */
> +#define MDPS_CTRL_REG1 0x20 /*rw 00000111 */
> +#define MDPS_CTRL_REG2 0x21 /*rw 00000000 */
> +#define MDPS_CTRL_REG3 0x22 /*rw 00001000 */
> +#define MDPS_HP_FILTER RESET 0x23 /*r */
> +#define MDPS_STATUS_REG 0x27 /*rw 00000000 */
> +#define MDPS_OUTX_L 0x28 /*r */
> +#define MDPS_OUTX_H 0x29 /*r */
> +#define MDPS_OUTY_L 0x2A /*r */
> +#define MDPS_OUTY_H 0x2B /*r */
> +#define MDPS_OUTZ_L 0x2C /*r */
> +#define MDPS_OUTZ_H 0x2D /*r */
> +#define MDPS_FF_WU_CFG 0x30 /*rw 00000000 */
> +#define MDPS_FF_WU_SRC 0x31 /*rw 00000000 */
> +#define MDPS_FF_WU_ACK 0x32 /*r */
> +#define MDPS_FF_WU_THS_L 0x34 /*rw 00000000 */
> +#define MDPS_FF_WU_THS_H 0x35 /*rw 00000000 */
> +#define MDPS_FF_WU_DURATION 0x36 /*rw 00000000 */
> +#define MDPS_DD_CFG 0x38 /*rw 00000000 */
> +#define MDPS_DD_SRC 0x39 /*rw 00000000 */
> +#define MDPS_DD_ACK 0x3A /*r */
> +#define MDPS_DD_THSI_L 0x3C /*rw 00000000 */
> +#define MDPS_DD_THSI_H 0x3D /*rw 00000000 */
> +#define MDPS_DD_THSE_L 0x3E /*rw 00000000 */
> +#define MDPS_DD_THSE_H 0x3F /*rw 00000000 */
> +
> +#define MDPS_ID 0x3A /* MDPS_WHO_AM_I */
> +#define MDPS_FS (1<<7) /* MDPS_CTRL_REG2 : Full Scale selection */
> +#define MDPS_BDU (1<<6) /* MDPS_CTRL_REG2 : Block Data Update */
> +
> +/* joystick device poll interval in milliseconds */
> +#define MDPS_POLL_INTERVAL 30
> +
> +/* Maximum value our axis may get for the input device */
> +#define MDPS_MAX_VAL 2048
> +
> +static unsigned int power_off;
> +module_param(power_off, bool, S_IRUGO);
> +MODULE_PARM_DESC(power_off, "Turn off device on module load");
> +
> +struct axis_conversion {
> + s8 x;
> + s8 y;
> + s8 z;
> +};
> +
> +struct acpi_mdps {
> + struct acpi_device *device; /* The ACPI device */
> + u32 irq; /* IRQ number */
> + struct input_dev *idev; /* input device */
> + struct task_struct *kthread; /* kthread for input */
> + int xcalib; /* calibrated null value for x */
> + int ycalib; /* calibrated null value for y */
> + int zcalib; /* calibrated null value for z */
> + int is_on; /* whether the device is on or off */
> + struct platform_device *pdev; /* platform device */
> + atomic_t count; /* interrupt count after last read */
> + struct fasync_struct *async_queue;
> + atomic_t available; /* whether the device is open */
> + wait_queue_head_t misc_wait; /* Wait queue for the misc device */
> + /* conversion between hw axis and logical ones */
> + struct axis_conversion ac;
> +};
> +
> +static struct acpi_mdps mdps;
> +
> +static int mdps_remove_fs(void);
> +static int mdps_add_fs(struct acpi_device *device);
> +static void mdps_joystick_enable(void);
> +static void mdps_joystick_disable(void);
> +
> +static struct acpi_device_id mdps_device_ids[] = {
> + {ACPI_MDPS_ID, 0},
> + {"", 0},
> +};
> +MODULE_DEVICE_TABLE(acpi, mdps_device_ids);
> +
> +/** Create a single value from 2 bytes received from the accelerometer
> + * @param hi the high byte
> + * @param lo the low byte
> + * @return the resulting value
> + */
> +static inline s16 mdps_glue_bytes(unsigned long hi, unsigned long lo)
> +{
> + /* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
> + return (s16)((hi << 8) | lo);
> +}
> +
> +/** ACPI ALRD method: read a register
> + * @param handle the handle of the device
> + * @param reg the register to read
> + * @param[out] ret result of the operation
> + * @return AE_OK on success
> + */
> +static acpi_status mdps_ALRD(acpi_handle handle, int reg,
> + unsigned long *ret)
> +{
> + union acpi_object arg0 = { ACPI_TYPE_INTEGER };
> + struct acpi_object_list args = { 1, &arg0 };
> +
> + arg0.integer.value = reg;
> +
> + return acpi_evaluate_integer(handle, "ALRD", &args, ret);
> +}
> +
> +/** ACPI _INI method: initialize the device.
> + * @param handle the handle of the device
> + * @return 0 on success
> + */
> +static inline acpi_status mdps__INI(acpi_handle handle)
> +{
> + return acpi_evaluate_object(handle, METHOD_NAME__INI, NULL, NULL);
> +}
> +
> +/** ACPI ALWR method: write to a register
> + * @param handle the handle of the device
> + * @param reg the register to write to
> + * @param val the value to write
> + * @param[out] ret result of the operation
> + * @return AE_OK on success
> + */
> +static acpi_status mdps_ALWR(acpi_handle handle, int reg, int val,
> + unsigned long *ret)
> +{
> + union acpi_object in_obj[2];
> + struct acpi_object_list args = { 2, in_obj };
> +
> + in_obj[0].type = ACPI_TYPE_INTEGER;
> + in_obj[0].integer.value = reg;
> + in_obj[1].type = ACPI_TYPE_INTEGER;
> + in_obj[1].integer.value = val;
> +
> + return acpi_evaluate_integer(handle, "ALWR", &args, ret);
> +}
> +
> +static int mdps_read_axis(acpi_handle handle, int lo_const, int hi_const)
> +{
> + unsigned long lo_val, hi_val;
> + mdps_ALRD(handle, lo_const, &lo_val);
> + mdps_ALRD(handle, hi_const, &hi_val);
> + return mdps_glue_bytes(hi_val, lo_val);
> +}
> +
> +static inline int mdps_get_axis(s8 axis, int hw_values[3])
> +{
> + if (axis > 0)
> + return hw_values[axis - 1];
> + else
> + return -hw_values[-axis - 1];
> +}
> +
> +/** Get X, Y and Z axis values from the accelerometer
> + * @param handle the handle to the device
> + * @param[out] x where to store the X axis value
> + * @param[out] y where to store the Y axis value
> + * @param[out] z where to store the Z axis value
> + * @note 40Hz input device can eat up about 10% CPU at 800MHZ
> + */
> +static void mdps_get_xyz(acpi_handle handle, int *x, int *y, int *z)
> +{
> + int position[3];
> + position[0] = mdps_read_axis(handle, MDPS_OUTX_L, MDPS_OUTX_H);
> + position[1] = mdps_read_axis(handle, MDPS_OUTY_L, MDPS_OUTY_H);
> + position[2] = mdps_read_axis(handle, MDPS_OUTZ_L, MDPS_OUTZ_H);
> +
> + *x = mdps_get_axis(mdps.ac.x, position);
> + *y = mdps_get_axis(mdps.ac.y, position);
> + *z = mdps_get_axis(mdps.ac.z, position);
> +}
> +
> +/** Kthread polling function
> + * @param data unused - here to conform to threadfn prototype
> + */
> +static int mdps_input_kthread(void *data)
> +{
> + int x, y, z;
> +
> + while (!kthread_should_stop()) {
> + mdps_get_xyz(mdps.device->handle, &x, &y, &z);
> + input_report_abs(mdps.idev, ABS_X, x - mdps.xcalib);
> + input_report_abs(mdps.idev, ABS_Y, y - mdps.ycalib);
> + input_report_abs(mdps.idev, ABS_Z, z - mdps.zcalib);
> +
> + input_sync(mdps.idev);
> +
> + try_to_freeze();
> + msleep_interruptible(MDPS_POLL_INTERVAL);
> + }
> +
> + return 0;
> +}
> +
> +static inline void mdps_poweroff(acpi_handle handle)
> +{
> + unsigned long ret;
> + mdps.is_on = 0;
> + /* disable X,Y,Z axis and power down */
> + mdps_ALWR(handle, MDPS_CTRL_REG1, 0x00, &ret);
> +}
> +
> +static inline void mdps_poweron(acpi_handle handle)
> +{
> + unsigned long val, retw;
> +
> + mdps.is_on = 1;
> + mdps__INI(handle);
> + /*
> + * Change to Block Data Update mode: LSB and MSB values are not updated
> + * until both have been read. So the value read will always be correct.
> + */
> + mdps_ALRD(handle, MDPS_CTRL_REG2, &val);
> + val |= MDPS_BDU;
> + mdps_ALWR(handle, MDPS_CTRL_REG2, val, &retw);
> +}
> +
> +#ifdef CONFIG_PM
> +static int mdps_suspend(struct acpi_device *device, pm_message_t state)
> +{
> + /* make sure the device is off when we suspend */
> + mdps_poweroff(mdps.device->handle);
> + return 0;
> +}
> +#endif
> +
> +static int mdps_resume(struct acpi_device *device)
> +{
> + /* make sure the device went online */
> + mdps_poweron(mdps.device->handle);
> + return 0;
> +}
> +
> +static irqreturn_t mdps_irq(int irq, void *dev_id)
> +{
> + atomic_inc(&mdps.count);
> +
> + wake_up_interruptible(&mdps.misc_wait);
> + kill_fasync(&mdps.async_queue, SIGIO, POLL_IN);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static int mdps_misc_open(struct inode *inode, struct file *file)
> +{
> + int ret;
> +
> + if (!atomic_dec_and_test(&mdps.available)) {
> + atomic_inc(&mdps.available);
> + return -EBUSY; /* already open */
> + }
> +
> + atomic_set(&mdps.count, 0);
> +
> + /* Can't have shared interrupts here, since we have no way
> + * to determine in interrupt context
> + * if it was our device that caused the interrupt */
> + ret = request_irq(mdps.irq, mdps_irq, 0, "mdps", mdps_irq);
> + if (ret) {
> + atomic_inc(&mdps.available);
> + printk(KERN_ERR "mdps: IRQ%d allocation failed\n", mdps.irq);
> + return -ENODEV;
> + }
> +
> + return 0;
> +}
> +
> +static int mdps_misc_release(struct inode *inode, struct file *file)
> +{
> + fasync_helper(-1, file, 0, &mdps.async_queue);
> + free_irq(mdps.irq, mdps_irq);
> + atomic_inc(&mdps.available); /* release the device */
> + return 0;
> +}
> +
> +static ssize_t mdps_misc_read(struct file *file, char __user *buf,
> + size_t count, loff_t *pos)
> +{
> + DECLARE_WAITQUEUE(wait, current);
> + u32 data;
> + ssize_t retval = count;
> +
> + if (count != sizeof(u32))
> + return -EINVAL;
> +
> + add_wait_queue(&mdps.misc_wait, &wait);
> + for (; ; ) {
> + set_current_state(TASK_INTERRUPTIBLE);
> + data = atomic_xchg(&mdps.count, 0);
> + if (data)
> + break;
> +
> + if (file->f_flags & O_NONBLOCK) {
> + retval = -EAGAIN;
> + goto out;
> + }
> +
> + if (signal_pending(current)) {
> + retval = -ERESTARTSYS;
> + goto out;
> + }
> +
> + schedule();
> + }
> +
> + /* make sure we are not going into copy_to_user() with
> + * TASK_INTERRUPTIBLE state */
> + set_current_state(TASK_RUNNING);
> + if (copy_to_user(buf, &data, sizeof(data)))
> + retval = -EFAULT;
> +
> +out:
> + __set_current_state(TASK_RUNNING);
> + remove_wait_queue(&mdps.misc_wait, &wait);
> +
> + return retval;
> +}
> +
> +static unsigned int mdps_misc_poll(struct file *file, poll_table *wait)
> +{
> + poll_wait(file, &mdps.misc_wait, wait);
> + if (atomic_read(&mdps.count))
> + return POLLIN | POLLRDNORM;
> + return 0;
> +}
> +
> +static int mdps_misc_fasync(int fd, struct file *file, int on)
> +{
> + return fasync_helper(fd, file, on, &mdps.async_queue);
> +}
> +
> +static const struct file_operations mdps_misc_fops = {
> + .owner = THIS_MODULE,
> + .llseek = no_llseek,
> + .read = mdps_misc_read,
> + .open = mdps_misc_open,
> + .release = mdps_misc_release,
> + .poll = mdps_misc_poll,
> + .fasync = mdps_misc_fasync,
> +};
> +
> +static struct miscdevice mdps_misc_device = {
> + .minor = MISC_DYNAMIC_MINOR,
> + .name = "accel",
> + .fops = &mdps_misc_fops,
> +};
> +
> +static acpi_status
> +mdps_get_resource(struct acpi_resource *resource, void *context)
> +{
> + if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
> + struct acpi_resource_extended_irq *irq;
> + u32 *device_irq = context;
> +
> + irq = &resource->data.extended_irq;
> + *device_irq = irq->interrupts[0];
> + }
> +
> + return AE_OK;
> +}
> +
> +static void mdps_enum_resources(struct acpi_device *device)
> +{
> + acpi_status status;
> +
> + status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
> + mdps_get_resource, &mdps.irq);
> + if (ACPI_FAILURE(status))
> + printk(KERN_DEBUG "mdps: Error getting resources\n");
> +}
> +
> +static int mdps_dmi_matched(const struct dmi_system_id *dmi)
> +{
> + mdps.ac = *(struct axis_conversion *)dmi->driver_data;
> + printk(KERN_INFO "mdps: hardware type %s found.\n", dmi->ident);
> +
> + return 1;
> +}
> +
> +
> +/* Represents, for each axis seen by userspace, the corresponding hw axis (+1).
> + * If the value is negative, the opposite of the hw value is used. */
> +static struct axis_conversion mdps_axis_normal = {1, 2, 3};
> +static struct axis_conversion mdps_axis_y_inverted = {1, -2, 3};
> +static struct axis_conversion mdps_axis_x_inverted = {-1, 2, 3};
> +
> +static struct dmi_system_id mdps_dmi_ids[] = {
> + {
> + .callback = mdps_dmi_matched,
> + .ident = "NC64x0",
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nc64"),
> + },
> + .driver_data = &mdps_axis_x_inverted
> + },
> + {
> + .callback = mdps_dmi_matched,
> + .ident = "NX9420",
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx9420"),
> + },
> + .driver_data = &mdps_axis_x_inverted
> + },
> + {
> + .callback = mdps_dmi_matched,
> + .ident = "NW9440",
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nw9440"),
> + },
> + .driver_data = &mdps_axis_x_inverted
> + },
> + {
> + .callback = mdps_dmi_matched,
> + .ident = "NC2510",
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 2510"),
> + },
> + .driver_data = &mdps_axis_y_inverted
> + },
> + { NULL, }
> +/* Laptop models without axis info (yet):
> + * "NC84x0" "HP Compaq nc84"
> + * "NC651xx" "HP Compaq 651"
> + * "NC671xx" "HP Compaq 671"
> + * "NC6910" "HP Compaq 6910"
> + * HP Compaq 8510x Notebook PC / Mobile Workstation
> + * HP Compaq 8710x Notebook PC / Mobile Workstation
> + * "NC2400" "HP Compaq nc2400"
> + * "NX74x0" "HP Compaq nx74"
> + * "NX6325" "HP Compaq nx6325"
> + * "NC4400" "HP Compaq nc4400"
> + */
> +};
> +
> +static int mdps_add(struct acpi_device *device)
> +{
> + unsigned long val;
> + int ret;
> +
> + if (!device)
> + return -EINVAL;
> +
> + mdps.device = device;
> + strcpy(acpi_device_name(device), DRIVER_NAME);
> + strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
> + acpi_driver_data(device) = &mdps;
> +
> + mdps_ALRD(device->handle, MDPS_WHO_AM_I, &val);
> + if (val != MDPS_ID) {
> + printk(KERN_ERR
> + "mdps: Accelerometer chip not LIS3LV02D{L,Q}\n");
> + return -ENODEV;
> + }
> +
> + /* This is just to make sure that the same physical move
> + * is reported identically */
> + if (dmi_check_system(mdps_dmi_ids) == 0) {
> + printk(KERN_INFO "mdps: laptop model unknown, "
> + "using default axes configuration\n");
> + mdps.ac = mdps_axis_normal;
> + }
> +
> + mdps_add_fs(device);
> + mdps_resume(device);
> +
> + mdps_joystick_enable();
> +
> + /* obtain IRQ number of our device from ACPI */
> + mdps_enum_resources(device);
> +
> + if (power_off) /* see if user wanted to power off the device on load */
> + mdps_poweroff(mdps.device->handle);
> +
> + /* if we did not get an IRQ from ACPI - we have nothing more to do */
> + if (!mdps.irq) {
> + printk(KERN_INFO
> + "mdps: No IRQ in ACPI. Disabling /dev/accel\n");
> + return 0;
> + }
> +
> + atomic_set(&mdps.available, 1); /* init the misc device open count */
> + init_waitqueue_head(&mdps.misc_wait);
> +
> + ret = misc_register(&mdps_misc_device);
> + if (ret)
> + printk(KERN_ERR "mdps: misc_register failed\n");
> +
> + return 0;
> +}
> +
> +static int mdps_remove(struct acpi_device *device, int type)
> +{
> + if (!device)
> + return -EINVAL;
> +
> + if (mdps.irq)
> + misc_deregister(&mdps_misc_device);
> +
> + mdps_joystick_disable();
> +
> + return mdps_remove_fs();
> +}
> +
> +static inline void mdps_calibrate_joystick(void)
> +{
> + mdps_get_xyz(mdps.device->handle, &mdps.xcalib, &mdps.ycalib,
> + &mdps.zcalib);
> +}
> +
> +static int mdps_joystick_open(struct input_dev *dev)
> +{
> + mdps.kthread = kthread_run(mdps_input_kthread, NULL, "kmdps");
> + if (IS_ERR(mdps.kthread))
> + return PTR_ERR(mdps.kthread);
> +
> + return 0;
> +}
> +
> +static void mdps_joystick_close(struct input_dev *dev)
> +{
> + kthread_stop(mdps.kthread);
> +}
> +
> +static void mdps_joystick_enable(void)
> +{
> + if (mdps.idev)
> + return;
> +
> + mdps.idev = input_allocate_device();
> + if (!mdps.idev)
> + return;
> +
> + mdps_calibrate_joystick();
> +
> + mdps.idev->name = "HP Mobile Data Protection System";
> + mdps.idev->phys = "mdps/input0";
> + mdps.idev->id.bustype = BUS_HOST;
> + mdps.idev->id.vendor = 0;
> + mdps.idev->dev.parent = &mdps.pdev->dev;
> +
> + set_bit(EV_ABS, mdps.idev->evbit);
> +
> + input_set_abs_params(mdps.idev, ABS_X, -MDPS_MAX_VAL, MDPS_MAX_VAL,
> + 3, 0);
> + input_set_abs_params(mdps.idev, ABS_Y, -MDPS_MAX_VAL, MDPS_MAX_VAL,
> + 3, 0);
> + input_set_abs_params(mdps.idev, ABS_Z, -MDPS_MAX_VAL, MDPS_MAX_VAL,
> + 3, 0);
> +
> + mdps.idev->open = mdps_joystick_open;
> + mdps.idev->close = mdps_joystick_close;
> +
> + if (input_register_device(mdps.idev)) {
> + input_free_device(mdps.idev);
> + mdps.idev = NULL;
> + }
> +}
> +
> +static void mdps_joystick_disable(void)
> +{
> + if (!mdps.idev)
> + return;
> +
> + input_unregister_device(mdps.idev);
> + mdps.idev = NULL;
> +}
> +
> +/* Sysfs stuff */
> +static ssize_t mdps_position_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + int x, y, z;
> + mdps_get_xyz(mdps.device->handle, &x, &y, &z);
> +
> + return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
> +}
> +
> +static ssize_t mdps_state_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + return sprintf(buf, "%s\n", (mdps.is_on ? "on" : "off"));
> +}
> +
> +static ssize_t mdps_calibrate_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + return sprintf(buf, "(%d,%d,%d)\n", mdps.xcalib, mdps.ycalib,
> + mdps.zcalib);
> +}
> +
> +static ssize_t mdps_calibrate_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t count)
> +{
> + mdps_calibrate_joystick();
> + return count;
> +}
> +
> +static ssize_t mdps_rate_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + unsigned long ctrl;
> + int rate = 0;
> +
> + mdps_ALRD(mdps.device->handle, MDPS_CTRL_REG1, &ctrl);
> +
> + /* get the sampling rate of the accelerometer in HZ */
> + switch ((ctrl & 0x30) >> 4) {
> + case 00:
> + rate = 40;
> + break;
> +
> + case 01:
> + rate = 160;
> + break;
> +
> + case 02:
> + rate = 640;
> + break;
> +
> + case 03:
> + rate = 2560;
> + break;
> + }
> +
> + return sprintf(buf, "%d\n", rate);
> +}
> +
> +static ssize_t mdps_state_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t count)
> +{
> + int state;
> + if (sscanf(buf, "%d", &state) != 1 || (state != 1 && state != 0))
> + return -EINVAL;
> +
> + mdps.is_on = state;
> +
> + if (mdps.is_on)
> + mdps_poweron(mdps.device->handle);
> + else
> + mdps_poweroff(mdps.device->handle);
> +
> + return count;
> +}
> +
> +static DEVICE_ATTR(position, S_IRUGO, mdps_position_show, NULL);
> +static DEVICE_ATTR(calibrate, S_IRUGO|S_IWUSR, mdps_calibrate_show,
> + mdps_calibrate_store);
> +static DEVICE_ATTR(rate, S_IRUGO, mdps_rate_show, NULL);
> +static DEVICE_ATTR(state, S_IRUGO|S_IWUSR, mdps_state_show, mdps_state_store);
> +
> +static struct attribute *mdps_attributes[] = {
> + &dev_attr_position.attr,
> + &dev_attr_calibrate.attr,
> + &dev_attr_rate.attr,
> + &dev_attr_state.attr,
> + NULL
> +};
> +
> +static struct attribute_group mdps_attribute_group = {
> + .attrs = mdps_attributes
> +};
> +
> +static int mdps_add_fs(struct acpi_device *device)
> +{
> + mdps.pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
> + if (IS_ERR(mdps.pdev))
> + return PTR_ERR(mdps.pdev);
> +
> + return sysfs_create_group(&mdps.pdev->dev.kobj, &mdps_attribute_group);
> +}
> +
> +static int mdps_remove_fs(void)
> +{
> + sysfs_remove_group(&mdps.pdev->dev.kobj, &mdps_attribute_group);
> + platform_device_unregister(mdps.pdev);
> + return 0;
> +}
> +
> +static struct acpi_driver mdps_driver = {
> + .name = DRIVER_NAME,
> + .class = ACPI_MDPS_CLASS,
> + .ids = mdps_device_ids,
> + .ops = {
> + .add = mdps_add,
> + .remove = mdps_remove,
> +#ifdef CONFIG_PM
> + .suspend = mdps_suspend,
> + .resume = mdps_resume
> +#endif
> + }
> +};
> +
> +static int __init mdps_init_module(void)
> +{
> + int ret;
> +
> + if (acpi_disabled)
> + return -ENODEV;
> +
> + ret = acpi_bus_register_driver(&mdps_driver);
> + if (ret < 0)
> + return ret;
> +
> + printk(KERN_INFO "mdps version " VERSION " loaded.\n");
> +
> + return 0;
> +}
> +
> +static void __exit mdps_exit_module(void)
> +{
> + acpi_bus_unregister_driver(&mdps_driver);
> +}
> +
> +MODULE_DESCRIPTION("HP three-axis digital accelerometer ACPI driver");
> +MODULE_AUTHOR("Yan Burman (burman.yan@gmail.com)");
> +MODULE_VERSION(VERSION);
> +MODULE_LICENSE("GPL");
> +
> +module_init(mdps_init_module);
> +module_exit(mdps_exit_module);
>
>
> _______________________________________________
> lm-sensors mailing list
> lm-sensors@lm-sensors.org
> http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
>



\
 
 \ /
  Last update: 2008-06-05 09:53    [W:0.178 / U:0.724 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site