1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
24#include <linux/dmi.h>
25#include <linux/init.h>
26#include <linux/ioport.h>
27#include <linux/kernel.h>
28#include <linux/leds.h>
29#include <linux/module.h>
30#include <linux/pci.h>
31#include <linux/types.h>
32#include <linux/uaccess.h>
33
34MODULE_AUTHOR("Rodney Girod <rgirod@confocus.com>, Dave Hansen <dave@sr71.net>");
35MODULE_DESCRIPTION("Intel NAS/Home Server ICH7 GPIO Driver");
36MODULE_LICENSE("GPL");
37
38
39
40
41#define PMBASE 0x040
42#define GPIO_BASE 0x048
43#define GPIO_CTRL 0x04c
44#define GPIO_EN 0x010
45
46
47
48
49#define ICH7_GPIO_SIZE 64
50
51
52
53
54#define GPIO_USE_SEL 0x000
55#define GP_IO_SEL 0x004
56#define GP_LVL 0x00c
57#define GPO_BLINK 0x018
58#define GPI_INV 0x030
59#define GPIO_USE_SEL2 0x034
60#define GP_IO_SEL2 0x038
61#define GP_LVL2 0x03c
62
63
64
65
66static const struct pci_device_id ich7_lpc_pci_id[] = {
67 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0) },
68 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_1) },
69 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_30) },
70 { }
71};
72
73MODULE_DEVICE_TABLE(pci, ich7_lpc_pci_id);
74
75static int __init ss4200_led_dmi_callback(const struct dmi_system_id *id)
76{
77 pr_info("detected '%s'\n", id->ident);
78 return 1;
79}
80
81static bool nodetect;
82module_param_named(nodetect, nodetect, bool, 0);
83MODULE_PARM_DESC(nodetect, "Skip DMI-based hardware detection");
84
85
86
87
88
89
90
91
92
93
94static struct dmi_system_id nas_led_whitelist[] __initdata = {
95 {
96 .callback = ss4200_led_dmi_callback,
97 .ident = "Intel SS4200-E",
98 .matches = {
99 DMI_MATCH(DMI_SYS_VENDOR, "Intel"),
100 DMI_MATCH(DMI_PRODUCT_NAME, "SS4200-E"),
101 DMI_MATCH(DMI_PRODUCT_VERSION, "1.00.00")
102 }
103 },
104 {
105
106
107
108
109 .callback = ss4200_led_dmi_callback,
110 .ident = "Fujitsu Siemens SCALEO Home Server",
111 .matches = {
112 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
113 DMI_MATCH(DMI_PRODUCT_NAME, "SCALEO Home Server"),
114 DMI_MATCH(DMI_PRODUCT_VERSION, "1.00.00")
115 }
116 },
117 {}
118};
119
120
121
122
123static u32 g_pm_io_base;
124
125
126
127
128static u32 nas_gpio_io_base;
129
130
131
132
133
134
135static struct resource *gp_gpio_resource;
136
137struct nasgpio_led {
138 char *name;
139 u32 gpio_bit;
140 struct led_classdev led_cdev;
141};
142
143
144
145
146static struct nasgpio_led nasgpio_leds[] = {
147 { .name = "hdd1:blue:sata", .gpio_bit = 0 },
148 { .name = "hdd1:amber:sata", .gpio_bit = 1 },
149 { .name = "hdd2:blue:sata", .gpio_bit = 2 },
150 { .name = "hdd2:amber:sata", .gpio_bit = 3 },
151 { .name = "hdd3:blue:sata", .gpio_bit = 4 },
152 { .name = "hdd3:amber:sata", .gpio_bit = 5 },
153 { .name = "hdd4:blue:sata", .gpio_bit = 6 },
154 { .name = "hdd4:amber:sata", .gpio_bit = 7 },
155 { .name = "power:blue:power", .gpio_bit = 27},
156 { .name = "power:amber:power", .gpio_bit = 28},
157};
158
159#define NAS_RECOVERY 0x00000400
160
161static struct nasgpio_led *
162led_classdev_to_nasgpio_led(struct led_classdev *led_cdev)
163{
164 return container_of(led_cdev, struct nasgpio_led, led_cdev);
165}
166
167static struct nasgpio_led *get_led_named(char *name)
168{
169 int i;
170 for (i = 0; i < ARRAY_SIZE(nasgpio_leds); i++) {
171 if (strcmp(nasgpio_leds[i].name, name))
172 continue;
173 return &nasgpio_leds[i];
174 }
175 return NULL;
176}
177
178
179
180
181static DEFINE_SPINLOCK(nasgpio_gpio_lock);
182
183
184
185
186
187
188
189
190static void __nasgpio_led_set_attr(struct led_classdev *led_cdev,
191 u32 port, u32 value)
192{
193 struct nasgpio_led *led = led_classdev_to_nasgpio_led(led_cdev);
194 u32 gpio_out;
195
196 gpio_out = inl(nas_gpio_io_base + port);
197 if (value)
198 gpio_out |= (1<<led->gpio_bit);
199 else
200 gpio_out &= ~(1<<led->gpio_bit);
201
202 outl(gpio_out, nas_gpio_io_base + port);
203}
204
205static void nasgpio_led_set_attr(struct led_classdev *led_cdev,
206 u32 port, u32 value)
207{
208 spin_lock(&nasgpio_gpio_lock);
209 __nasgpio_led_set_attr(led_cdev, port, value);
210 spin_unlock(&nasgpio_gpio_lock);
211}
212
213static u32 nasgpio_led_get_attr(struct led_classdev *led_cdev, u32 port)
214{
215 struct nasgpio_led *led = led_classdev_to_nasgpio_led(led_cdev);
216 u32 gpio_in;
217
218 spin_lock(&nasgpio_gpio_lock);
219 gpio_in = inl(nas_gpio_io_base + port);
220 spin_unlock(&nasgpio_gpio_lock);
221 if (gpio_in & (1<<led->gpio_bit))
222 return 1;
223 return 0;
224}
225
226
227
228
229
230
231static void nasgpio_led_set_brightness(struct led_classdev *led_cdev,
232 enum led_brightness brightness)
233{
234 u32 setting = 0;
235 if (brightness >= LED_HALF)
236 setting = 1;
237
238
239
240
241
242 spin_lock(&nasgpio_gpio_lock);
243
244
245
246
247 if (brightness == 0)
248 __nasgpio_led_set_attr(led_cdev, GPO_BLINK, 0);
249 __nasgpio_led_set_attr(led_cdev, GP_LVL, setting);
250 spin_unlock(&nasgpio_gpio_lock);
251}
252
253static int nasgpio_led_set_blink(struct led_classdev *led_cdev,
254 unsigned long *delay_on,
255 unsigned long *delay_off)
256{
257 u32 setting = 1;
258 if (!(*delay_on == 0 && *delay_off == 0) &&
259 !(*delay_on == 500 && *delay_off == 500))
260 return -EINVAL;
261
262
263
264 *delay_on = 500;
265 *delay_off = 500;
266
267 nasgpio_led_set_attr(led_cdev, GPO_BLINK, setting);
268
269 return 0;
270}
271
272
273
274
275
276
277
278static int ich7_gpio_init(struct device *dev)
279{
280 int i;
281 u32 config_data = 0;
282 u32 all_nas_led = 0;
283
284 for (i = 0; i < ARRAY_SIZE(nasgpio_leds); i++)
285 all_nas_led |= (1<<nasgpio_leds[i].gpio_bit);
286
287 spin_lock(&nasgpio_gpio_lock);
288
289
290
291
292
293
294 config_data = inl(nas_gpio_io_base + GPIO_USE_SEL);
295 dev_dbg(dev, ": Data read from GPIO_USE_SEL = 0x%08x\n", config_data);
296 config_data |= all_nas_led + NAS_RECOVERY;
297 outl(config_data, nas_gpio_io_base + GPIO_USE_SEL);
298 config_data = inl(nas_gpio_io_base + GPIO_USE_SEL);
299 dev_dbg(dev, ": GPIO_USE_SEL = 0x%08x\n\n", config_data);
300
301
302
303
304
305
306
307 config_data = inl(nas_gpio_io_base + GP_IO_SEL);
308 dev_dbg(dev, ": Data read from GP_IO_SEL = 0x%08x\n",
309 config_data);
310 config_data &= ~all_nas_led;
311 config_data |= NAS_RECOVERY;
312 outl(config_data, nas_gpio_io_base + GP_IO_SEL);
313 config_data = inl(nas_gpio_io_base + GP_IO_SEL);
314 dev_dbg(dev, ": GP_IO_SEL = 0x%08x\n", config_data);
315
316
317
318
319
320 config_data = inl(nas_gpio_io_base + GP_LVL);
321 dev_dbg(dev, ": Data read from GP_LVL = 0x%08x\n", config_data);
322
323
324
325
326 config_data = inl(nas_gpio_io_base + GPO_BLINK);
327 dev_dbg(dev, ": Data read from GPO_BLINK = 0x%08x\n", config_data);
328
329
330
331
332 config_data = inl(nas_gpio_io_base + GPI_INV);
333 dev_dbg(dev, ": Data read from GPI_INV = 0x%08x\n", config_data);
334
335 spin_unlock(&nasgpio_gpio_lock);
336 return 0;
337}
338
339static void ich7_lpc_cleanup(struct device *dev)
340{
341
342
343
344
345 if (gp_gpio_resource) {
346 dev_dbg(dev, ": Releasing GPIO I/O addresses\n");
347 release_region(nas_gpio_io_base, ICH7_GPIO_SIZE);
348 gp_gpio_resource = NULL;
349 }
350}
351
352
353
354
355
356static struct pci_dev *nas_gpio_pci_dev;
357static int ich7_lpc_probe(struct pci_dev *dev,
358 const struct pci_device_id *id)
359{
360 int status;
361 u32 gc = 0;
362
363 status = pci_enable_device(dev);
364 if (status) {
365 dev_err(&dev->dev, "pci_enable_device failed\n");
366 return -EIO;
367 }
368
369 nas_gpio_pci_dev = dev;
370 status = pci_read_config_dword(dev, PMBASE, &g_pm_io_base);
371 if (status)
372 goto out;
373 g_pm_io_base &= 0x00000ff80;
374
375 status = pci_read_config_dword(dev, GPIO_CTRL, &gc);
376 if (!(GPIO_EN & gc)) {
377 status = -EEXIST;
378 dev_info(&dev->dev,
379 "ERROR: The LPC GPIO Block has not been enabled.\n");
380 goto out;
381 }
382
383 status = pci_read_config_dword(dev, GPIO_BASE, &nas_gpio_io_base);
384 if (0 > status) {
385 dev_info(&dev->dev, "Unable to read GPIOBASE.\n");
386 goto out;
387 }
388 dev_dbg(&dev->dev, ": GPIOBASE = 0x%08x\n", nas_gpio_io_base);
389 nas_gpio_io_base &= 0x00000ffc0;
390
391
392
393
394 gp_gpio_resource = request_region(nas_gpio_io_base, ICH7_GPIO_SIZE,
395 KBUILD_MODNAME);
396 if (NULL == gp_gpio_resource) {
397 dev_info(&dev->dev,
398 "ERROR Unable to register GPIO I/O addresses.\n");
399 status = -1;
400 goto out;
401 }
402
403
404
405
406 ich7_gpio_init(&dev->dev);
407
408out:
409 if (status) {
410 ich7_lpc_cleanup(&dev->dev);
411 pci_disable_device(dev);
412 }
413 return status;
414}
415
416static void ich7_lpc_remove(struct pci_dev *dev)
417{
418 ich7_lpc_cleanup(&dev->dev);
419 pci_disable_device(dev);
420}
421
422
423
424
425static struct pci_driver nas_gpio_pci_driver = {
426 .name = KBUILD_MODNAME,
427 .id_table = ich7_lpc_pci_id,
428 .probe = ich7_lpc_probe,
429 .remove = ich7_lpc_remove,
430};
431
432static struct led_classdev *get_classdev_for_led_nr(int nr)
433{
434 struct nasgpio_led *nas_led = &nasgpio_leds[nr];
435 struct led_classdev *led = &nas_led->led_cdev;
436 return led;
437}
438
439
440static void set_power_light_amber_noblink(void)
441{
442 struct nasgpio_led *amber = get_led_named("power:amber:power");
443 struct nasgpio_led *blue = get_led_named("power:blue:power");
444
445 if (!amber || !blue)
446 return;
447
448
449
450 pr_debug("setting blue off and amber on\n");
451
452 nasgpio_led_set_brightness(&blue->led_cdev, LED_OFF);
453 nasgpio_led_set_brightness(&amber->led_cdev, LED_FULL);
454}
455
456static ssize_t nas_led_blink_show(struct device *dev,
457 struct device_attribute *attr, char *buf)
458{
459 struct led_classdev *led = dev_get_drvdata(dev);
460 int blinking = 0;
461 if (nasgpio_led_get_attr(led, GPO_BLINK))
462 blinking = 1;
463 return sprintf(buf, "%u\n", blinking);
464}
465
466static ssize_t nas_led_blink_store(struct device *dev,
467 struct device_attribute *attr,
468 const char *buf, size_t size)
469{
470 int ret;
471 struct led_classdev *led = dev_get_drvdata(dev);
472 unsigned long blink_state;
473
474 ret = kstrtoul(buf, 10, &blink_state);
475 if (ret)
476 return ret;
477
478 nasgpio_led_set_attr(led, GPO_BLINK, blink_state);
479
480 return size;
481}
482
483static DEVICE_ATTR(blink, 0644, nas_led_blink_show, nas_led_blink_store);
484
485static struct attribute *nasgpio_led_attrs[] = {
486 &dev_attr_blink.attr,
487 NULL
488};
489ATTRIBUTE_GROUPS(nasgpio_led);
490
491static int register_nasgpio_led(int led_nr)
492{
493 int ret;
494 struct nasgpio_led *nas_led = &nasgpio_leds[led_nr];
495 struct led_classdev *led = get_classdev_for_led_nr(led_nr);
496
497 led->name = nas_led->name;
498 led->brightness = LED_OFF;
499 if (nasgpio_led_get_attr(led, GP_LVL))
500 led->brightness = LED_FULL;
501 led->brightness_set = nasgpio_led_set_brightness;
502 led->blink_set = nasgpio_led_set_blink;
503 led->groups = nasgpio_led_groups;
504 ret = led_classdev_register(&nas_gpio_pci_dev->dev, led);
505 if (ret)
506 return ret;
507
508 return 0;
509}
510
511static void unregister_nasgpio_led(int led_nr)
512{
513 struct led_classdev *led = get_classdev_for_led_nr(led_nr);
514 led_classdev_unregister(led);
515}
516
517
518
519static int __init nas_gpio_init(void)
520{
521 int i;
522 int ret = 0;
523 int nr_devices = 0;
524
525 nr_devices = dmi_check_system(nas_led_whitelist);
526 if (nodetect) {
527 pr_info("skipping hardware autodetection\n");
528 pr_info("Please send 'dmidecode' output to dave@sr71.net\n");
529 nr_devices++;
530 }
531
532 if (nr_devices <= 0) {
533 pr_info("no LED devices found\n");
534 return -ENODEV;
535 }
536
537 pr_info("registering PCI driver\n");
538 ret = pci_register_driver(&nas_gpio_pci_driver);
539 if (ret)
540 return ret;
541 for (i = 0; i < ARRAY_SIZE(nasgpio_leds); i++) {
542 ret = register_nasgpio_led(i);
543 if (ret)
544 goto out_err;
545 }
546
547
548
549
550
551 set_power_light_amber_noblink();
552 return 0;
553out_err:
554 for (i--; i >= 0; i--)
555 unregister_nasgpio_led(i);
556 pci_unregister_driver(&nas_gpio_pci_driver);
557 return ret;
558}
559
560
561
562
563static void __exit nas_gpio_exit(void)
564{
565 int i;
566 pr_info("Unregistering driver\n");
567 for (i = 0; i < ARRAY_SIZE(nasgpio_leds); i++)
568 unregister_nasgpio_led(i);
569 pci_unregister_driver(&nas_gpio_pci_driver);
570}
571
572module_init(nas_gpio_init);
573module_exit(nas_gpio_exit);
574