Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 50526df605e7c3e22168664acf726269eae10171

Authored by Len Brown
1 parent 716e084edb
Exists in master and in 7 other branches 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, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

[ACPI] Lindent drivers/acpi/ec.c 

necessary for clean merge from acpi-2.6.12 to-akpm

Signed-off-by: Len Brown <len.brown@intel.com>

Showing 1 changed file with 389 additions and 480 deletions Side-by-side Diff

Changes suppressed. Click to show
... ... @@ -38,130 +38,112 @@
38 38 #include <acpi/actypes.h>
39 39  
40 40 #define _COMPONENT ACPI_EC_COMPONENT
41   -ACPI_MODULE_NAME ("acpi_ec")
42   -
  41 +ACPI_MODULE_NAME("acpi_ec")
43 42 #define ACPI_EC_COMPONENT 0x00100000
44 43 #define ACPI_EC_CLASS "embedded_controller"
45 44 #define ACPI_EC_HID "PNP0C09"
46 45 #define ACPI_EC_DRIVER_NAME "ACPI Embedded Controller Driver"
47 46 #define ACPI_EC_DEVICE_NAME "Embedded Controller"
48 47 #define ACPI_EC_FILE_INFO "info"
49   -
50   -
51 48 #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
52 49 #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
53 50 #define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
54 51 #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
55   -
56 52 #define ACPI_EC_EVENT_OBF 0x01 /* Output buffer full */
57 53 #define ACPI_EC_EVENT_IBE 0x02 /* Input buffer empty */
58   -
59 54 #define ACPI_EC_DELAY 50 /* Wait 50ms max. during EC ops */
60 55 #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
61   -
62   -#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
63   -#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
64   -
  56 +#define ACPI_EC_UDELAY 100 /* Poll @ 100us increments */
  57 +#define ACPI_EC_UDELAY_COUNT 1000 /* Wait 10ms max. during EC ops */
65 58 #define ACPI_EC_COMMAND_READ 0x80
66 59 #define ACPI_EC_COMMAND_WRITE 0x81
67 60 #define ACPI_EC_BURST_ENABLE 0x82
68 61 #define ACPI_EC_BURST_DISABLE 0x83
69 62 #define ACPI_EC_COMMAND_QUERY 0x84
70   -
71 63 #define EC_POLLING 0xFF
72 64 #define EC_BURST 0x00
  65 +static int acpi_ec_remove(struct acpi_device *device, int type);
  66 +static int acpi_ec_start(struct acpi_device *device);
  67 +static int acpi_ec_stop(struct acpi_device *device, int type);
  68 +static int acpi_ec_burst_add(struct acpi_device *device);
  69 +static int acpi_ec_polling_add(struct acpi_device *device);
73 70  
74   -
75   -static int acpi_ec_remove (struct acpi_device *device, int type);
76   -static int acpi_ec_start (struct acpi_device *device);
77   -static int acpi_ec_stop (struct acpi_device *device, int type);
78   -static int acpi_ec_burst_add ( struct acpi_device *device);
79   -static int acpi_ec_polling_add ( struct acpi_device *device);
80   -
81 71 static struct acpi_driver acpi_ec_driver = {
82   - .name = ACPI_EC_DRIVER_NAME,
83   - .class = ACPI_EC_CLASS,
84   - .ids = ACPI_EC_HID,
85   - .ops = {
86   - .add = acpi_ec_polling_add,
87   - .remove = acpi_ec_remove,
88   - .start = acpi_ec_start,
89   - .stop = acpi_ec_stop,
90   - },
  72 + .name = ACPI_EC_DRIVER_NAME,
  73 + .class = ACPI_EC_CLASS,
  74 + .ids = ACPI_EC_HID,
  75 + .ops = {
  76 + .add = acpi_ec_polling_add,
  77 + .remove = acpi_ec_remove,
  78 + .start = acpi_ec_start,
  79 + .stop = acpi_ec_stop,
  80 + },
91 81 };
92 82 union acpi_ec {
93 83 struct {
94   - u32 mode;
95   - acpi_handle handle;
96   - unsigned long uid;
97   - unsigned long gpe_bit;
98   - struct acpi_generic_address status_addr;
99   - struct acpi_generic_address command_addr;
100   - struct acpi_generic_address data_addr;
101   - unsigned long global_lock;
  84 + u32 mode;
  85 + acpi_handle handle;
  86 + unsigned long uid;
  87 + unsigned long gpe_bit;
  88 + struct acpi_generic_address status_addr;
  89 + struct acpi_generic_address command_addr;
  90 + struct acpi_generic_address data_addr;
  91 + unsigned long global_lock;
102 92 } common;
103 93  
104 94 struct {
105   - u32 mode;
106   - acpi_handle handle;
107   - unsigned long uid;
108   - unsigned long gpe_bit;
109   - struct acpi_generic_address status_addr;
110   - struct acpi_generic_address command_addr;
111   - struct acpi_generic_address data_addr;
112   - unsigned long global_lock;
113   - unsigned int expect_event;
114   - atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort*/
115   - atomic_t pending_gpe;
116   - struct semaphore sem;
117   - wait_queue_head_t wait;
118   - }burst;
  95 + u32 mode;
  96 + acpi_handle handle;
  97 + unsigned long uid;
  98 + unsigned long gpe_bit;
  99 + struct acpi_generic_address status_addr;
  100 + struct acpi_generic_address command_addr;
  101 + struct acpi_generic_address data_addr;
  102 + unsigned long global_lock;
  103 + unsigned int expect_event;
  104 + atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
  105 + atomic_t pending_gpe;
  106 + struct semaphore sem;
  107 + wait_queue_head_t wait;
  108 + } burst;
119 109  
120 110 struct {
121   - u32 mode;
122   - acpi_handle handle;
123   - unsigned long uid;
124   - unsigned long gpe_bit;
125   - struct acpi_generic_address status_addr;
126   - struct acpi_generic_address command_addr;
127   - struct acpi_generic_address data_addr;
128   - unsigned long global_lock;
129   - spinlock_t lock;
130   - }polling;
  111 + u32 mode;
  112 + acpi_handle handle;
  113 + unsigned long uid;
  114 + unsigned long gpe_bit;
  115 + struct acpi_generic_address status_addr;
  116 + struct acpi_generic_address command_addr;
  117 + struct acpi_generic_address data_addr;
  118 + unsigned long global_lock;
  119 + spinlock_t lock;
  120 + } polling;
131 121 };
132 122  
133   -static int acpi_ec_polling_wait ( union acpi_ec *ec, u8 event);
  123 +static int acpi_ec_polling_wait(union acpi_ec *ec, u8 event);
134 124 static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event);
135   -static int acpi_ec_polling_read ( union acpi_ec *ec, u8 address, u32 *data);
136   -static int acpi_ec_burst_read( union acpi_ec *ec, u8 address, u32 *data);
137   -static int acpi_ec_polling_write ( union acpi_ec *ec, u8 address, u8 data);
138   -static int acpi_ec_burst_write ( union acpi_ec *ec, u8 address, u8 data);
139   -static int acpi_ec_polling_query ( union acpi_ec *ec, u32 *data);
140   -static int acpi_ec_burst_query ( union acpi_ec *ec, u32 *data);
141   -static void acpi_ec_gpe_polling_query ( void *ec_cxt);
142   -static void acpi_ec_gpe_burst_query ( void *ec_cxt);
143   -static u32 acpi_ec_gpe_polling_handler ( void *data);
144   -static u32 acpi_ec_gpe_burst_handler ( void *data);
  125 +static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data);
  126 +static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data);
  127 +static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data);
  128 +static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data);
  129 +static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data);
  130 +static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data);
  131 +static void acpi_ec_gpe_polling_query(void *ec_cxt);
  132 +static void acpi_ec_gpe_burst_query(void *ec_cxt);
  133 +static u32 acpi_ec_gpe_polling_handler(void *data);
  134 +static u32 acpi_ec_gpe_burst_handler(void *data);
145 135 static acpi_status __init
146   -acpi_fake_ecdt_polling_callback (
147   - acpi_handle handle,
148   - u32 Level,
149   - void *context,
150   - void **retval);
  136 +acpi_fake_ecdt_polling_callback(acpi_handle handle,
  137 + u32 Level, void *context, void **retval);
151 138  
152 139 static acpi_status __init
153   -acpi_fake_ecdt_burst_callback (
154   - acpi_handle handle,
155   - u32 Level,
156   - void *context,
157   - void **retval);
  140 +acpi_fake_ecdt_burst_callback(acpi_handle handle,
  141 + u32 Level, void *context, void **retval);
158 142  
159   -static int __init
160   -acpi_ec_polling_get_real_ecdt(void);
161   -static int __init
162   -acpi_ec_burst_get_real_ecdt(void);
  143 +static int __init acpi_ec_polling_get_real_ecdt(void);
  144 +static int __init acpi_ec_burst_get_real_ecdt(void);
163 145 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
164   -static union acpi_ec *ec_ecdt;
  146 +static union acpi_ec *ec_ecdt;
165 147  
166 148 /* External interfaces use first EC only, so remember */
167 149 static struct acpi_device *first_ec;
168 150  
169 151  
170 152  
171 153  
172 154  
... ... @@ -173,30 +155,24 @@
173 155  
174 156 static inline u32 acpi_ec_read_status(union acpi_ec *ec)
175 157 {
176   - u32 status = 0;
  158 + u32 status = 0;
177 159  
178 160 acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
179 161 return status;
180 162 }
181 163  
182   -static int
183   -acpi_ec_wait (
184   - union acpi_ec *ec,
185   - u8 event)
  164 +static int acpi_ec_wait(union acpi_ec *ec, u8 event)
186 165 {
187   - if (acpi_ec_polling_mode)
188   - return acpi_ec_polling_wait (ec, event);
  166 + if (acpi_ec_polling_mode)
  167 + return acpi_ec_polling_wait(ec, event);
189 168 else
190   - return acpi_ec_burst_wait (ec, event);
  169 + return acpi_ec_burst_wait(ec, event);
191 170 }
192 171  
193   -static int
194   -acpi_ec_polling_wait (
195   - union acpi_ec *ec,
196   - u8 event)
  172 +static int acpi_ec_polling_wait(union acpi_ec *ec, u8 event)
197 173 {
198   - u32 acpi_ec_status = 0;
199   - u32 i = ACPI_EC_UDELAY_COUNT;
  174 + u32 acpi_ec_status = 0;
  175 + u32 i = ACPI_EC_UDELAY_COUNT;
200 176  
201 177 if (!ec)
202 178 return -EINVAL;
203 179  
204 180  
205 181  
... ... @@ -205,19 +181,21 @@
205 181 switch (event) {
206 182 case ACPI_EC_EVENT_OBF:
207 183 do {
208   - acpi_hw_low_level_read(8, &acpi_ec_status, &ec->common.status_addr);
  184 + acpi_hw_low_level_read(8, &acpi_ec_status,
  185 + &ec->common.status_addr);
209 186 if (acpi_ec_status & ACPI_EC_FLAG_OBF)
210 187 return 0;
211 188 udelay(ACPI_EC_UDELAY);
212   - } while (--i>0);
  189 + } while (--i > 0);
213 190 break;
214 191 case ACPI_EC_EVENT_IBE:
215 192 do {
216   - acpi_hw_low_level_read(8, &acpi_ec_status, &ec->common.status_addr);
  193 + acpi_hw_low_level_read(8, &acpi_ec_status,
  194 + &ec->common.status_addr);
217 195 if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
218 196 return 0;
219 197 udelay(ACPI_EC_UDELAY);
220   - } while (--i>0);
  198 + } while (--i > 0);
221 199 break;
222 200 default:
223 201 return -EINVAL;
... ... @@ -227,7 +205,7 @@
227 205 }
228 206 static int acpi_ec_burst_wait(union acpi_ec *ec, unsigned int event)
229 207 {
230   - int result = 0;
  208 + int result = 0;
231 209  
232 210 ACPI_FUNCTION_TRACE("acpi_ec_wait");
233 211  
... ... @@ -251,9 +229,9 @@
251 229 }
252 230  
253 231 result = wait_event_timeout(ec->burst.wait,
254   - !ec->burst.expect_event,
255   - msecs_to_jiffies(ACPI_EC_DELAY));
256   -
  232 + !ec->burst.expect_event,
  233 + msecs_to_jiffies(ACPI_EC_DELAY));
  234 +
257 235 ec->burst.expect_event = 0;
258 236 smp_mb();
259 237  
260 238  
261 239  
262 240  
263 241  
264 242  
265 243  
266 244  
267 245  
... ... @@ -277,43 +255,37 @@
277 255 return_VALUE(-ETIME);
278 256 }
279 257  
280   -
281   -
282   -static int
283   -acpi_ec_enter_burst_mode (
284   - union acpi_ec *ec)
  258 +static int acpi_ec_enter_burst_mode(union acpi_ec *ec)
285 259 {
286   - u32 tmp = 0;
287   - int status = 0;
  260 + u32 tmp = 0;
  261 + int status = 0;
288 262  
289 263 ACPI_FUNCTION_TRACE("acpi_ec_enter_burst_mode");
290 264  
291 265 status = acpi_ec_read_status(ec);
292   - if (status != -EINVAL &&
293   - !(status & ACPI_EC_FLAG_BURST)){
  266 + if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
294 267 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
295   - if(status)
  268 + if (status)
296 269 goto end;
297   - acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE, &ec->common.command_addr);
  270 + acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE,
  271 + &ec->common.command_addr);
298 272 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
299 273 if (status)
300 274 return_VALUE(-EINVAL);
301 275 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
302   - if(tmp != 0x90 ) {/* Burst ACK byte*/
  276 + if (tmp != 0x90) { /* Burst ACK byte */
303 277 return_VALUE(-EINVAL);
304 278 }
305 279 }
306 280  
307   - atomic_set(&ec->burst.leaving_burst , 0);
  281 + atomic_set(&ec->burst.leaving_burst, 0);
308 282 return_VALUE(0);
309   -end:
  283 + end:
310 284 printk("Error in acpi_ec_wait\n");
311 285 return_VALUE(-1);
312 286 }
313 287  
314   -static int
315   -acpi_ec_leave_burst_mode (
316   - union acpi_ec *ec)
  288 +static int acpi_ec_leave_burst_mode(union acpi_ec *ec)
317 289 {
318 290  
319 291 ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
320 292  
321 293  
322 294  
323 295  
324 296  
... ... @@ -322,38 +294,26 @@
322 294 return_VALUE(0);
323 295 }
324 296  
325   -static int
326   -acpi_ec_read (
327   - union acpi_ec *ec,
328   - u8 address,
329   - u32 *data)
  297 +static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data)
330 298 {
331   - if (acpi_ec_polling_mode)
  299 + if (acpi_ec_polling_mode)
332 300 return acpi_ec_polling_read(ec, address, data);
333 301 else
334 302 return acpi_ec_burst_read(ec, address, data);
335 303 }
336   -static int
337   -acpi_ec_write (
338   - union acpi_ec *ec,
339   - u8 address,
340   - u8 data)
  304 +static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data)
341 305 {
342   - if (acpi_ec_polling_mode)
  306 + if (acpi_ec_polling_mode)
343 307 return acpi_ec_polling_write(ec, address, data);
344 308 else
345 309 return acpi_ec_burst_write(ec, address, data);
346 310 }
347   -static int
348   -acpi_ec_polling_read (
349   - union acpi_ec *ec,
350   - u8 address,
351   - u32 *data)
  311 +static int acpi_ec_polling_read(union acpi_ec *ec, u8 address, u32 * data)
352 312 {
353   - acpi_status status = AE_OK;
354   - int result = 0;
355   - unsigned long flags = 0;
356   - u32 glk = 0;
  313 + acpi_status status = AE_OK;
  314 + int result = 0;
  315 + unsigned long flags = 0;
  316 + u32 glk = 0;
357 317  
358 318 ACPI_FUNCTION_TRACE("acpi_ec_read");
359 319  
... ... @@ -370,7 +330,8 @@
370 330  
371 331 spin_lock_irqsave(&ec->polling.lock, flags);
372 332  
373   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->common.command_addr);
  333 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
  334 + &ec->common.command_addr);
374 335 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
375 336 if (result)
376 337 goto end;
... ... @@ -383,9 +344,9 @@
383 344 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
384 345  
385 346 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
386   - *data, address));
387   -
388   -end:
  347 + *data, address));
  348 +
  349 + end:
389 350 spin_unlock_irqrestore(&ec->polling.lock, flags);
390 351  
391 352 if (ec->common.global_lock)
392 353  
... ... @@ -394,17 +355,12 @@
394 355 return_VALUE(result);
395 356 }
396 357  
397   -
398   -static int
399   -acpi_ec_polling_write (
400   - union acpi_ec *ec,
401   - u8 address,
402   - u8 data)
  358 +static int acpi_ec_polling_write(union acpi_ec *ec, u8 address, u8 data)
403 359 {
404   - int result = 0;
405   - acpi_status status = AE_OK;
406   - unsigned long flags = 0;
407   - u32 glk = 0;
  360 + int result = 0;
  361 + acpi_status status = AE_OK;
  362 + unsigned long flags = 0;
  363 + u32 glk = 0;
408 364  
409 365 ACPI_FUNCTION_TRACE("acpi_ec_write");
410 366  
... ... @@ -419,7 +375,8 @@
419 375  
420 376 spin_lock_irqsave(&ec->polling.lock, flags);
421 377  
422   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->common.command_addr);
  378 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
  379 + &ec->common.command_addr);
423 380 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
424 381 if (result)
425 382 goto end;
426 383  
... ... @@ -435,9 +392,9 @@
435 392 goto end;
436 393  
437 394 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
438   - data, address));
  395 + data, address));
439 396  
440   -end:
  397 + end:
441 398 spin_unlock_irqrestore(&ec->polling.lock, flags);
442 399  
443 400 if (ec->common.global_lock)
444 401  
... ... @@ -446,14 +403,10 @@
446 403 return_VALUE(result);
447 404 }
448 405  
449   -static int
450   -acpi_ec_burst_read (
451   - union acpi_ec *ec,
452   - u8 address,
453   - u32 *data)
  406 +static int acpi_ec_burst_read(union acpi_ec *ec, u8 address, u32 * data)
454 407 {
455   - int status = 0;
456   - u32 glk;
  408 + int status = 0;
  409 + u32 glk;
457 410  
458 411 ACPI_FUNCTION_TRACE("acpi_ec_read");
459 412  
460 413  
461 414  
... ... @@ -477,23 +430,24 @@
477 430 printk("read EC, IB not empty\n");
478 431 goto end;
479 432 }
480   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ, &ec->common.command_addr);
  433 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
  434 + &ec->common.command_addr);
481 435 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
482 436 if (status) {
483 437 printk("read EC, IB not empty\n");
484 438 }
485 439  
486 440 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
487   - status= acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
488   - if (status){
  441 + status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
  442 + if (status) {
489 443 printk("read EC, OB not full\n");
490 444 goto end;
491 445 }
492 446 acpi_hw_low_level_read(8, data, &ec->common.data_addr);
493 447 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
494   - *data, address));
495   -
496   -end:
  448 + *data, address));
  449 +
  450 + end:
497 451 acpi_ec_leave_burst_mode(ec);
498 452 up(&ec->burst.sem);
499 453  
500 454  
... ... @@ -503,15 +457,10 @@
503 457 return_VALUE(status);
504 458 }
505 459  
506   -
507   -static int
508   -acpi_ec_burst_write (
509   - union acpi_ec *ec,
510   - u8 address,
511   - u8 data)
  460 +static int acpi_ec_burst_write(union acpi_ec *ec, u8 address, u8 data)
512 461 {
513   - int status = 0;
514   - u32 glk;
  462 + int status = 0;
  463 + u32 glk;
515 464  
516 465 ACPI_FUNCTION_TRACE("acpi_ec_write");
517 466  
518 467  
519 468  
520 469  
521 470  
... ... @@ -530,25 +479,26 @@
530 479 acpi_ec_enter_burst_mode(ec);
531 480  
532 481 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
533   - if ( status) {
  482 + if (status) {
534 483 printk("write EC, IB not empty\n");
535 484 }
536   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE, &ec->common.command_addr);
  485 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
  486 + &ec->common.command_addr);
537 487 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
538 488 if (status) {
539   - printk ("write EC, IB not empty\n");
  489 + printk("write EC, IB not empty\n");
540 490 }
541 491  
542 492 acpi_hw_low_level_write(8, address, &ec->common.data_addr);
543 493 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
544   - if (status){
  494 + if (status) {
545 495 printk("write EC, IB not empty\n");
546 496 }
547 497  
548 498 acpi_hw_low_level_write(8, data, &ec->common.data_addr);
549 499  
550 500 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
551   - data, address));
  501 + data, address));
552 502  
553 503 acpi_ec_leave_burst_mode(ec);
554 504 up(&ec->burst.sem);
... ... @@ -562,8 +512,7 @@
562 512 /*
563 513 * Externally callable EC access functions. For now, assume 1 EC only
564 514 */
565   -int
566   -ec_read(u8 addr, u8 *val)
  515 +int ec_read(u8 addr, u8 * val)
567 516 {
568 517 union acpi_ec *ec;
569 518 int err;
570 519  
571 520  
... ... @@ -579,14 +528,13 @@
579 528 if (!err) {
580 529 *val = temp_data;
581 530 return 0;
582   - }
583   - else
  531 + } else
584 532 return err;
585 533 }
  534 +
586 535 EXPORT_SYMBOL(ec_read);
587 536  
588   -int
589   -ec_write(u8 addr, u8 val)
  537 +int ec_write(u8 addr, u8 val)
590 538 {
591 539 union acpi_ec *ec;
592 540 int err;
593 541  
594 542  
595 543  
596 544  
... ... @@ -600,27 +548,22 @@
600 548  
601 549 return err;
602 550 }
  551 +
603 552 EXPORT_SYMBOL(ec_write);
604 553  
605   -static int
606   -acpi_ec_query (
607   - union acpi_ec *ec,
608   - u32 *data)
  554 +static int acpi_ec_query(union acpi_ec *ec, u32 * data)
609 555 {
610   - if (acpi_ec_polling_mode)
  556 + if (acpi_ec_polling_mode)
611 557 return acpi_ec_polling_query(ec, data);
612 558 else
613 559 return acpi_ec_burst_query(ec, data);
614 560 }
615   -static int
616   -acpi_ec_polling_query (
617   - union acpi_ec *ec,
618   - u32 *data)
  561 +static int acpi_ec_polling_query(union acpi_ec *ec, u32 * data)
619 562 {
620   - int result = 0;
621   - acpi_status status = AE_OK;
622   - unsigned long flags = 0;
623   - u32 glk = 0;
  563 + int result = 0;
  564 + acpi_status status = AE_OK;
  565 + unsigned long flags = 0;
  566 + u32 glk = 0;
624 567  
625 568 ACPI_FUNCTION_TRACE("acpi_ec_query");
626 569  
... ... @@ -642,7 +585,8 @@
642 585 */
643 586 spin_lock_irqsave(&ec->polling.lock, flags);
644 587  
645   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->common.command_addr);
  588 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
  589 + &ec->common.command_addr);
646 590 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
647 591 if (result)
648 592 goto end;
... ... @@ -651,7 +595,7 @@
651 595 if (!*data)
652 596 result = -ENODATA;
653 597  
654   -end:
  598 + end:
655 599 spin_unlock_irqrestore(&ec->polling.lock, flags);
656 600  
657 601 if (ec->common.global_lock)
658 602  
... ... @@ -659,13 +603,10 @@
659 603  
660 604 return_VALUE(result);
661 605 }
662   -static int
663   -acpi_ec_burst_query (
664   - union acpi_ec *ec,
665   - u32 *data)
  606 +static int acpi_ec_burst_query(union acpi_ec *ec, u32 * data)
666 607 {
667   - int status = 0;
668   - u32 glk;
  608 + int status = 0;
  609 + u32 glk;
669 610  
670 611 ACPI_FUNCTION_TRACE("acpi_ec_query");
671 612  
672 613  
... ... @@ -691,9 +632,10 @@
691 632 * Note that successful completion of the query causes the ACPI_EC_SCI
692 633 * bit to be cleared (and thus clearing the interrupt source).
693 634 */
694   - acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY, &ec->common.command_addr);
  635 + acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
  636 + &ec->common.command_addr);
695 637 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
696   - if (status){
  638 + if (status) {
697 639 printk("query EC, OB not full\n");
698 640 goto end;
699 641 }
... ... @@ -702,7 +644,7 @@
702 644 if (!*data)
703 645 status = -ENODATA;
704 646  
705   -end:
  647 + end:
706 648 up(&ec->burst.sem);
707 649  
708 650 if (ec->common.global_lock)
709 651  
710 652  
711 653  
712 654  
713 655  
... ... @@ -711,36 +653,32 @@
711 653 return_VALUE(status);
712 654 }
713 655  
714   -
715 656 /* --------------------------------------------------------------------------
716 657 Event Management
717 658 -------------------------------------------------------------------------- */
718 659  
719 660 union acpi_ec_query_data {
720   - acpi_handle handle;
721   - u8 data;
  661 + acpi_handle handle;
  662 + u8 data;
722 663 };
723 664  
724   -static void
725   -acpi_ec_gpe_query (
726   - void *ec_cxt)
  665 +static void acpi_ec_gpe_query(void *ec_cxt)
727 666 {
728   - if (acpi_ec_polling_mode)
  667 + if (acpi_ec_polling_mode)
729 668 acpi_ec_gpe_polling_query(ec_cxt);
730 669 else
731 670 acpi_ec_gpe_burst_query(ec_cxt);
732 671 }
733 672  
734   -static void
735   -acpi_ec_gpe_polling_query (
736   - void *ec_cxt)
  673 +static void acpi_ec_gpe_polling_query(void *ec_cxt)
737 674 {
738   - union acpi_ec *ec = (union acpi_ec *) ec_cxt;
739   - u32 value = 0;
740   - unsigned long flags = 0;
741   - static char object_name[5] = {'_','Q','0','0','\0'};
742   - const char hex[] = {'0','1','2','3','4','5','6','7',
743   - '8','9','A','B','C','D','E','F'};
  675 + union acpi_ec *ec = (union acpi_ec *)ec_cxt;
  676 + u32 value = 0;
  677 + unsigned long flags = 0;
  678 + static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
  679 + const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
  680 + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
  681 + };
744 682  
745 683 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
746 684  
747 685  
748 686  
... ... @@ -770,19 +708,18 @@
770 708  
771 709 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
772 710  
773   -end:
  711 + end:
774 712 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
775 713 }
776   -static void
777   -acpi_ec_gpe_burst_query (
778   - void *ec_cxt)
  714 +static void acpi_ec_gpe_burst_query(void *ec_cxt)
779 715 {
780   - union acpi_ec *ec = (union acpi_ec *) ec_cxt;
781   - u32 value;
782   - int result = -ENODATA;
783   - static char object_name[5] = {'_','Q','0','0','\0'};
784   - const char hex[] = {'0','1','2','3','4','5','6','7',
785   - '8','9','A','B','C','D','E','F'};
  716 + union acpi_ec *ec = (union acpi_ec *)ec_cxt;
  717 + u32 value;
  718 + int result = -ENODATA;
  719 + static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
  720 + const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
  721 + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
  722 + };
786 723  
787 724 ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
788 725  
789 726  
790 727  
791 728  
792 729  
793 730  
... ... @@ -798,26 +735,22 @@
798 735 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
799 736  
800 737 acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
801   -end:
  738 + end:
802 739 atomic_dec(&ec->burst.pending_gpe);
803 740 return;
804 741 }
805 742  
806   -static u32
807   -acpi_ec_gpe_handler (
808   - void *data)
  743 +static u32 acpi_ec_gpe_handler(void *data)
809 744 {
810   - if (acpi_ec_polling_mode)
  745 + if (acpi_ec_polling_mode)
811 746 return acpi_ec_gpe_polling_handler(data);
812 747 else
813   - return acpi_ec_gpe_burst_handler(data);
  748 + return acpi_ec_gpe_burst_handler(data);
814 749 }
815   -static u32
816   -acpi_ec_gpe_polling_handler (
817   - void *data)
  750 +static u32 acpi_ec_gpe_polling_handler(void *data)
818 751 {
819   - acpi_status status = AE_OK;
820   - union acpi_ec *ec = (union acpi_ec *) data;
  752 + acpi_status status = AE_OK;
  753 + union acpi_ec *ec = (union acpi_ec *)data;
821 754  
822 755 if (!ec)
823 756 return ACPI_INTERRUPT_NOT_HANDLED;
824 757  
825 758  
... ... @@ -825,20 +758,18 @@
825 758 acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
826 759  
827 760 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
828   - acpi_ec_gpe_query, ec);
  761 + acpi_ec_gpe_query, ec);
829 762  
830 763 if (status == AE_OK)
831 764 return ACPI_INTERRUPT_HANDLED;
832 765 else
833 766 return ACPI_INTERRUPT_NOT_HANDLED;
834 767 }
835   -static u32
836   -acpi_ec_gpe_burst_handler (
837   - void *data)
  768 +static u32 acpi_ec_gpe_burst_handler(void *data)
838 769 {
839   - acpi_status status = AE_OK;
840   - u32 value;
841   - union acpi_ec *ec = (union acpi_ec *) data;
  770 + acpi_status status = AE_OK;
  771 + u32 value;
  772 + union acpi_ec *ec = (union acpi_ec *)data;
842 773  
843 774 if (!ec)
844 775 return ACPI_INTERRUPT_NOT_HANDLED;
... ... @@ -846,7 +777,7 @@
846 777 acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
847 778 value = acpi_ec_read_status(ec);
848 779  
849   - switch ( ec->burst.expect_event) {
  780 + switch (ec->burst.expect_event) {
850 781 case ACPI_EC_EVENT_OBF:
851 782 if (!(value & ACPI_EC_FLAG_OBF))
852 783 break;
853 784  
854 785  
855 786  
... ... @@ -860,16 +791,16 @@
860 791 break;
861 792 }
862 793  
863   - if (value & ACPI_EC_FLAG_SCI){
864   - atomic_add(1, &ec->burst.pending_gpe) ;
  794 + if (value & ACPI_EC_FLAG_SCI) {
  795 + atomic_add(1, &ec->burst.pending_gpe);
865 796 status = acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
866   - acpi_ec_gpe_query, ec);
  797 + acpi_ec_gpe_query, ec);
867 798 return status == AE_OK ?
868   - ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
869   - }
  799 + ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
  800 + }
870 801 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
871 802 return status == AE_OK ?
872   - ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
  803 + ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
873 804 }
874 805  
875 806 /* --------------------------------------------------------------------------
876 807  
877 808  
878 809  
879 810  
... ... @@ -877,37 +808,31 @@
877 808 -------------------------------------------------------------------------- */
878 809  
879 810 static acpi_status
880   -acpi_ec_space_setup (
881   - acpi_handle region_handle,
882   - u32 function,
883   - void *handler_context,
884   - void **return_context)
  811 +acpi_ec_space_setup(acpi_handle region_handle,
  812 + u32 function, void *handler_context, void **return_context)
885 813 {
886 814 /*
887 815 * The EC object is in the handler context and is needed
888 816 * when calling the acpi_ec_space_handler.
889 817 */
890   - *return_context = (function != ACPI_REGION_DEACTIVATE) ?
891   - handler_context : NULL;
  818 + *return_context = (function != ACPI_REGION_DEACTIVATE) ?
  819 + handler_context : NULL;
892 820  
893 821 return AE_OK;
894 822 }
895 823  
896   -
897 824 static acpi_status
898   -acpi_ec_space_handler (
899   - u32 function,
900   - acpi_physical_address address,
901   - u32 bit_width,
902   - acpi_integer *value,
903   - void *handler_context,
904   - void *region_context)
  825 +acpi_ec_space_handler(u32 function,
  826 + acpi_physical_address address,
  827 + u32 bit_width,
  828 + acpi_integer * value,
  829 + void *handler_context, void *region_context)
905 830 {
906   - int result = 0;
907   - union acpi_ec *ec = NULL;
908   - u64 temp = *value;
909   - acpi_integer f_v = 0;
910   - int i = 0;
  831 + int result = 0;
  832 + union acpi_ec *ec = NULL;
  833 + u64 temp = *value;
  834 + acpi_integer f_v = 0;
  835 + int i = 0;
911 836  
912 837 ACPI_FUNCTION_TRACE("acpi_ec_space_handler");
913 838  
914 839  
915 840  
916 841  
... ... @@ -915,17 +840,18 @@
915 840 return_VALUE(AE_BAD_PARAMETER);
916 841  
917 842 if (bit_width != 8 && acpi_strict) {
918   - printk(KERN_WARNING PREFIX "acpi_ec_space_handler: bit_width should be 8\n");
  843 + printk(KERN_WARNING PREFIX
  844 + "acpi_ec_space_handler: bit_width should be 8\n");
919 845 return_VALUE(AE_BAD_PARAMETER);
920 846 }
921 847  
922   - ec = (union acpi_ec *) handler_context;
  848 + ec = (union acpi_ec *)handler_context;
923 849  
924   -next_byte:
  850 + next_byte:
925 851 switch (function) {
926 852 case ACPI_READ:
927 853 temp = 0;
928   - result = acpi_ec_read(ec, (u8) address, (u32 *)&temp);
  854 + result = acpi_ec_read(ec, (u8) address, (u32 *) & temp);
929 855 break;
930 856 case ACPI_WRITE:
931 857 result = acpi_ec_write(ec, (u8) address, (u8) temp);
... ... @@ -952,8 +878,7 @@
952 878 *value = f_v;
953 879 }
954 880  
955   -
956   -out:
  881 + out:
957 882 switch (result) {
958 883 case -EINVAL:
959 884 return_VALUE(AE_BAD_PARAMETER);
960 885  
961 886  
962 887  
... ... @@ -969,18 +894,15 @@
969 894 }
970 895 }
971 896  
972   -
973 897 /* --------------------------------------------------------------------------
974 898 FS Interface (/proc)
975 899 -------------------------------------------------------------------------- */
976 900  
977   -static struct proc_dir_entry *acpi_ec_dir;
  901 +static struct proc_dir_entry *acpi_ec_dir;
978 902  
979   -
980   -static int
981   -acpi_ec_read_info (struct seq_file *seq, void *offset)
  903 +static int acpi_ec_read_info(struct seq_file *seq, void *offset)
982 904 {
983   - union acpi_ec *ec = (union acpi_ec *) seq->private;
  905 + union acpi_ec *ec = (union acpi_ec *)seq->private;
984 906  
985 907 ACPI_FUNCTION_TRACE("acpi_ec_read_info");
986 908  
987 909  
988 910  
989 911  
... ... @@ -988,14 +910,15 @@
988 910 goto end;
989 911  
990 912 seq_printf(seq, "gpe bit: 0x%02x\n",
991   - (u32) ec->common.gpe_bit);
  913 + (u32) ec->common.gpe_bit);
992 914 seq_printf(seq, "ports: 0x%02x, 0x%02x\n",
993   - (u32) ec->common.status_addr.address, (u32) ec->common.data_addr.address);
  915 + (u32) ec->common.status_addr.address,
  916 + (u32) ec->common.data_addr.address);
994 917 seq_printf(seq, "use global lock: %s\n",
995   - ec->common.global_lock?"yes":"no");
  918 + ec->common.global_lock ? "yes" : "no");
996 919 acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
997 920  
998   -end:
  921 + end:
999 922 return_VALUE(0);
1000 923 }
1001 924  
1002 925  
1003 926  
1004 927  
1005 928  
1006 929  
... ... @@ -1005,34 +928,32 @@
1005 928 }
1006 929  
1007 930 static struct file_operations acpi_ec_info_ops = {
1008   - .open = acpi_ec_info_open_fs,
1009   - .read = seq_read,
1010   - .llseek = seq_lseek,
1011   - .release = single_release,
  931 + .open = acpi_ec_info_open_fs,
  932 + .read = seq_read,
  933 + .llseek = seq_lseek,
  934 + .release = single_release,
1012 935 .owner = THIS_MODULE,
1013 936 };
1014 937  
1015   -static int
1016   -acpi_ec_add_fs (
1017   - struct acpi_device *device)
  938 +static int acpi_ec_add_fs(struct acpi_device *device)
1018 939 {
1019   - struct proc_dir_entry *entry = NULL;
  940 + struct proc_dir_entry *entry = NULL;
1020 941  
1021 942 ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
1022 943  
1023 944 if (!acpi_device_dir(device)) {
1024 945 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1025   - acpi_ec_dir);
  946 + acpi_ec_dir);
1026 947 if (!acpi_device_dir(device))
1027 948 return_VALUE(-ENODEV);
1028 949 }
1029 950  
1030 951 entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
1031   - acpi_device_dir(device));
  952 + acpi_device_dir(device));
1032 953 if (!entry)
1033 954 ACPI_DEBUG_PRINT((ACPI_DB_WARN,
1034   - "Unable to create '%s' fs entry\n",
1035   - ACPI_EC_FILE_INFO));
  955 + "Unable to create '%s' fs entry\n",
  956 + ACPI_EC_FILE_INFO));
1036 957 else {
1037 958 entry->proc_fops = &acpi_ec_info_ops;
1038 959 entry->data = acpi_driver_data(device);
... ... @@ -1042,10 +963,7 @@
1042 963 return_VALUE(0);
1043 964 }
1044 965  
1045   -
1046   -static int
1047   -acpi_ec_remove_fs (
1048   - struct acpi_device *device)
  966 +static int acpi_ec_remove_fs(struct acpi_device *device)
1049 967 {
1050 968 ACPI_FUNCTION_TRACE("acpi_ec_remove_fs");
1051 969  
1052 970  
1053 971  
... ... @@ -1058,20 +976,16 @@
1058 976 return_VALUE(0);
1059 977 }
1060 978  
1061   -
1062 979 /* --------------------------------------------------------------------------
1063 980 Driver Interface
1064 981 -------------------------------------------------------------------------- */
1065 982  
1066   -
1067   -static int
1068   -acpi_ec_polling_add (
1069   - struct acpi_device *device)
  983 +static int acpi_ec_polling_add(struct acpi_device *device)
1070 984 {
1071   - int result = 0;
1072   - acpi_status status = AE_OK;
1073   - union acpi_ec *ec = NULL;
1074   - unsigned long uid;
  985 + int result = 0;
  986 + acpi_status status = AE_OK;
  987 + union acpi_ec *ec = NULL;
  988 + unsigned long uid;
1075 989  
1076 990 ACPI_FUNCTION_TRACE("acpi_ec_add");
1077 991  
1078 992  
1079 993  
1080 994  
1081 995  
1082 996  
... ... @@ -1091,26 +1005,31 @@
1091 1005 acpi_driver_data(device) = ec;
1092 1006  
1093 1007 /* Use the global lock for all EC transactions? */
1094   - acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, &ec->common.global_lock);
  1008 + acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
  1009 + &ec->common.global_lock);
1095 1010  
1096 1011 /* If our UID matches the UID for the ECDT-enumerated EC,
1097   - we now have the *real* EC info, so kill the makeshift one.*/
  1012 + we now have the *real* EC info, so kill the makeshift one. */
1098 1013 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid);
1099 1014 if (ec_ecdt && ec_ecdt->common.uid == uid) {
1100 1015 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1101   - ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
1102   -
1103   - acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, &acpi_ec_gpe_handler);
  1016 + ACPI_ADR_SPACE_EC,
  1017 + &acpi_ec_space_handler);
1104 1018  
  1019 + acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
  1020 + &acpi_ec_gpe_handler);
  1021 +
1105 1022 kfree(ec_ecdt);
1106 1023 }
1107 1024  
1108 1025 /* Get GPE bit assignment (EC events). */
1109 1026 /* TODO: Add support for _GPE returning a package */
1110   - status = acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, &ec->common.gpe_bit);
  1027 + status =
  1028 + acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
  1029 + &ec->common.gpe_bit);
1111 1030 if (ACPI_FAILURE(status)) {
1112 1031 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1113   - "Error obtaining GPE bit assignment\n"));
  1032 + "Error obtaining GPE bit assignment\n"));
1114 1033 result = -ENODEV;
1115 1034 goto end;
1116 1035 }
1117 1036  
1118 1037  
1119 1038  
... ... @@ -1120,26 +1039,24 @@
1120 1039 goto end;
1121 1040  
1122 1041 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
1123   - acpi_device_name(device), acpi_device_bid(device),
1124   - (u32) ec->common.gpe_bit);
  1042 + acpi_device_name(device), acpi_device_bid(device),
  1043 + (u32) ec->common.gpe_bit);
1125 1044  
1126 1045 if (!first_ec)
1127 1046 first_ec = device;
1128 1047  
1129   -end:
  1048 + end:
1130 1049 if (result)
1131 1050 kfree(ec);
1132 1051  
1133 1052 return_VALUE(result);
1134 1053 }
1135   -static int
1136   -acpi_ec_burst_add (
1137   - struct acpi_device *device)
  1054 +static int acpi_ec_burst_add(struct acpi_device *device)
1138 1055 {
1139   - int result = 0;
1140   - acpi_status status = AE_OK;
1141   - union acpi_ec *ec = NULL;
1142   - unsigned long uid;
  1056 + int result = 0;
  1057 + acpi_status status = AE_OK;
  1058 + union acpi_ec *ec = NULL;
  1059 + unsigned long uid;
1143 1060  
1144 1061 ACPI_FUNCTION_TRACE("acpi_ec_add");
1145 1062  
1146 1063  
1147 1064  
1148 1065  
1149 1066  
1150 1067  
1151 1068  
... ... @@ -1153,35 +1070,40 @@
1153 1070  
1154 1071 ec->common.handle = device->handle;
1155 1072 ec->common.uid = -1;
1156   - atomic_set(&ec->burst.pending_gpe, 0);
1157   - atomic_set(&ec->burst.leaving_burst , 1);
1158   - init_MUTEX(&ec->burst.sem);
1159   - init_waitqueue_head(&ec->burst.wait);
  1073 + atomic_set(&ec->burst.pending_gpe, 0);
  1074 + atomic_set(&ec->burst.leaving_burst, 1);
  1075 + init_MUTEX(&ec->burst.sem);
  1076 + init_waitqueue_head(&ec->burst.wait);
1160 1077 strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1161 1078 strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1162 1079 acpi_driver_data(device) = ec;
1163 1080  
1164 1081 /* Use the global lock for all EC transactions? */
1165   - acpi_evaluate_integer(ec->common.handle, "_GLK", NULL, &ec->common.global_lock);
  1082 + acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
  1083 + &ec->common.global_lock);
1166 1084  
1167 1085 /* If our UID matches the UID for the ECDT-enumerated EC,
1168   - we now have the *real* EC info, so kill the makeshift one.*/
  1086 + we now have the *real* EC info, so kill the makeshift one. */
1169 1087 acpi_evaluate_integer(ec->common.handle, "_UID", NULL, &uid);
1170 1088 if (ec_ecdt && ec_ecdt->common.uid == uid) {
1171 1089 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1172   - ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
  1090 + ACPI_ADR_SPACE_EC,
  1091 + &acpi_ec_space_handler);
1173 1092  
1174   - acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit, &acpi_ec_gpe_handler);
  1093 + acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
  1094 + &acpi_ec_gpe_handler);
1175 1095  
1176 1096 kfree(ec_ecdt);
1177 1097 }
1178 1098  
1179 1099 /* Get GPE bit assignment (EC events). */
1180 1100 /* TODO: Add support for _GPE returning a package */
1181   - status = acpi_evaluate_integer(ec->common.handle, "_GPE", NULL, &ec->common.gpe_bit);
  1101 + status =
  1102 + acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
  1103 + &ec->common.gpe_bit);
1182 1104 if (ACPI_FAILURE(status)) {
1183 1105 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1184   - "Error obtaining GPE bit assignment\n"));
  1106 + "Error obtaining GPE bit assignment\n"));
1185 1107 result = -ENODEV;
1186 1108 goto end;
1187 1109 }
1188 1110  
1189 1111  
1190 1112  
... ... @@ -1192,26 +1114,22 @@
1192 1114  
1193 1115 printk("burst-mode-ec-10-Aug\n");
1194 1116 printk(KERN_INFO PREFIX "%s [%s] (gpe %d)\n",
1195   - acpi_device_name(device), acpi_device_bid(device),
1196   - (u32) ec->common.gpe_bit);
  1117 + acpi_device_name(device), acpi_device_bid(device),
  1118 + (u32) ec->common.gpe_bit);
1197 1119  
1198 1120 if (!first_ec)
1199 1121 first_ec = device;
1200 1122  
1201   -end:
  1123 + end:
1202 1124 if (result)
1203 1125 kfree(ec);
1204 1126  
1205 1127 return_VALUE(result);
1206 1128 }
1207 1129  
1208   -
1209   -static int
1210   -acpi_ec_remove (
1211   - struct acpi_device *device,
1212   - int type)
  1130 +static int acpi_ec_remove(struct acpi_device *device, int type)
1213 1131 {
1214   - union acpi_ec *ec = NULL;
  1132 + union acpi_ec *ec = NULL;
1215 1133  
1216 1134 ACPI_FUNCTION_TRACE("acpi_ec_remove");
1217 1135  
1218 1136  
1219 1137  
... ... @@ -1227,13 +1145,10 @@
1227 1145 return_VALUE(0);
1228 1146 }
1229 1147  
1230   -
1231 1148 static acpi_status
1232   -acpi_ec_io_ports (
1233   - struct acpi_resource *resource,
1234   - void *context)
  1149 +acpi_ec_io_ports(struct acpi_resource *resource, void *context)
1235 1150 {
1236   - union acpi_ec *ec = (union acpi_ec *) context;
  1151 + union acpi_ec *ec = (union acpi_ec *)context;
1237 1152 struct acpi_generic_address *addr;
1238 1153  
1239 1154 if (resource->id != ACPI_RSTYPE_IO) {
1240 1155  
... ... @@ -1261,13 +1176,10 @@
1261 1176 return AE_OK;
1262 1177 }
1263 1178  
1264   -
1265   -static int
1266   -acpi_ec_start (
1267   - struct acpi_device *device)
  1179 +static int acpi_ec_start(struct acpi_device *device)
1268 1180 {
1269   - acpi_status status = AE_OK;
1270   - union acpi_ec *ec = NULL;
  1181 + acpi_status status = AE_OK;
  1182 + union acpi_ec *ec = NULL;
1271 1183  
1272 1184 ACPI_FUNCTION_TRACE("acpi_ec_start");
1273 1185  
1274 1186  
1275 1187  
1276 1188  
1277 1189  
1278 1190  
1279 1191  
1280 1192  
1281 1193  
... ... @@ -1283,49 +1195,50 @@
1283 1195 * Get I/O port addresses. Convert to GAS format.
1284 1196 */
1285 1197 status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
1286   - acpi_ec_io_ports, ec);
1287   - if (ACPI_FAILURE(status) || ec->common.command_addr.register_bit_width == 0) {
1288   - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses"));
  1198 + acpi_ec_io_ports, ec);
  1199 + if (ACPI_FAILURE(status)
  1200 + || ec->common.command_addr.register_bit_width == 0) {
  1201 + ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  1202 + "Error getting I/O port addresses"));
1289 1203 return_VALUE(-ENODEV);
1290 1204 }
1291 1205  
1292 1206 ec->common.status_addr = ec->common.command_addr;
1293 1207  
1294 1208 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
1295   - (u32) ec->common.gpe_bit, (u32) ec->common.command_addr.address,
1296   - (u32) ec->common.data_addr.address));
  1209 + (u32) ec->common.gpe_bit,
  1210 + (u32) ec->common.command_addr.address,
  1211 + (u32) ec->common.data_addr.address));
1297 1212  
1298   -
1299 1213 /*
1300 1214 * Install GPE handler
1301 1215 */
1302 1216 status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
1303   - ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec);
  1217 + ACPI_GPE_EDGE_TRIGGERED,
  1218 + &acpi_ec_gpe_handler, ec);
1304 1219 if (ACPI_FAILURE(status)) {
1305 1220 return_VALUE(-ENODEV);
1306 1221 }
1307   - acpi_set_gpe_type (NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1308   - acpi_enable_gpe (NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
  1222 + acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
  1223 + acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1309 1224  
1310   - status = acpi_install_address_space_handler (ec->common.handle,
1311   - ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
1312   - &acpi_ec_space_setup, ec);
  1225 + status = acpi_install_address_space_handler(ec->common.handle,
  1226 + ACPI_ADR_SPACE_EC,
  1227 + &acpi_ec_space_handler,
  1228 + &acpi_ec_space_setup, ec);
1313 1229 if (ACPI_FAILURE(status)) {
1314   - acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
  1230 + acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
  1231 + &acpi_ec_gpe_handler);
1315 1232 return_VALUE(-ENODEV);
1316 1233 }
1317 1234  
1318 1235 return_VALUE(AE_OK);
1319 1236 }
1320 1237  
1321   -
1322   -static int
1323   -acpi_ec_stop (
1324   - struct acpi_device *device,
1325   - int type)
  1238 +static int acpi_ec_stop(struct acpi_device *device, int type)
1326 1239 {
1327   - acpi_status status = AE_OK;
1328   - union acpi_ec *ec = NULL;
  1240 + acpi_status status = AE_OK;
  1241 + union acpi_ec *ec = NULL;
1329 1242  
1330 1243 ACPI_FUNCTION_TRACE("acpi_ec_stop");
1331 1244  
1332 1245  
... ... @@ -1335,11 +1248,14 @@
1335 1248 ec = acpi_driver_data(device);
1336 1249  
1337 1250 status = acpi_remove_address_space_handler(ec->common.handle,
1338   - ACPI_ADR_SPACE_EC, &acpi_ec_space_handler);
  1251 + ACPI_ADR_SPACE_EC,
  1252 + &acpi_ec_space_handler);
1339 1253 if (ACPI_FAILURE(status))
1340 1254 return_VALUE(-ENODEV);
1341 1255  
1342   - status = acpi_remove_gpe_handler(NULL, ec->common.gpe_bit, &acpi_ec_gpe_handler);
  1256 + status =
  1257 + acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
  1258 + &acpi_ec_gpe_handler);
1343 1259 if (ACPI_FAILURE(status))
1344 1260 return_VALUE(-ENODEV);
1345 1261  
1346 1262  
1347 1263  
1348 1264  
1349 1265  
1350 1266  
... ... @@ -1347,32 +1263,26 @@
1347 1263 }
1348 1264  
1349 1265 static acpi_status __init
1350   -acpi_fake_ecdt_callback (
1351   - acpi_handle handle,
1352   - u32 Level,
1353   - void *context,
1354   - void **retval)
  1266 +acpi_fake_ecdt_callback(acpi_handle handle,
  1267 + u32 Level, void *context, void **retval)
1355 1268 {
1356 1269  
1357 1270 if (acpi_ec_polling_mode)
1358 1271 return acpi_fake_ecdt_polling_callback(handle,
1359   - Level, context, retval);
  1272 + Level, context, retval);
1360 1273 else
1361 1274 return acpi_fake_ecdt_burst_callback(handle,
1362   - Level, context, retval);
  1275 + Level, context, retval);
1363 1276 }
1364 1277  
1365 1278 static acpi_status __init
1366   -acpi_fake_ecdt_polling_callback (
1367   - acpi_handle handle,
1368   - u32 Level,
1369   - void *context,
1370   - void **retval)
  1279 +acpi_fake_ecdt_polling_callback(acpi_handle handle,
  1280 + u32 Level, void *context, void **retval)
1371 1281 {
1372   - acpi_status status;
  1282 + acpi_status status;
1373 1283  
1374 1284 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1375   - acpi_ec_io_ports, ec_ecdt);
  1285 + acpi_ec_io_ports, ec_ecdt);
1376 1286 if (ACPI_FAILURE(status))
1377 1287 return status;
1378 1288 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1379 1289  
1380 1290  
1381 1291  
1382 1292  
... ... @@ -1380,33 +1290,33 @@
1380 1290 ec_ecdt->common.uid = -1;
1381 1291 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1382 1292  
1383   - status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->common.gpe_bit);
  1293 + status =
  1294 + acpi_evaluate_integer(handle, "_GPE", NULL,
  1295 + &ec_ecdt->common.gpe_bit);
1384 1296 if (ACPI_FAILURE(status))
1385 1297 return status;
1386 1298 spin_lock_init(&ec_ecdt->polling.lock);
1387 1299 ec_ecdt->common.global_lock = TRUE;
1388 1300 ec_ecdt->common.handle = handle;
1389 1301  
1390   - printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1391   - (u32) ec_ecdt->common.gpe_bit, (u32) ec_ecdt->common.command_addr.address,
1392   - (u32) ec_ecdt->common.data_addr.address);
  1302 + printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
  1303 + (u32) ec_ecdt->common.gpe_bit,
  1304 + (u32) ec_ecdt->common.command_addr.address,
  1305 + (u32) ec_ecdt->common.data_addr.address);
1393 1306  
1394 1307 return AE_CTRL_TERMINATE;
1395 1308 }
1396 1309  
1397 1310 static acpi_status __init
1398   -acpi_fake_ecdt_burst_callback (
1399   - acpi_handle handle,
1400   - u32 Level,
1401   - void *context,
1402   - void **retval)
  1311 +acpi_fake_ecdt_burst_callback(acpi_handle handle,
  1312 + u32 Level, void *context, void **retval)
1403 1313 {
1404   - acpi_status status;
  1314 + acpi_status status;
1405 1315  
1406 1316 init_MUTEX(&ec_ecdt->burst.sem);
1407 1317 init_waitqueue_head(&ec_ecdt->burst.wait);
1408 1318 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1409   - acpi_ec_io_ports, ec_ecdt);
  1319 + acpi_ec_io_ports, ec_ecdt);
1410 1320 if (ACPI_FAILURE(status))
1411 1321 return status;
1412 1322 ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1413 1323  
... ... @@ -1414,15 +1324,18 @@
1414 1324 ec_ecdt->common.uid = -1;
1415 1325 acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1416 1326  
1417   - status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec_ecdt->common.gpe_bit);
  1327 + status =
  1328 + acpi_evaluate_integer(handle, "_GPE", NULL,
  1329 + &ec_ecdt->common.gpe_bit);
1418 1330 if (ACPI_FAILURE(status))
1419 1331 return status;
1420 1332 ec_ecdt->common.global_lock = TRUE;
1421 1333 ec_ecdt->common.handle = handle;
1422 1334  
1423   - printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1424   - (u32) ec_ecdt->common.gpe_bit, (u32) ec_ecdt->common.command_addr.address,
1425   - (u32) ec_ecdt->common.data_addr.address);
  1335 + printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
  1336 + (u32) ec_ecdt->common.gpe_bit,
  1337 + (u32) ec_ecdt->common.command_addr.address,
  1338 + (u32) ec_ecdt->common.data_addr.address);
1426 1339  
1427 1340 return AE_CTRL_TERMINATE;
1428 1341 }
1429 1342  
... ... @@ -1437,11 +1350,10 @@
1437 1350 * op region (since _REG isn't invoked yet). The assumption is true for
1438 1351 * all systems found.
1439 1352 */
1440   -static int __init
1441   -acpi_ec_fake_ecdt(void)
  1353 +static int __init acpi_ec_fake_ecdt(void)
1442 1354 {
1443   - acpi_status status;
1444   - int ret = 0;
  1355 + acpi_status status;
  1356 + int ret = 0;
1445 1357  
1446 1358 printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1447 1359  
... ... @@ -1452,10 +1364,8 @@
1452 1364 }
1453 1365 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1454 1366  
1455   - status = acpi_get_devices (ACPI_EC_HID,
1456   - acpi_fake_ecdt_callback,
1457   - NULL,
1458   - NULL);
  1367 + status = acpi_get_devices(ACPI_EC_HID,
  1368 + acpi_fake_ecdt_callback, NULL, NULL);
1459 1369 if (ACPI_FAILURE(status)) {
1460 1370 kfree(ec_ecdt);
1461 1371 ec_ecdt = NULL;
1462 1372  
... ... @@ -1463,13 +1373,12 @@
1463 1373 goto error;
1464 1374 }
1465 1375 return 0;
1466   -error:
  1376 + error:
1467 1377 printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1468 1378 return ret;
1469 1379 }
1470 1380  
1471   -static int __init
1472   -acpi_ec_get_real_ecdt(void)
  1381 +static int __init acpi_ec_get_real_ecdt(void)
1473 1382 {
1474 1383 if (acpi_ec_polling_mode)
1475 1384 return acpi_ec_polling_get_real_ecdt();
1476 1385  
1477 1386  
... ... @@ -1477,14 +1386,14 @@
1477 1386 return acpi_ec_burst_get_real_ecdt();
1478 1387 }
1479 1388  
1480   -static int __init
1481   -acpi_ec_polling_get_real_ecdt(void)
  1389 +static int __init acpi_ec_polling_get_real_ecdt(void)
1482 1390 {
1483   - acpi_status status;
1484   - struct acpi_table_ecdt *ecdt_ptr;
  1391 + acpi_status status;
  1392 + struct acpi_table_ecdt *ecdt_ptr;
1485 1393  
1486   - status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1487   - (struct acpi_table_header **) &ecdt_ptr);
  1394 + status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
  1395 + (struct acpi_table_header **)
  1396 + &ecdt_ptr);
1488 1397 if (ACPI_FAILURE(status))
1489 1398 return -ENODEV;
1490 1399  
1491 1400  
... ... @@ -1507,13 +1416,14 @@
1507 1416 ec_ecdt->common.global_lock = TRUE;
1508 1417 ec_ecdt->common.uid = ecdt_ptr->uid;
1509 1418  
1510   - status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
  1419 + status =
  1420 + acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1511 1421 if (ACPI_FAILURE(status)) {
1512 1422 goto error;
1513 1423 }
1514 1424  
1515 1425 return 0;
1516   -error:
  1426 + error:
1517 1427 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1518 1428 kfree(ec_ecdt);
1519 1429 ec_ecdt = NULL;
1520 1430  
1521 1431  
... ... @@ -1521,15 +1431,14 @@
1521 1431 return -ENODEV;
1522 1432 }
1523 1433  
1524   -
1525   -static int __init
1526   -acpi_ec_burst_get_real_ecdt(void)
  1434 +static int __init acpi_ec_burst_get_real_ecdt(void)
1527 1435 {
1528   - acpi_status status;
1529   - struct acpi_table_ecdt *ecdt_ptr;
  1436 + acpi_status status;
  1437 + struct acpi_table_ecdt *ecdt_ptr;
1530 1438  
1531 1439 status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1532   - (struct acpi_table_header **) &ecdt_ptr);
  1440 + (struct acpi_table_header **)
  1441 + &ecdt_ptr);
1533 1442 if (ACPI_FAILURE(status))
1534 1443 return -ENODEV;
1535 1444  
... ... @@ -1543,8 +1452,8 @@
1543 1452 return -ENOMEM;
1544 1453 memset(ec_ecdt, 0, sizeof(union acpi_ec));
1545 1454  
1546   - init_MUTEX(&ec_ecdt->burst.sem);
1547   - init_waitqueue_head(&ec_ecdt->burst.wait);
  1455 + init_MUTEX(&ec_ecdt->burst.sem);
  1456 + init_waitqueue_head(&ec_ecdt->burst.wait);
1548 1457 ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1549 1458 ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1550 1459 ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1551 1460  
... ... @@ -1553,13 +1462,14 @@
1553 1462 ec_ecdt->common.global_lock = TRUE;
1554 1463 ec_ecdt->common.uid = ecdt_ptr->uid;
1555 1464  
1556   - status = acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
  1465 + status =
  1466 + acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1557 1467 if (ACPI_FAILURE(status)) {
1558 1468 goto error;
1559 1469 }
1560 1470  
1561 1471 return 0;
1562   -error:
  1472 + error:
1563 1473 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1564 1474 kfree(ec_ecdt);
1565 1475 ec_ecdt = NULL;
1566 1476  
... ... @@ -1568,11 +1478,10 @@
1568 1478 }
1569 1479  
1570 1480 static int __initdata acpi_fake_ecdt_enabled;
1571   -int __init
1572   -acpi_ec_ecdt_probe (void)
  1481 +int __init acpi_ec_ecdt_probe(void)
1573 1482 {
1574   - acpi_status status;
1575   - int ret;
  1483 + acpi_status status;
  1484 + int ret;
1576 1485  
1577 1486 ret = acpi_ec_get_real_ecdt();
1578 1487 /* Try to make a fake ECDT */
1579 1488  
1580 1489  
1581 1490  
1582 1491  
... ... @@ -1587,26 +1496,28 @@
1587 1496 * Install GPE handler
1588 1497 */
1589 1498 status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1590   - ACPI_GPE_EDGE_TRIGGERED, &acpi_ec_gpe_handler,
1591   - ec_ecdt);
  1499 + ACPI_GPE_EDGE_TRIGGERED,
  1500 + &acpi_ec_gpe_handler, ec_ecdt);
1592 1501 if (ACPI_FAILURE(status)) {
1593 1502 goto error;
1594 1503 }
1595   - acpi_set_gpe_type (NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1596   - acpi_enable_gpe (NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
  1504 + acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
  1505 + acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1597 1506  
1598   - status = acpi_install_address_space_handler (ACPI_ROOT_OBJECT,
1599   - ACPI_ADR_SPACE_EC, &acpi_ec_space_handler,
1600   - &acpi_ec_space_setup, ec_ecdt);
  1507 + status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
  1508 + ACPI_ADR_SPACE_EC,
  1509 + &acpi_ec_space_handler,
  1510 + &acpi_ec_space_setup,
  1511 + ec_ecdt);
1601 1512 if (ACPI_FAILURE(status)) {
1602 1513 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1603   - &acpi_ec_gpe_handler);
  1514 + &acpi_ec_gpe_handler);
1604 1515 goto error;
1605 1516 }
1606 1517  
1607 1518 return 0;
1608 1519  
1609   -error:
  1520 + error:
1610 1521 printk(KERN_ERR PREFIX "Could not use ECDT\n");
1611 1522 kfree(ec_ecdt);
1612 1523 ec_ecdt = NULL;
1613 1524  
... ... @@ -1614,10 +1525,9 @@
1614 1525 return -ENODEV;
1615 1526 }
1616 1527  
1617   -
1618   -static int __init acpi_ec_init (void)
  1528 +static int __init acpi_ec_init(void)
1619 1529 {
1620   - int result = 0;
  1530 + int result = 0;
1621 1531  
1622 1532 ACPI_FUNCTION_TRACE("acpi_ec_init");
1623 1533  
... ... @@ -1642,8 +1552,7 @@
1642 1552  
1643 1553 /* EC driver currently not unloadable */
1644 1554 #if 0
1645   -static void __exit
1646   -acpi_ec_exit (void)
  1555 +static void __exit acpi_ec_exit(void)
1647 1556 {
1648 1557 ACPI_FUNCTION_TRACE("acpi_ec_exit");
1649 1558  
... ... @@ -1653,7 +1562,7 @@
1653 1562  
1654 1563 return_VOID;
1655 1564 }
1656   -#endif /* 0 */
  1565 +#endif /* 0 */
1657 1566  
1658 1567 static int __init acpi_fake_ecdt_setup(char *str)
1659 1568 {
1660 1569  
... ... @@ -1676,9 +1585,9 @@
1676 1585 acpi_ec_polling_mode = EC_POLLING;
1677 1586 acpi_ec_driver.ops.add = acpi_ec_polling_add;
1678 1587 }
1679   - printk(KERN_INFO PREFIX "EC %s mode.\n",
1680   - burst ? "burst": "polling");
  1588 + printk(KERN_INFO PREFIX "EC %s mode.\n", burst ? "burst" : "polling");
1681 1589 return 0;
1682 1590 }
  1591 +
1683 1592 __setup("ec_burst=", acpi_ec_set_polling_mode);