hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

hp_accel: adev is poor name of exported symbol 

As Andrew noted, adev is pretty poor name for symbol being exported.
Rename it to lis3.

Signed-off-by: Pavel Machek <pavel@ucw.cz>
Cc: Eric Piel <eric.piel@tremplin-utc.net>
Cc: Vladimir Botka <vbotka@suse.cz>
Cc: <Quoc.Pham@hp.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Pavel Machek 2009-03-31 15:24:26 -07:00 committed by Linus Torvalds
parent 2b872903c5
commit be84cfc588
3 changed files with 116 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
drivers/hwmon/hp_accel.c
View File

@ -140,7 +140,7 @@ acpi_status lis3lv02d_acpi_write(acpi_handle handle, int reg, u8 val)
static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi) static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi)
{ {
adev.ac = *((struct axis_conversion *)dmi->driver_data); lis3_dev.ac = *((struct axis_conversion *)dmi->driver_data);
printk(KERN_INFO DRIVER_NAME ": hardware type %s found.\n", dmi->ident); printk(KERN_INFO DRIVER_NAME ": hardware type %s found.\n", dmi->ident);
return 1; return 1;
@ -214,7 +214,7 @@ static struct dmi_system_id lis3lv02d_dmi_ids[] = {
static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value) static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value)
{ {
acpi_handle handle = adev.device->handle; acpi_handle handle = lis3_dev.device->handle;
unsigned long long ret; /* Not used when writing */ unsigned long long ret; /* Not used when writing */
union acpi_object in_obj[1]; union acpi_object in_obj[1];
struct acpi_object_list args = { 1, in_obj }; struct acpi_object_list args = { 1, in_obj };
@ -254,7 +254,7 @@ static void lis3lv02d_enum_resources(struct acpi_device *device)
acpi_status status; acpi_status status;
status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
lis3lv02d_get_resource, &adev.irq); lis3lv02d_get_resource, &lis3_dev.irq);
if (ACPI_FAILURE(status)) if (ACPI_FAILURE(status))
printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n"); printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n");
} }
@ -263,8 +263,8 @@ static s16 lis3lv02d_read_16(acpi_handle handle, int reg)
{ {
u8 lo, hi; u8 lo, hi;
adev.read(handle, reg - 1, &lo); lis3_dev.read(handle, reg - 1, &lo);
adev.read(handle, reg, &hi); lis3_dev.read(handle, reg, &hi);
/* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */ /* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
return (s16)((hi << 8) | lo); return (s16)((hi << 8) | lo);
} }
@ -272,7 +272,7 @@ static s16 lis3lv02d_read_16(acpi_handle handle, int reg)
static s16 lis3lv02d_read_8(acpi_handle handle, int reg) static s16 lis3lv02d_read_8(acpi_handle handle, int reg)
{ {
s8 lo; s8 lo;
adev.read(handle, reg, &lo); lis3_dev.read(handle, reg, &lo);
return lo; return lo;
} }
@ -283,29 +283,29 @@ static int lis3lv02d_add(struct acpi_device *device)
if (!device) if (!device)
return -EINVAL; return -EINVAL;
adev.device = device; lis3_dev.device = device;
adev.init = lis3lv02d_acpi_init; lis3_dev.init = lis3lv02d_acpi_init;
adev.read = lis3lv02d_acpi_read; lis3_dev.read = lis3lv02d_acpi_read;
adev.write = lis3lv02d_acpi_write; lis3_dev.write = lis3lv02d_acpi_write;
strcpy(acpi_device_name(device), DRIVER_NAME); strcpy(acpi_device_name(device), DRIVER_NAME);
strcpy(acpi_device_class(device), ACPI_MDPS_CLASS); strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
device->driver_data = &adev; device->driver_data = &lis3_dev;
lis3lv02d_acpi_read(device->handle, WHO_AM_I, &adev.whoami); lis3lv02d_acpi_read(device->handle, WHO_AM_I, &lis3_dev.whoami);
switch (adev.whoami) { switch (lis3_dev.whoami) {
case LIS_DOUBLE_ID: case LIS_DOUBLE_ID:
printk(KERN_INFO DRIVER_NAME ": 2-byte sensor found\n"); printk(KERN_INFO DRIVER_NAME ": 2-byte sensor found\n");
adev.read_data = lis3lv02d_read_16; lis3_dev.read_data = lis3lv02d_read_16;
adev.mdps_max_val = 2048; lis3_dev.mdps_max_val = 2048;
break; break;
case LIS_SINGLE_ID: case LIS_SINGLE_ID:
printk(KERN_INFO DRIVER_NAME ": 1-byte sensor found\n"); printk(KERN_INFO DRIVER_NAME ": 1-byte sensor found\n");
adev.read_data = lis3lv02d_read_8; lis3_dev.read_data = lis3lv02d_read_8;
adev.mdps_max_val = 128; lis3_dev.mdps_max_val = 128;
break; break;
default: default:
printk(KERN_ERR DRIVER_NAME printk(KERN_ERR DRIVER_NAME
": unknown sensor type 0x%X\n", adev.whoami); ": unknown sensor type 0x%X\n", lis3_dev.whoami);
return -EINVAL; return -EINVAL;
} }
@ -313,7 +313,7 @@ static int lis3lv02d_add(struct acpi_device *device)
if (dmi_check_system(lis3lv02d_dmi_ids) == 0) { if (dmi_check_system(lis3lv02d_dmi_ids) == 0) {
printk(KERN_INFO DRIVER_NAME ": laptop model unknown, " printk(KERN_INFO DRIVER_NAME ": laptop model unknown, "
"using default axes configuration\n"); "using default axes configuration\n");
adev.ac = lis3lv02d_axis_normal; lis3_dev.ac = lis3lv02d_axis_normal;
} }
INIT_WORK(&hpled_led.work, delayed_set_status_worker); INIT_WORK(&hpled_led.work, delayed_set_status_worker);
@ -322,9 +322,9 @@ static int lis3lv02d_add(struct acpi_device *device)
return ret; return ret;
/* obtain IRQ number of our device from ACPI */ /* obtain IRQ number of our device from ACPI */
lis3lv02d_enum_resources(adev.device); lis3lv02d_enum_resources(lis3_dev.device);
ret = lis3lv02d_init_device(&adev); ret = lis3lv02d_init_device(&lis3_dev);
if (ret) { if (ret) {
flush_work(&hpled_led.work); flush_work(&hpled_led.work);
led_classdev_unregister(&hpled_led.led_classdev); led_classdev_unregister(&hpled_led.led_classdev);
@ -360,12 +360,12 @@ static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state)
static int lis3lv02d_resume(struct acpi_device *device) static int lis3lv02d_resume(struct acpi_device *device)
{ {
/* put back the device in the right state (ACPI might turn it on) */ /* put back the device in the right state (ACPI might turn it on) */
mutex_lock(&adev.lock); mutex_lock(&lis3_dev.lock);
if (adev.usage > 0) if (lis3_dev.usage > 0)
lis3lv02d_poweron(device->handle); lis3lv02d_poweron(device->handle);
else else
lis3lv02d_poweroff(device->handle); lis3lv02d_poweroff(device->handle);
mutex_unlock(&adev.lock); mutex_unlock(&lis3_dev.lock);
return 0; return 0;
} }
#else #else

172
drivers/hwmon/lis3lv02d.c
View File

@ -53,14 +53,24 @@
* joystick. * joystick.
*/ */
struct acpi_lis3lv02d adev = { struct acpi_lis3lv02d lis3_dev = {
.misc_wait = __WAIT_QUEUE_HEAD_INITIALIZER(adev.misc_wait), .misc_wait = __WAIT_QUEUE_HEAD_INITIALIZER(lis3_dev.misc_wait),
}; };
EXPORT_SYMBOL_GPL(adev); EXPORT_SYMBOL_GPL(lis3_dev);
static int lis3lv02d_add_fs(struct acpi_device *device); static int lis3lv02d_add_fs(struct acpi_device *device);
static s16 lis3lv02d_read_16(acpi_handle handle, int reg)
{
u8 lo, hi;
lis3_dev.read(handle, reg, &lo);
lis3_dev.read(handle, reg + 1, &hi);
/* In "12 bit right justified" mode, bit 6, bit 7, bit 8 = bit 5 */
return (s16)((hi << 8) | lo);
}
/** /**
* lis3lv02d_get_axis - For the given axis, give the value converted * lis3lv02d_get_axis - For the given axis, give the value converted
* @axis: 1,2,3 - can also be negative * @axis: 1,2,3 - can also be negative
@ -89,25 +99,25 @@ static void lis3lv02d_get_xyz(acpi_handle handle, int *x, int *y, int *z)
{ {
int position[3]; int position[3];
position[0] = adev.read_data(handle, OUTX); position[0] = lis3_dev.read_data(handle, OUTX);
position[1] = adev.read_data(handle, OUTY); position[1] = lis3_dev.read_data(handle, OUTY);
position[2] = adev.read_data(handle, OUTZ); position[2] = lis3_dev.read_data(handle, OUTZ);
*x = lis3lv02d_get_axis(adev.ac.x, position); *x = lis3lv02d_get_axis(lis3_dev.ac.x, position);
*y = lis3lv02d_get_axis(adev.ac.y, position); *y = lis3lv02d_get_axis(lis3_dev.ac.y, position);
*z = lis3lv02d_get_axis(adev.ac.z, position); *z = lis3lv02d_get_axis(lis3_dev.ac.z, position);
} }
void lis3lv02d_poweroff(acpi_handle handle) void lis3lv02d_poweroff(acpi_handle handle)
{ {
adev.is_on = 0; lis3_dev.is_on = 0;
} }
EXPORT_SYMBOL_GPL(lis3lv02d_poweroff); EXPORT_SYMBOL_GPL(lis3lv02d_poweroff);
void lis3lv02d_poweron(acpi_handle handle) void lis3lv02d_poweron(acpi_handle handle)
{ {
adev.is_on = 1; lis3_dev.is_on = 1;
adev.init(handle); lis3_dev.init(handle);
} }
EXPORT_SYMBOL_GPL(lis3lv02d_poweron); EXPORT_SYMBOL_GPL(lis3lv02d_poweron);
@ -147,10 +157,10 @@ static irqreturn_t lis302dl_interrupt(int irq, void *dummy)
* the lid is closed. This leads to interrupts as soon as a little move * the lid is closed. This leads to interrupts as soon as a little move
* is done. * is done.
*/ */
atomic_inc(&adev.count); atomic_inc(&lis3_dev.count);
wake_up_interruptible(&adev.misc_wait); wake_up_interruptible(&lis3_dev.misc_wait);
kill_fasync(&adev.async_queue, SIGIO, POLL_IN); kill_fasync(&lis3_dev.async_queue, SIGIO, POLL_IN);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -158,10 +168,10 @@ static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
{ {
int ret; int ret;
if (test_and_set_bit(0, &adev.misc_opened)) if (test_and_set_bit(0, &lis3_dev.misc_opened))
return -EBUSY; /* already open */ return -EBUSY; /* already open */
atomic_set(&adev.count, 0); atomic_set(&lis3_dev.count, 0);
/* /*
* The sensor can generate interrupts for free-fall and direction * The sensor can generate interrupts for free-fall and direction
@ -174,25 +184,25 @@ static int lis3lv02d_misc_open(struct inode *inode, struct file *file)
* io-apic is not configurable (and generates a warning) but I keep it * io-apic is not configurable (and generates a warning) but I keep it
* in case of support for other hardware. * in case of support for other hardware.
*/ */
ret = request_irq(adev.irq, lis302dl_interrupt, IRQF_TRIGGER_RISING, ret = request_irq(lis3_dev.irq, lis302dl_interrupt, IRQF_TRIGGER_RISING,
DRIVER_NAME, &adev); DRIVER_NAME, &lis3_dev);
if (ret) { if (ret) {
clear_bit(0, &adev.misc_opened); clear_bit(0, &lis3_dev.misc_opened);
printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", adev.irq); printk(KERN_ERR DRIVER_NAME ": IRQ%d allocation failed\n", lis3_dev.irq);
return -EBUSY; return -EBUSY;
} }
lis3lv02d_increase_use(&adev); lis3lv02d_increase_use(&lis3_dev);
printk("lis3: registered interrupt %d\n", adev.irq); printk("lis3: registered interrupt %d\n", lis3_dev.irq);
return 0; return 0;
} }
static int lis3lv02d_misc_release(struct inode *inode, struct file *file) static int lis3lv02d_misc_release(struct inode *inode, struct file *file)
{ {
fasync_helper(-1, file, 0, &adev.async_queue); fasync_helper(-1, file, 0, &lis3_dev.async_queue);
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
free_irq(adev.irq, &adev); free_irq(lis3_dev.irq, &lis3_dev);
clear_bit(0, &adev.misc_opened); /* release the device */ clear_bit(0, &lis3_dev.misc_opened); /* release the device */
return 0; return 0;
} }
@ -207,10 +217,10 @@ static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
if (count < 1) if (count < 1)
return -EINVAL; return -EINVAL;
add_wait_queue(&adev.misc_wait, &wait); add_wait_queue(&lis3_dev.misc_wait, &wait);
while (true) { while (true) {
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
data = atomic_xchg(&adev.count, 0); data = atomic_xchg(&lis3_dev.count, 0);
if (data) if (data)
break; break;
@ -240,22 +250,22 @@ static ssize_t lis3lv02d_misc_read(struct file *file, char __user *buf,
out: out:
__set_current_state(TASK_RUNNING); __set_current_state(TASK_RUNNING);
remove_wait_queue(&adev.misc_wait, &wait); remove_wait_queue(&lis3_dev.misc_wait, &wait);
return retval; return retval;
} }
static unsigned int lis3lv02d_misc_poll(struct file *file, poll_table *wait) static unsigned int lis3lv02d_misc_poll(struct file *file, poll_table *wait)
{ {
poll_wait(file, &adev.misc_wait, wait); poll_wait(file, &lis3_dev.misc_wait, wait);
if (atomic_read(&adev.count)) if (atomic_read(&lis3_dev.count))
return POLLIN | POLLRDNORM; return POLLIN | POLLRDNORM;
return 0; return 0;
} }
static int lis3lv02d_misc_fasync(int fd, struct file *file, int on) static int lis3lv02d_misc_fasync(int fd, struct file *file, int on)
{ {
return fasync_helper(fd, file, on, &adev.async_queue); return fasync_helper(fd, file, on, &lis3_dev.async_queue);
} }
static const struct file_operations lis3lv02d_misc_fops = { static const struct file_operations lis3lv02d_misc_fops = {
@ -283,12 +293,12 @@ static int lis3lv02d_joystick_kthread(void *data)
int x, y, z; int x, y, z;
while (!kthread_should_stop()) { while (!kthread_should_stop()) {
lis3lv02d_get_xyz(adev.device->handle, &x, &y, &z); lis3lv02d_get_xyz(lis3_dev.device->handle, &x, &y, &z);
input_report_abs(adev.idev, ABS_X, x - adev.xcalib); input_report_abs(lis3_dev.idev, ABS_X, x - lis3_dev.xcalib);
input_report_abs(adev.idev, ABS_Y, y - adev.ycalib); input_report_abs(lis3_dev.idev, ABS_Y, y - lis3_dev.ycalib);
input_report_abs(adev.idev, ABS_Z, z - adev.zcalib); input_report_abs(lis3_dev.idev, ABS_Z, z - lis3_dev.zcalib);
input_sync(adev.idev); input_sync(lis3_dev.idev);
try_to_freeze(); try_to_freeze();
msleep_interruptible(MDPS_POLL_INTERVAL); msleep_interruptible(MDPS_POLL_INTERVAL);
@ -299,11 +309,11 @@ static int lis3lv02d_joystick_kthread(void *data)
static int lis3lv02d_joystick_open(struct input_dev *input) static int lis3lv02d_joystick_open(struct input_dev *input)
{ {
lis3lv02d_increase_use(&adev); lis3lv02d_increase_use(&lis3_dev);
adev.kthread = kthread_run(lis3lv02d_joystick_kthread, NULL, "klis3lv02d"); lis3_dev.kthread = kthread_run(lis3lv02d_joystick_kthread, NULL, "klis3lv02d");
if (IS_ERR(adev.kthread)) { if (IS_ERR(lis3_dev.kthread)) {
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
return PTR_ERR(adev.kthread); return PTR_ERR(lis3_dev.kthread);
} }
return 0; return 0;
@ -311,45 +321,45 @@ static int lis3lv02d_joystick_open(struct input_dev *input)
static void lis3lv02d_joystick_close(struct input_dev *input) static void lis3lv02d_joystick_close(struct input_dev *input)
{ {
kthread_stop(adev.kthread); kthread_stop(lis3_dev.kthread);
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
} }
static inline void lis3lv02d_calibrate_joystick(void) static inline void lis3lv02d_calibrate_joystick(void)
{ {
lis3lv02d_get_xyz(adev.device->handle, &adev.xcalib, &adev.ycalib, &adev.zcalib); lis3lv02d_get_xyz(lis3_dev.device->handle, &lis3_dev.xcalib, &lis3_dev.ycalib, &lis3_dev.zcalib);
} }
int lis3lv02d_joystick_enable(void) int lis3lv02d_joystick_enable(void)
{ {
int err; int err;
if (adev.idev) if (lis3_dev.idev)
return -EINVAL; return -EINVAL;
adev.idev = input_allocate_device(); lis3_dev.idev = input_allocate_device();
if (!adev.idev) if (!lis3_dev.idev)
return -ENOMEM; return -ENOMEM;
lis3lv02d_calibrate_joystick(); lis3lv02d_calibrate_joystick();
adev.idev->name = "ST LIS3LV02DL Accelerometer"; lis3_dev.idev->name = "ST LIS3LV02DL Accelerometer";
adev.idev->phys = DRIVER_NAME "/input0"; lis3_dev.idev->phys = DRIVER_NAME "/input0";
adev.idev->id.bustype = BUS_HOST; lis3_dev.idev->id.bustype = BUS_HOST;
adev.idev->id.vendor = 0; lis3_dev.idev->id.vendor = 0;
adev.idev->dev.parent = &adev.pdev->dev; lis3_dev.idev->dev.parent = &lis3_dev.pdev->dev;
adev.idev->open = lis3lv02d_joystick_open; lis3_dev.idev->open = lis3lv02d_joystick_open;
adev.idev->close = lis3lv02d_joystick_close; lis3_dev.idev->close = lis3lv02d_joystick_close;
set_bit(EV_ABS, adev.idev->evbit); set_bit(EV_ABS, lis3_dev.idev->evbit);
input_set_abs_params(adev.idev, ABS_X, -adev.mdps_max_val, adev.mdps_max_val, 3, 3); input_set_abs_params(lis3_dev.idev, ABS_X, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
input_set_abs_params(adev.idev, ABS_Y, -adev.mdps_max_val, adev.mdps_max_val, 3, 3); input_set_abs_params(lis3_dev.idev, ABS_Y, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
input_set_abs_params(adev.idev, ABS_Z, -adev.mdps_max_val, adev.mdps_max_val, 3, 3); input_set_abs_params(lis3_dev.idev, ABS_Z, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
err = input_register_device(adev.idev); err = input_register_device(lis3_dev.idev);
if (err) { if (err) {
input_free_device(adev.idev); input_free_device(lis3_dev.idev);
adev.idev = NULL; lis3_dev.idev = NULL;
} }
return err; return err;
@ -358,12 +368,12 @@ EXPORT_SYMBOL_GPL(lis3lv02d_joystick_enable);
void lis3lv02d_joystick_disable(void) void lis3lv02d_joystick_disable(void)
{ {
if (!adev.idev) if (!lis3_dev.idev)
return; return;
misc_deregister(&lis3lv02d_misc_device); misc_deregister(&lis3lv02d_misc_device);
input_unregister_device(adev.idev); input_unregister_device(lis3_dev.idev);
adev.idev = NULL; lis3_dev.idev = NULL;
} }
EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable); EXPORT_SYMBOL_GPL(lis3lv02d_joystick_disable);
@ -404,25 +414,25 @@ static ssize_t lis3lv02d_position_show(struct device *dev,
{ {
int x, y, z; int x, y, z;
lis3lv02d_increase_use(&adev); lis3lv02d_increase_use(&lis3_dev);
lis3lv02d_get_xyz(adev.device->handle, &x, &y, &z); lis3lv02d_get_xyz(lis3_dev.device->handle, &x, &y, &z);
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
return sprintf(buf, "(%d,%d,%d)\n", x, y, z); return sprintf(buf, "(%d,%d,%d)\n", x, y, z);
} }
static ssize_t lis3lv02d_calibrate_show(struct device *dev, static ssize_t lis3lv02d_calibrate_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
return sprintf(buf, "(%d,%d,%d)\n", adev.xcalib, adev.ycalib, adev.zcalib); return sprintf(buf, "(%d,%d,%d)\n", lis3_dev.xcalib, lis3_dev.ycalib, lis3_dev.zcalib);
} }
static ssize_t lis3lv02d_calibrate_store(struct device *dev, static ssize_t lis3lv02d_calibrate_store(struct device *dev,
struct device_attribute *attr, struct device_attribute *attr,
const char *buf, size_t count) const char *buf, size_t count)
{ {
lis3lv02d_increase_use(&adev); lis3lv02d_increase_use(&lis3_dev);
lis3lv02d_calibrate_joystick(); lis3lv02d_calibrate_joystick();
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
return count; return count;
} }
@ -434,9 +444,9 @@ static ssize_t lis3lv02d_rate_show(struct device *dev,
u8 ctrl; u8 ctrl;
int val; int val;
lis3lv02d_increase_use(&adev); lis3lv02d_increase_use(&lis3_dev);
adev.read(adev.device->handle, CTRL_REG1, &ctrl); lis3_dev.read(lis3_dev.device->handle, CTRL_REG1, &ctrl);
lis3lv02d_decrease_use(&adev); lis3lv02d_decrease_use(&lis3_dev);
val = (ctrl & (CTRL1_DF0 | CTRL1_DF1)) >> 4; val = (ctrl & (CTRL1_DF0 | CTRL1_DF1)) >> 4;
return sprintf(buf, "%d\n", lis3lv02dl_df_val[val]); return sprintf(buf, "%d\n", lis3lv02dl_df_val[val]);
} }
@ -460,17 +470,17 @@ static struct attribute_group lis3lv02d_attribute_group = {
static int lis3lv02d_add_fs(struct acpi_device *device) static int lis3lv02d_add_fs(struct acpi_device *device)
{ {
adev.pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0); lis3_dev.pdev = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
if (IS_ERR(adev.pdev)) if (IS_ERR(lis3_dev.pdev))
return PTR_ERR(adev.pdev); return PTR_ERR(lis3_dev.pdev);
return sysfs_create_group(&adev.pdev->dev.kobj, &lis3lv02d_attribute_group); return sysfs_create_group(&lis3_dev.pdev->dev.kobj, &lis3lv02d_attribute_group);
} }
int lis3lv02d_remove_fs(void) int lis3lv02d_remove_fs(void)
{ {
sysfs_remove_group(&adev.pdev->dev.kobj, &lis3lv02d_attribute_group); sysfs_remove_group(&lis3_dev.pdev->dev.kobj, &lis3lv02d_attribute_group);
platform_device_unregister(adev.pdev); platform_device_unregister(lis3_dev.pdev);
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs); EXPORT_SYMBOL_GPL(lis3lv02d_remove_fs);

2
drivers/hwmon/lis3lv02d.h
View File

@ -194,4 +194,4 @@ void lis3lv02d_poweroff(acpi_handle handle);
void lis3lv02d_poweron(acpi_handle handle); void lis3lv02d_poweron(acpi_handle handle);
int lis3lv02d_remove_fs(void); int lis3lv02d_remove_fs(void);
extern struct acpi_lis3lv02d adev; extern struct acpi_lis3lv02d lis3_dev;