Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 53ab0e6888925ae3ebe931c060120b0f11c1923c

Authored by Joe Perches
Committed by Guenter Roeck
1 parent 22d3b41281
Exists in master and in 39 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

hwmon: (hp_accel) Use pr_fmt and pr_<level> 

Added #define pr_fmt KBUILD_MODNAME ": " fmt
Converted printks to pr_<level>
Coalesced any long formats
Removed prefixes from formats

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Guenter Roeck <guenter.roeck@ericsson.com>

Showing 1 changed file with 7 additions and 6 deletions Inline Diff

drivers/hwmon/hp_accel.c
Diff comments   View file @ 53ab0e6
1 /* 1 /*
2 * hp_accel.c - Interface between LIS3LV02DL driver and HP ACPI BIOS 2 * hp_accel.c - Interface between LIS3LV02DL driver and HP ACPI BIOS
3 * 3 *
4 * Copyright (C) 2007-2008 Yan Burman 4 * Copyright (C) 2007-2008 Yan Burman
5 * Copyright (C) 2008 Eric Piel 5 * Copyright (C) 2008 Eric Piel
6 * Copyright (C) 2008-2009 Pavel Machek 6 * Copyright (C) 2008-2009 Pavel Machek
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */ 21 */
22 22
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
23 #include <linux/kernel.h> 25 #include <linux/kernel.h>
24 #include <linux/init.h> 26 #include <linux/init.h>
25 #include <linux/dmi.h> 27 #include <linux/dmi.h>
26 #include <linux/module.h> 28 #include <linux/module.h>
27 #include <linux/types.h> 29 #include <linux/types.h>
28 #include <linux/platform_device.h> 30 #include <linux/platform_device.h>
29 #include <linux/interrupt.h> 31 #include <linux/interrupt.h>
30 #include <linux/delay.h> 32 #include <linux/delay.h>
31 #include <linux/wait.h> 33 #include <linux/wait.h>
32 #include <linux/poll.h> 34 #include <linux/poll.h>
33 #include <linux/freezer.h> 35 #include <linux/freezer.h>
34 #include <linux/uaccess.h> 36 #include <linux/uaccess.h>
35 #include <linux/leds.h> 37 #include <linux/leds.h>
36 #include <acpi/acpi_drivers.h> 38 #include <acpi/acpi_drivers.h>
37 #include <asm/atomic.h> 39 #include <asm/atomic.h>
38 #include "lis3lv02d.h" 40 #include "lis3lv02d.h"
39 41
40 #define DRIVER_NAME "lis3lv02d" 42 #define DRIVER_NAME "lis3lv02d"
41 #define ACPI_MDPS_CLASS "accelerometer" 43 #define ACPI_MDPS_CLASS "accelerometer"
42 44
43 /* Delayed LEDs infrastructure ------------------------------------ */ 45 /* Delayed LEDs infrastructure ------------------------------------ */
44 46
45 /* Special LED class that can defer work */ 47 /* Special LED class that can defer work */
46 struct delayed_led_classdev { 48 struct delayed_led_classdev {
47 struct led_classdev led_classdev; 49 struct led_classdev led_classdev;
48 struct work_struct work; 50 struct work_struct work;
49 enum led_brightness new_brightness; 51 enum led_brightness new_brightness;
50 52
51 unsigned int led; /* For driver */ 53 unsigned int led; /* For driver */
52 void (*set_brightness)(struct delayed_led_classdev *data, enum led_brightness value); 54 void (*set_brightness)(struct delayed_led_classdev *data, enum led_brightness value);
53 }; 55 };
54 56
55 static inline void delayed_set_status_worker(struct work_struct *work) 57 static inline void delayed_set_status_worker(struct work_struct *work)
56 { 58 {
57 struct delayed_led_classdev *data = 59 struct delayed_led_classdev *data =
58 container_of(work, struct delayed_led_classdev, work); 60 container_of(work, struct delayed_led_classdev, work);
59 61
60 data->set_brightness(data, data->new_brightness); 62 data->set_brightness(data, data->new_brightness);
61 } 63 }
62 64
63 static inline void delayed_sysfs_set(struct led_classdev *led_cdev, 65 static inline void delayed_sysfs_set(struct led_classdev *led_cdev,
64 enum led_brightness brightness) 66 enum led_brightness brightness)
65 { 67 {
66 struct delayed_led_classdev *data = container_of(led_cdev, 68 struct delayed_led_classdev *data = container_of(led_cdev,
67 struct delayed_led_classdev, led_classdev); 69 struct delayed_led_classdev, led_classdev);
68 data->new_brightness = brightness; 70 data->new_brightness = brightness;
69 schedule_work(&data->work); 71 schedule_work(&data->work);
70 } 72 }
71 73
72 /* HP-specific accelerometer driver ------------------------------------ */ 74 /* HP-specific accelerometer driver ------------------------------------ */
73 75
74 /* For automatic insertion of the module */ 76 /* For automatic insertion of the module */
75 static struct acpi_device_id lis3lv02d_device_ids[] = { 77 static struct acpi_device_id lis3lv02d_device_ids[] = {
76 {"HPQ0004", 0}, /* HP Mobile Data Protection System PNP */ 78 {"HPQ0004", 0}, /* HP Mobile Data Protection System PNP */
77 {"", 0}, 79 {"", 0},
78 }; 80 };
79 MODULE_DEVICE_TABLE(acpi, lis3lv02d_device_ids); 81 MODULE_DEVICE_TABLE(acpi, lis3lv02d_device_ids);
80 82
81 83
82 /** 84 /**
83 * lis3lv02d_acpi_init - ACPI _INI method: initialize the device. 85 * lis3lv02d_acpi_init - ACPI _INI method: initialize the device.
84 * @lis3: pointer to the device struct 86 * @lis3: pointer to the device struct
85 * 87 *
86 * Returns 0 on success. 88 * Returns 0 on success.
87 */ 89 */
88 int lis3lv02d_acpi_init(struct lis3lv02d *lis3) 90 int lis3lv02d_acpi_init(struct lis3lv02d *lis3)
89 { 91 {
90 struct acpi_device *dev = lis3->bus_priv; 92 struct acpi_device *dev = lis3->bus_priv;
91 if (acpi_evaluate_object(dev->handle, METHOD_NAME__INI, 93 if (acpi_evaluate_object(dev->handle, METHOD_NAME__INI,
92 NULL, NULL) != AE_OK) 94 NULL, NULL) != AE_OK)
93 return -EINVAL; 95 return -EINVAL;
94 96
95 return 0; 97 return 0;
96 } 98 }
97 99
98 /** 100 /**
99 * lis3lv02d_acpi_read - ACPI ALRD method: read a register 101 * lis3lv02d_acpi_read - ACPI ALRD method: read a register
100 * @lis3: pointer to the device struct 102 * @lis3: pointer to the device struct
101 * @reg: the register to read 103 * @reg: the register to read
102 * @ret: result of the operation 104 * @ret: result of the operation
103 * 105 *
104 * Returns 0 on success. 106 * Returns 0 on success.
105 */ 107 */
106 int lis3lv02d_acpi_read(struct lis3lv02d *lis3, int reg, u8 *ret) 108 int lis3lv02d_acpi_read(struct lis3lv02d *lis3, int reg, u8 *ret)
107 { 109 {
108 struct acpi_device *dev = lis3->bus_priv; 110 struct acpi_device *dev = lis3->bus_priv;
109 union acpi_object arg0 = { ACPI_TYPE_INTEGER }; 111 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
110 struct acpi_object_list args = { 1, &arg0 }; 112 struct acpi_object_list args = { 1, &arg0 };
111 unsigned long long lret; 113 unsigned long long lret;
112 acpi_status status; 114 acpi_status status;
113 115
114 arg0.integer.value = reg; 116 arg0.integer.value = reg;
115 117
116 status = acpi_evaluate_integer(dev->handle, "ALRD", &args, &lret); 118 status = acpi_evaluate_integer(dev->handle, "ALRD", &args, &lret);
117 *ret = lret; 119 *ret = lret;
118 return (status != AE_OK) ? -EINVAL : 0; 120 return (status != AE_OK) ? -EINVAL : 0;
119 } 121 }
120 122
121 /** 123 /**
122 * lis3lv02d_acpi_write - ACPI ALWR method: write to a register 124 * lis3lv02d_acpi_write - ACPI ALWR method: write to a register
123 * @lis3: pointer to the device struct 125 * @lis3: pointer to the device struct
124 * @reg: the register to write to 126 * @reg: the register to write to
125 * @val: the value to write 127 * @val: the value to write
126 * 128 *
127 * Returns 0 on success. 129 * Returns 0 on success.
128 */ 130 */
129 int lis3lv02d_acpi_write(struct lis3lv02d *lis3, int reg, u8 val) 131 int lis3lv02d_acpi_write(struct lis3lv02d *lis3, int reg, u8 val)
130 { 132 {
131 struct acpi_device *dev = lis3->bus_priv; 133 struct acpi_device *dev = lis3->bus_priv;
132 unsigned long long ret; /* Not used when writting */ 134 unsigned long long ret; /* Not used when writting */
133 union acpi_object in_obj[2]; 135 union acpi_object in_obj[2];
134 struct acpi_object_list args = { 2, in_obj }; 136 struct acpi_object_list args = { 2, in_obj };
135 137
136 in_obj[0].type = ACPI_TYPE_INTEGER; 138 in_obj[0].type = ACPI_TYPE_INTEGER;
137 in_obj[0].integer.value = reg; 139 in_obj[0].integer.value = reg;
138 in_obj[1].type = ACPI_TYPE_INTEGER; 140 in_obj[1].type = ACPI_TYPE_INTEGER;
139 in_obj[1].integer.value = val; 141 in_obj[1].integer.value = val;
140 142
141 if (acpi_evaluate_integer(dev->handle, "ALWR", &args, &ret) != AE_OK) 143 if (acpi_evaluate_integer(dev->handle, "ALWR", &args, &ret) != AE_OK)
142 return -EINVAL; 144 return -EINVAL;
143 145
144 return 0; 146 return 0;
145 } 147 }
146 148
147 static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi) 149 static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi)
148 { 150 {
149 lis3_dev.ac = *((union axis_conversion *)dmi->driver_data); 151 lis3_dev.ac = *((union axis_conversion *)dmi->driver_data);
150 printk(KERN_INFO DRIVER_NAME ": hardware type %s found.\n", dmi->ident); 152 pr_info("hardware type %s found\n", dmi->ident);
151 153
152 return 1; 154 return 1;
153 } 155 }
154 156
155 /* Represents, for each axis seen by userspace, the corresponding hw axis (+1). 157 /* Represents, for each axis seen by userspace, the corresponding hw axis (+1).
156 * If the value is negative, the opposite of the hw value is used. */ 158 * If the value is negative, the opposite of the hw value is used. */
157 #define DEFINE_CONV(name, x, y, z) \ 159 #define DEFINE_CONV(name, x, y, z) \
158 static union axis_conversion lis3lv02d_axis_##name = \ 160 static union axis_conversion lis3lv02d_axis_##name = \
159 { .as_array = { x, y, z } } 161 { .as_array = { x, y, z } }
160 DEFINE_CONV(normal, 1, 2, 3); 162 DEFINE_CONV(normal, 1, 2, 3);
161 DEFINE_CONV(y_inverted, 1, -2, 3); 163 DEFINE_CONV(y_inverted, 1, -2, 3);
162 DEFINE_CONV(x_inverted, -1, 2, 3); 164 DEFINE_CONV(x_inverted, -1, 2, 3);
163 DEFINE_CONV(z_inverted, 1, 2, -3); 165 DEFINE_CONV(z_inverted, 1, 2, -3);
164 DEFINE_CONV(xy_swap, 2, 1, 3); 166 DEFINE_CONV(xy_swap, 2, 1, 3);
165 DEFINE_CONV(xy_rotated_left, -2, 1, 3); 167 DEFINE_CONV(xy_rotated_left, -2, 1, 3);
166 DEFINE_CONV(xy_rotated_left_usd, -2, 1, -3); 168 DEFINE_CONV(xy_rotated_left_usd, -2, 1, -3);
167 DEFINE_CONV(xy_swap_inverted, -2, -1, 3); 169 DEFINE_CONV(xy_swap_inverted, -2, -1, 3);
168 DEFINE_CONV(xy_rotated_right, 2, -1, 3); 170 DEFINE_CONV(xy_rotated_right, 2, -1, 3);
169 DEFINE_CONV(xy_swap_yz_inverted, 2, -1, -3); 171 DEFINE_CONV(xy_swap_yz_inverted, 2, -1, -3);
170 172
171 #define AXIS_DMI_MATCH(_ident, _name, _axis) { \ 173 #define AXIS_DMI_MATCH(_ident, _name, _axis) { \
172 .ident = _ident, \ 174 .ident = _ident, \
173 .callback = lis3lv02d_dmi_matched, \ 175 .callback = lis3lv02d_dmi_matched, \
174 .matches = { \ 176 .matches = { \
175 DMI_MATCH(DMI_PRODUCT_NAME, _name) \ 177 DMI_MATCH(DMI_PRODUCT_NAME, _name) \
176 }, \ 178 }, \
177 .driver_data = &lis3lv02d_axis_##_axis \ 179 .driver_data = &lis3lv02d_axis_##_axis \
178 } 180 }
179 181
180 #define AXIS_DMI_MATCH2(_ident, _class1, _name1, \ 182 #define AXIS_DMI_MATCH2(_ident, _class1, _name1, \
181 _class2, _name2, \ 183 _class2, _name2, \
182 _axis) { \ 184 _axis) { \
183 .ident = _ident, \ 185 .ident = _ident, \
184 .callback = lis3lv02d_dmi_matched, \ 186 .callback = lis3lv02d_dmi_matched, \
185 .matches = { \ 187 .matches = { \
186 DMI_MATCH(DMI_##_class1, _name1), \ 188 DMI_MATCH(DMI_##_class1, _name1), \
187 DMI_MATCH(DMI_##_class2, _name2), \ 189 DMI_MATCH(DMI_##_class2, _name2), \
188 }, \ 190 }, \
189 .driver_data = &lis3lv02d_axis_##_axis \ 191 .driver_data = &lis3lv02d_axis_##_axis \
190 } 192 }
191 static struct dmi_system_id lis3lv02d_dmi_ids[] = { 193 static struct dmi_system_id lis3lv02d_dmi_ids[] = {
192 /* product names are truncated to match all kinds of a same model */ 194 /* product names are truncated to match all kinds of a same model */
193 AXIS_DMI_MATCH("NC64x0", "HP Compaq nc64", x_inverted), 195 AXIS_DMI_MATCH("NC64x0", "HP Compaq nc64", x_inverted),
194 AXIS_DMI_MATCH("NC84x0", "HP Compaq nc84", z_inverted), 196 AXIS_DMI_MATCH("NC84x0", "HP Compaq nc84", z_inverted),
195 AXIS_DMI_MATCH("NX9420", "HP Compaq nx9420", x_inverted), 197 AXIS_DMI_MATCH("NX9420", "HP Compaq nx9420", x_inverted),
196 AXIS_DMI_MATCH("NW9440", "HP Compaq nw9440", x_inverted), 198 AXIS_DMI_MATCH("NW9440", "HP Compaq nw9440", x_inverted),
197 AXIS_DMI_MATCH("NC2510", "HP Compaq 2510", y_inverted), 199 AXIS_DMI_MATCH("NC2510", "HP Compaq 2510", y_inverted),
198 AXIS_DMI_MATCH("NC2710", "HP Compaq 2710", xy_swap), 200 AXIS_DMI_MATCH("NC2710", "HP Compaq 2710", xy_swap),
199 AXIS_DMI_MATCH("NC8510", "HP Compaq 8510", xy_swap_inverted), 201 AXIS_DMI_MATCH("NC8510", "HP Compaq 8510", xy_swap_inverted),
200 AXIS_DMI_MATCH("HP2133", "HP 2133", xy_rotated_left), 202 AXIS_DMI_MATCH("HP2133", "HP 2133", xy_rotated_left),
201 AXIS_DMI_MATCH("HP2140", "HP 2140", xy_swap_inverted), 203 AXIS_DMI_MATCH("HP2140", "HP 2140", xy_swap_inverted),
202 AXIS_DMI_MATCH("NC653x", "HP Compaq 653", xy_rotated_left_usd), 204 AXIS_DMI_MATCH("NC653x", "HP Compaq 653", xy_rotated_left_usd),
203 AXIS_DMI_MATCH("NC6730b", "HP Compaq 6730b", xy_rotated_left_usd), 205 AXIS_DMI_MATCH("NC6730b", "HP Compaq 6730b", xy_rotated_left_usd),
204 AXIS_DMI_MATCH("NC6730s", "HP Compaq 6730s", xy_swap), 206 AXIS_DMI_MATCH("NC6730s", "HP Compaq 6730s", xy_swap),
205 AXIS_DMI_MATCH("NC651xx", "HP Compaq 651", xy_rotated_right), 207 AXIS_DMI_MATCH("NC651xx", "HP Compaq 651", xy_rotated_right),
206 AXIS_DMI_MATCH("NC6710x", "HP Compaq 6710", xy_swap_yz_inverted), 208 AXIS_DMI_MATCH("NC6710x", "HP Compaq 6710", xy_swap_yz_inverted),
207 AXIS_DMI_MATCH("NC6715x", "HP Compaq 6715", y_inverted), 209 AXIS_DMI_MATCH("NC6715x", "HP Compaq 6715", y_inverted),
208 AXIS_DMI_MATCH("NC693xx", "HP EliteBook 693", xy_rotated_right), 210 AXIS_DMI_MATCH("NC693xx", "HP EliteBook 693", xy_rotated_right),
209 AXIS_DMI_MATCH("NC693xx", "HP EliteBook 853", xy_swap), 211 AXIS_DMI_MATCH("NC693xx", "HP EliteBook 853", xy_swap),
210 /* Intel-based HP Pavilion dv5 */ 212 /* Intel-based HP Pavilion dv5 */
211 AXIS_DMI_MATCH2("HPDV5_I", 213 AXIS_DMI_MATCH2("HPDV5_I",
212 PRODUCT_NAME, "HP Pavilion dv5", 214 PRODUCT_NAME, "HP Pavilion dv5",
213 BOARD_NAME, "3603", 215 BOARD_NAME, "3603",
214 x_inverted), 216 x_inverted),
215 /* AMD-based HP Pavilion dv5 */ 217 /* AMD-based HP Pavilion dv5 */
216 AXIS_DMI_MATCH2("HPDV5_A", 218 AXIS_DMI_MATCH2("HPDV5_A",
217 PRODUCT_NAME, "HP Pavilion dv5", 219 PRODUCT_NAME, "HP Pavilion dv5",
218 BOARD_NAME, "3600", 220 BOARD_NAME, "3600",
219 y_inverted), 221 y_inverted),
220 AXIS_DMI_MATCH("DV7", "HP Pavilion dv7", x_inverted), 222 AXIS_DMI_MATCH("DV7", "HP Pavilion dv7", x_inverted),
221 AXIS_DMI_MATCH("HP8710", "HP Compaq 8710", y_inverted), 223 AXIS_DMI_MATCH("HP8710", "HP Compaq 8710", y_inverted),
222 AXIS_DMI_MATCH("HDX18", "HP HDX 18", x_inverted), 224 AXIS_DMI_MATCH("HDX18", "HP HDX 18", x_inverted),
223 AXIS_DMI_MATCH("HPB432x", "HP ProBook 432", xy_rotated_left), 225 AXIS_DMI_MATCH("HPB432x", "HP ProBook 432", xy_rotated_left),
224 AXIS_DMI_MATCH("HPB442x", "HP ProBook 442", xy_rotated_left), 226 AXIS_DMI_MATCH("HPB442x", "HP ProBook 442", xy_rotated_left),
225 AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted), 227 AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted),
226 AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap), 228 AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap),
227 AXIS_DMI_MATCH("HPB532x", "HP ProBook 532", y_inverted), 229 AXIS_DMI_MATCH("HPB532x", "HP ProBook 532", y_inverted),
228 AXIS_DMI_MATCH("Mini510x", "HP Mini 510", xy_rotated_left_usd), 230 AXIS_DMI_MATCH("Mini510x", "HP Mini 510", xy_rotated_left_usd),
229 { NULL, } 231 { NULL, }
230 /* Laptop models without axis info (yet): 232 /* Laptop models without axis info (yet):
231 * "NC6910" "HP Compaq 6910" 233 * "NC6910" "HP Compaq 6910"
232 * "NC2400" "HP Compaq nc2400" 234 * "NC2400" "HP Compaq nc2400"
233 * "NX74x0" "HP Compaq nx74" 235 * "NX74x0" "HP Compaq nx74"
234 * "NX6325" "HP Compaq nx6325" 236 * "NX6325" "HP Compaq nx6325"
235 * "NC4400" "HP Compaq nc4400" 237 * "NC4400" "HP Compaq nc4400"
236 */ 238 */
237 }; 239 };
238 240
239 static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value) 241 static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value)
240 { 242 {
241 struct acpi_device *dev = lis3_dev.bus_priv; 243 struct acpi_device *dev = lis3_dev.bus_priv;
242 unsigned long long ret; /* Not used when writing */ 244 unsigned long long ret; /* Not used when writing */
243 union acpi_object in_obj[1]; 245 union acpi_object in_obj[1];
244 struct acpi_object_list args = { 1, in_obj }; 246 struct acpi_object_list args = { 1, in_obj };
245 247
246 in_obj[0].type = ACPI_TYPE_INTEGER; 248 in_obj[0].type = ACPI_TYPE_INTEGER;
247 in_obj[0].integer.value = !!value; 249 in_obj[0].integer.value = !!value;
248 250
249 acpi_evaluate_integer(dev->handle, "ALED", &args, &ret); 251 acpi_evaluate_integer(dev->handle, "ALED", &args, &ret);
250 } 252 }
251 253
252 static struct delayed_led_classdev hpled_led = { 254 static struct delayed_led_classdev hpled_led = {
253 .led_classdev = { 255 .led_classdev = {
254 .name = "hp::hddprotect", 256 .name = "hp::hddprotect",
255 .default_trigger = "none", 257 .default_trigger = "none",
256 .brightness_set = delayed_sysfs_set, 258 .brightness_set = delayed_sysfs_set,
257 .flags = LED_CORE_SUSPENDRESUME, 259 .flags = LED_CORE_SUSPENDRESUME,
258 }, 260 },
259 .set_brightness = hpled_set, 261 .set_brightness = hpled_set,
260 }; 262 };
261 263
262 static acpi_status 264 static acpi_status
263 lis3lv02d_get_resource(struct acpi_resource *resource, void *context) 265 lis3lv02d_get_resource(struct acpi_resource *resource, void *context)
264 { 266 {
265 if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) { 267 if (resource->type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
266 struct acpi_resource_extended_irq *irq; 268 struct acpi_resource_extended_irq *irq;
267 u32 *device_irq = context; 269 u32 *device_irq = context;
268 270
269 irq = &resource->data.extended_irq; 271 irq = &resource->data.extended_irq;
270 *device_irq = irq->interrupts[0]; 272 *device_irq = irq->interrupts[0];
271 } 273 }
272 274
273 return AE_OK; 275 return AE_OK;
274 } 276 }
275 277
276 static void lis3lv02d_enum_resources(struct acpi_device *device) 278 static void lis3lv02d_enum_resources(struct acpi_device *device)
277 { 279 {
278 acpi_status status; 280 acpi_status status;
279 281
280 status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 282 status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
281 lis3lv02d_get_resource, &lis3_dev.irq); 283 lis3lv02d_get_resource, &lis3_dev.irq);
282 if (ACPI_FAILURE(status)) 284 if (ACPI_FAILURE(status))
283 printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n"); 285 printk(KERN_DEBUG DRIVER_NAME ": Error getting resources\n");
284 } 286 }
285 287
286 static int lis3lv02d_add(struct acpi_device *device) 288 static int lis3lv02d_add(struct acpi_device *device)
287 { 289 {
288 int ret; 290 int ret;
289 291
290 if (!device) 292 if (!device)
291 return -EINVAL; 293 return -EINVAL;
292 294
293 lis3_dev.bus_priv = device; 295 lis3_dev.bus_priv = device;
294 lis3_dev.init = lis3lv02d_acpi_init; 296 lis3_dev.init = lis3lv02d_acpi_init;
295 lis3_dev.read = lis3lv02d_acpi_read; 297 lis3_dev.read = lis3lv02d_acpi_read;
296 lis3_dev.write = lis3lv02d_acpi_write; 298 lis3_dev.write = lis3lv02d_acpi_write;
297 strcpy(acpi_device_name(device), DRIVER_NAME); 299 strcpy(acpi_device_name(device), DRIVER_NAME);
298 strcpy(acpi_device_class(device), ACPI_MDPS_CLASS); 300 strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
299 device->driver_data = &lis3_dev; 301 device->driver_data = &lis3_dev;
300 302
301 /* obtain IRQ number of our device from ACPI */ 303 /* obtain IRQ number of our device from ACPI */
302 lis3lv02d_enum_resources(device); 304 lis3lv02d_enum_resources(device);
303 305
304 /* If possible use a "standard" axes order */ 306 /* If possible use a "standard" axes order */
305 if (lis3_dev.ac.x && lis3_dev.ac.y && lis3_dev.ac.z) { 307 if (lis3_dev.ac.x && lis3_dev.ac.y && lis3_dev.ac.z) {
306 printk(KERN_INFO DRIVER_NAME ": Using custom axes %d,%d,%d\n", 308 pr_info("Using custom axes %d,%d,%d\n",
307 lis3_dev.ac.x, lis3_dev.ac.y, lis3_dev.ac.z); 309 lis3_dev.ac.x, lis3_dev.ac.y, lis3_dev.ac.z);
308 } else if (dmi_check_system(lis3lv02d_dmi_ids) == 0) { 310 } else if (dmi_check_system(lis3lv02d_dmi_ids) == 0) {
309 printk(KERN_INFO DRIVER_NAME ": laptop model unknown, " 311 pr_info("laptop model unknown, using default axes configuration\n");
310 "using default axes configuration\n");
311 lis3_dev.ac = lis3lv02d_axis_normal; 312 lis3_dev.ac = lis3lv02d_axis_normal;
312 } 313 }
313 314
314 /* call the core layer do its init */ 315 /* call the core layer do its init */
315 ret = lis3lv02d_init_device(&lis3_dev); 316 ret = lis3lv02d_init_device(&lis3_dev);
316 if (ret) 317 if (ret)
317 return ret; 318 return ret;
318 319
319 INIT_WORK(&hpled_led.work, delayed_set_status_worker); 320 INIT_WORK(&hpled_led.work, delayed_set_status_worker);
320 ret = led_classdev_register(NULL, &hpled_led.led_classdev); 321 ret = led_classdev_register(NULL, &hpled_led.led_classdev);
321 if (ret) { 322 if (ret) {
322 lis3lv02d_joystick_disable(); 323 lis3lv02d_joystick_disable();
323 lis3lv02d_poweroff(&lis3_dev); 324 lis3lv02d_poweroff(&lis3_dev);
324 flush_work(&hpled_led.work); 325 flush_work(&hpled_led.work);
325 return ret; 326 return ret;
326 } 327 }
327 328
328 return ret; 329 return ret;
329 } 330 }
330 331
331 static int lis3lv02d_remove(struct acpi_device *device, int type) 332 static int lis3lv02d_remove(struct acpi_device *device, int type)
332 { 333 {
333 if (!device) 334 if (!device)
334 return -EINVAL; 335 return -EINVAL;
335 336
336 lis3lv02d_joystick_disable(); 337 lis3lv02d_joystick_disable();
337 lis3lv02d_poweroff(&lis3_dev); 338 lis3lv02d_poweroff(&lis3_dev);
338 339
339 led_classdev_unregister(&hpled_led.led_classdev); 340 led_classdev_unregister(&hpled_led.led_classdev);
340 flush_work(&hpled_led.work); 341 flush_work(&hpled_led.work);
341 342
342 return lis3lv02d_remove_fs(&lis3_dev); 343 return lis3lv02d_remove_fs(&lis3_dev);
343 } 344 }
344 345
345 346
346 #ifdef CONFIG_PM 347 #ifdef CONFIG_PM
347 static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state) 348 static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state)
348 { 349 {
349 /* make sure the device is off when we suspend */ 350 /* make sure the device is off when we suspend */
350 lis3lv02d_poweroff(&lis3_dev); 351 lis3lv02d_poweroff(&lis3_dev);
351 return 0; 352 return 0;
352 } 353 }
353 354
354 static int lis3lv02d_resume(struct acpi_device *device) 355 static int lis3lv02d_resume(struct acpi_device *device)
355 { 356 {
356 lis3lv02d_poweron(&lis3_dev); 357 lis3lv02d_poweron(&lis3_dev);
357 return 0; 358 return 0;
358 } 359 }
359 #else 360 #else
360 #define lis3lv02d_suspend NULL 361 #define lis3lv02d_suspend NULL
361 #define lis3lv02d_resume NULL 362 #define lis3lv02d_resume NULL
362 #endif 363 #endif
363 364
364 /* For the HP MDPS aka 3D Driveguard */ 365 /* For the HP MDPS aka 3D Driveguard */
365 static struct acpi_driver lis3lv02d_driver = { 366 static struct acpi_driver lis3lv02d_driver = {
366 .name = DRIVER_NAME, 367 .name = DRIVER_NAME,
367 .class = ACPI_MDPS_CLASS, 368 .class = ACPI_MDPS_CLASS,
368 .ids = lis3lv02d_device_ids, 369 .ids = lis3lv02d_device_ids,
369 .ops = { 370 .ops = {
370 .add = lis3lv02d_add, 371 .add = lis3lv02d_add,
371 .remove = lis3lv02d_remove, 372 .remove = lis3lv02d_remove,
372 .suspend = lis3lv02d_suspend, 373 .suspend = lis3lv02d_suspend,
373 .resume = lis3lv02d_resume, 374 .resume = lis3lv02d_resume,
374 } 375 }
375 }; 376 };
376 377
377 static int __init lis3lv02d_init_module(void) 378 static int __init lis3lv02d_init_module(void)
378 { 379 {
379 int ret; 380 int ret;
380 381
381 if (acpi_disabled) 382 if (acpi_disabled)
382 return -ENODEV; 383 return -ENODEV;
383 384
384 ret = acpi_bus_register_driver(&lis3lv02d_driver); 385 ret = acpi_bus_register_driver(&lis3lv02d_driver);
385 if (ret < 0) 386 if (ret < 0)
386 return ret; 387 return ret;
387 388
388 printk(KERN_INFO DRIVER_NAME " driver loaded.\n"); 389 pr_info("driver loaded\n");
389 390
390 return 0; 391 return 0;
391 } 392 }
392 393
393 static void __exit lis3lv02d_exit_module(void) 394 static void __exit lis3lv02d_exit_module(void)
394 { 395 {
395 acpi_bus_unregister_driver(&lis3lv02d_driver); 396 acpi_bus_unregister_driver(&lis3lv02d_driver);
396 } 397 }
397 398
398 MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS and support for disk protection LED."); 399 MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS and support for disk protection LED.");
399 MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek"); 400 MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
400 MODULE_LICENSE("GPL"); 401 MODULE_LICENSE("GPL");
401 402
402 module_init(lis3lv02d_init_module); 403 module_init(lis3lv02d_init_module);
403 module_exit(lis3lv02d_exit_module); 404 module_exit(lis3lv02d_exit_module);
404 405