projects/linux·blob master · refs

551 lines · 13.9 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Chassis LCD/LED driver for HP-PARISC workstations
4 *
5 * (c) Copyright 2000 Red Hat Software
6 * (c) Copyright 2000 Helge Deller <[email protected]>
7 * (c) Copyright 2001 Randolph Chung <[email protected]>
8 * (c) Copyright 2000-2023 Helge Deller <[email protected]>
9 *
10 * The control of the LEDs and LCDs on PARISC machines has to be done
11 * completely in software.
12 *
13 * The LEDs can be configured at runtime in /sys/class/leds/
14 */
15
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/types.h>
19#include <linux/ioport.h>
20#include <linux/utsname.h>
21#include <linux/capability.h>
22#include <linux/delay.h>
23#include <linux/reboot.h>
24#include <linux/uaccess.h>
25#include <linux/leds.h>
26#include <linux/platform_device.h>
27
28#include <asm/io.h>
29#include <asm/processor.h>
30#include <asm/hardware.h>
31#include <asm/param.h> /* HZ */
32#include <asm/led.h>
33#include <asm/pdc.h>
34
35#define LED_HAS_LCD 1
36#define LED_HAS_LED 2
37
38static unsigned char led_type; /* bitmask of LED_HAS_XXX */
39static unsigned char lastleds; /* LED state from most recent update */
40static unsigned char lcd_new_text;
41static unsigned char lcd_text[20];
42static unsigned char lcd_no_led_support; /* KittyHawk doesn't support LED on its LCD */
43
44struct lcd_block {
45 unsigned char command; /* stores the command byte */
46 unsigned char on; /* value for turning LED on */
47 unsigned char off; /* value for turning LED off */
48};
49
50/* Structure returned by PDC_RETURN_CHASSIS_INFO */
51/* NOTE: we use unsigned long:16 two times, since the following member
52 lcd_cmd_reg_addr needs to be 64bit aligned on 64bit PA2.0-machines */
53struct pdc_chassis_lcd_info_ret_block {
54 unsigned long model:16; /* DISPLAY_MODEL_XXXX */
55 unsigned long lcd_width:16; /* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
56 unsigned long lcd_cmd_reg_addr; /* ptr to LCD cmd-register & data ptr for LED */
57 unsigned long lcd_data_reg_addr; /* ptr to LCD data-register (LCD only) */
58 unsigned int min_cmd_delay; /* delay in uS after cmd-write (LCD only) */
59 unsigned char reset_cmd1; /* command #1 for writing LCD string (LCD only) */
60 unsigned char reset_cmd2; /* command #2 for writing LCD string (LCD only) */
61 unsigned char act_enable; /* 0 = no activity (LCD only) */
62 struct lcd_block heartbeat;
63 struct lcd_block disk_io;
64 struct lcd_block lan_rcv;
65 struct lcd_block lan_tx;
66 char _pad;
67};
68
69
70/* LCD_CMD and LCD_DATA for KittyHawk machines */
71#define KITTYHAWK_LCD_CMD F_EXTEND(0xf0190000UL)
72#define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD + 1)
73
74/* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's
75 * HP seems to have used Sharp/Hitachi HD44780 LCDs most of the time. */
76static struct pdc_chassis_lcd_info_ret_block
77lcd_info __attribute__((aligned(8))) =
78{
79 .model = DISPLAY_MODEL_NONE,
80 .lcd_width = 16,
81 .lcd_cmd_reg_addr = KITTYHAWK_LCD_CMD,
82 .lcd_data_reg_addr = KITTYHAWK_LCD_DATA,
83 .min_cmd_delay = 80,
84 .reset_cmd1 = 0x80,
85 .reset_cmd2 = 0xc0,
86};
87
88/* direct access to some of the lcd_info variables */
89#define LCD_CMD_REG lcd_info.lcd_cmd_reg_addr
90#define LCD_DATA_REG lcd_info.lcd_data_reg_addr
91#define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
92
93/* ptr to LCD/LED-specific function */
94static void (*led_func_ptr) (unsigned char);
95
96
97static void lcd_print_now(void)
98{
99 int i;
100 char *str = lcd_text;
101
102 if (lcd_info.model != DISPLAY_MODEL_LCD)
103 return;
104
105 if (!lcd_new_text)
106 return;
107 lcd_new_text = 0;
108
109 /* Set LCD Cursor to 1st character */
110 gsc_writeb(lcd_info.reset_cmd1, LCD_CMD_REG);
111 udelay(lcd_info.min_cmd_delay);
112
113 /* Print the string */
114 for (i = 0; i < lcd_info.lcd_width; i++) {
115 gsc_writeb(*str ? *str++ : ' ', LCD_DATA_REG);
116 udelay(lcd_info.min_cmd_delay);
117 }
118}
119
120/**
121 * lcd_print()
122 *
123 * @str: string to show on the LCD. If NULL, print current string again.
124 *
125 * Displays the given string on the LCD-Display of newer machines.
126 */
127void lcd_print(const char *str)
128{
129 /* copy display string to buffer for procfs */
130 if (str)
131 strscpy(lcd_text, str, sizeof(lcd_text));
132 lcd_new_text = 1;
133
134 /* print now if LCD without any LEDs */
135 if (led_type == LED_HAS_LCD)
136 lcd_print_now();
137}
138
139#define LED_DATA 0x01 /* data to shift (0:on 1:off) */
140#define LED_STROBE 0x02 /* strobe to clock data */
141
142/**
143 * led_ASP_driver() - LED driver for the ASP controller chip
144 *
145 * @leds: bitmap representing the LED status
146 */
147static void led_ASP_driver(unsigned char leds)
148{
149 int i;
150
151 leds = ~leds;
152 for (i = 0; i < 8; i++) {
153 unsigned char value;
154 value = (leds & 0x80) >> 7;
155 gsc_writeb( value, LED_DATA_REG );
156 gsc_writeb( value | LED_STROBE, LED_DATA_REG );
157 leds <<= 1;
158 }
159}
160
161/**
162 * led_LASI_driver() - LED driver for the LASI controller chip
163 *
164 * @leds: bitmap representing the LED status
165 */
166static void led_LASI_driver(unsigned char leds)
167{
168 leds = ~leds;
169 gsc_writeb( leds, LED_DATA_REG );
170}
171
172/**
173 * led_LCD_driver() - LED & LCD driver for LCD chips
174 *
175 * @leds: bitmap representing the LED status
176 */
177static void led_LCD_driver(unsigned char leds)
178{
179 static const unsigned char mask[4] = {
180 LED_HEARTBEAT, LED_DISK_IO,
181 LED_LAN_RCV, LED_LAN_TX };
182
183 static struct lcd_block * const blockp[4] = {
184 &lcd_info.heartbeat,
185 &lcd_info.disk_io,
186 &lcd_info.lan_rcv,
187 &lcd_info.lan_tx
188 };
189 static unsigned char latest_leds;
190 int i;
191
192 for (i = 0; i < 4; ++i) {
193 if ((leds & mask[i]) == (latest_leds & mask[i]))
194 continue;
195
196 gsc_writeb( blockp[i]->command, LCD_CMD_REG );
197 udelay(lcd_info.min_cmd_delay);
198
199 gsc_writeb( leds & mask[i] ? blockp[i]->on :
200 blockp[i]->off, LCD_DATA_REG );
201 udelay(lcd_info.min_cmd_delay);
202 }
203 latest_leds = leds;
204
205 lcd_print_now();
206}
207
208
209/**
210 * lcd_system_halt()
211 *
212 * @nb: pointer to the notifier_block structure
213 * @event: the event (SYS_RESTART, SYS_HALT or SYS_POWER_OFF)
214 * @buf: pointer to a buffer (not used)
215 *
216 * Called by the reboot notifier chain at shutdown. Stops all
217 * LED/LCD activities.
218 */
219static int lcd_system_halt(struct notifier_block *nb, unsigned long event, void *buf)
220{
221 const char *txt;
222
223 switch (event) {
224 case SYS_RESTART: txt = "SYSTEM RESTART";
225 break;
226 case SYS_HALT: txt = "SYSTEM HALT";
227 break;
228 case SYS_POWER_OFF: txt = "SYSTEM POWER OFF";
229 break;
230 default: return NOTIFY_DONE;
231 }
232
233 lcd_print(txt);
234
235 return NOTIFY_OK;
236}
237
238static struct notifier_block lcd_system_halt_notifier = {
239 .notifier_call = lcd_system_halt,
240};
241
242static void set_led(struct led_classdev *led_cdev, enum led_brightness brightness);
243
244struct hppa_led {
245 struct led_classdev led_cdev;
246 unsigned char led_bit;
247};
248#define to_hppa_led(d) container_of(d, struct hppa_led, led_cdev)
249
250typedef void (*set_handler)(struct led_classdev *, enum led_brightness);
251struct led_type {
252 const char *name;
253 set_handler handler;
254 const char *default_trigger;
255};
256
257#define NUM_LEDS_PER_BOARD 8
258struct hppa_drvdata {
259 struct hppa_led leds[NUM_LEDS_PER_BOARD];
260};
261
262static void set_led(struct led_classdev *led_cdev, enum led_brightness brightness)
263{
264 struct hppa_led *p = to_hppa_led(led_cdev);
265 unsigned char led_bit = p->led_bit;
266
267 if (brightness == LED_OFF)
268 lastleds &= ~led_bit;
269 else
270 lastleds |= led_bit;
271
272 if (led_func_ptr)
273 led_func_ptr(lastleds);
274}
275
276
277static int hppa_led_generic_probe(struct platform_device *pdev,
278 struct led_type *types)
279{
280 struct hppa_drvdata *p;
281 int i, err;
282
283 p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
284 if (!p)
285 return -ENOMEM;
286
287 for (i = 0; i < NUM_LEDS_PER_BOARD; i++) {
288 struct led_classdev *lp = &p->leds[i].led_cdev;
289
290 p->leds[i].led_bit = BIT(i);
291 lp->name = types[i].name;
292 lp->brightness = LED_FULL;
293 lp->brightness_set = types[i].handler;
294 lp->default_trigger = types[i].default_trigger;
295 err = led_classdev_register(&pdev->dev, lp);
296 if (err) {
297 dev_err(&pdev->dev, "Could not register %s LED\n",
298 lp->name);
299 for (i--; i >= 0; i--)
300 led_classdev_unregister(&p->leds[i].led_cdev);
301 return err;
302 }
303 }
304
305 platform_set_drvdata(pdev, p);
306
307 return 0;
308}
309
310static void platform_led_remove(struct platform_device *pdev)
311{
312 struct hppa_drvdata *p = platform_get_drvdata(pdev);
313 int i;
314
315 for (i = 0; i < NUM_LEDS_PER_BOARD; i++)
316 led_classdev_unregister(&p->leds[i].led_cdev);
317}
318
319static struct led_type mainboard_led_types[NUM_LEDS_PER_BOARD] = {
320 {
321 .name = "platform-lan-tx",
322 .handler = set_led,
323 .default_trigger = "tx",
324 },
325 {
326 .name = "platform-lan-rx",
327 .handler = set_led,
328 .default_trigger = "rx",
329 },
330 {
331 .name = "platform-disk",
332 .handler = set_led,
333 .default_trigger = "disk-activity",
334 },
335 {
336 .name = "platform-heartbeat",
337 .handler = set_led,
338 .default_trigger = "heartbeat",
339 },
340 {
341 .name = "platform-LED4",
342 .handler = set_led,
343 .default_trigger = "panic",
344 },
345 {
346 .name = "platform-LED5",
347 .handler = set_led,
348 .default_trigger = "panic",
349 },
350 {
351 .name = "platform-LED6",
352 .handler = set_led,
353 .default_trigger = "panic",
354 },
355 {
356 .name = "platform-LED7",
357 .handler = set_led,
358 .default_trigger = "panic",
359 },
360};
361
362static int platform_led_probe(struct platform_device *pdev)
363{
364 return hppa_led_generic_probe(pdev, mainboard_led_types);
365}
366
367MODULE_ALIAS("platform:platform-leds");
368
369static struct platform_driver hppa_mainboard_led_driver = {
370 .probe = platform_led_probe,
371 .remove = platform_led_remove,
372 .driver = {
373 .name = "platform-leds",
374 },
375};
376
377static struct platform_driver * const drivers[] = {
378 &hppa_mainboard_led_driver,
379};
380
381static struct platform_device platform_leds = {
382 .name = "platform-leds",
383};
384
385/**
386 * register_led_driver()
387 *
388 * @model: model type, one of the DISPLAY_MODEL_XXXX values
389 * @cmd_reg: physical address of cmd register for the LED/LCD
390 * @data_reg: physical address of data register for the LED/LCD
391 *
392 * Registers a chassis LED or LCD which should be driven by this driver.
393 * Only PDC-based, LASI- or ASP-style LEDs and LCDs are supported.
394 */
395int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long data_reg)
396{
397 if (led_func_ptr || !data_reg)
398 return 1;
399
400 /* No LEDs when running in QEMU */
401 if (running_on_qemu)
402 return 1;
403
404 lcd_info.model = model; /* store the values */
405 LCD_CMD_REG = (cmd_reg == LED_CMD_REG_NONE) ? 0 : cmd_reg;
406
407 switch (lcd_info.model) {
408 case DISPLAY_MODEL_LCD:
409 LCD_DATA_REG = data_reg;
410 pr_info("led: LCD display at %#lx and %#lx\n",
411 LCD_CMD_REG , LCD_DATA_REG);
412 led_func_ptr = led_LCD_driver;
413 if (lcd_no_led_support)
414 led_type = LED_HAS_LCD;
415 else
416 led_type = LED_HAS_LCD | LED_HAS_LED;
417 break;
418
419 case DISPLAY_MODEL_LASI:
420 LED_DATA_REG = data_reg;
421 led_func_ptr = led_LASI_driver;
422 pr_info("led: LED display at %#lx\n", LED_DATA_REG);
423 led_type = LED_HAS_LED;
424 break;
425
426 case DISPLAY_MODEL_OLD_ASP:
427 LED_DATA_REG = data_reg;
428 led_func_ptr = led_ASP_driver;
429 pr_info("led: LED (ASP-style) display at %#lx\n",
430 LED_DATA_REG);
431 led_type = LED_HAS_LED;
432 break;
433
434 default:
435 pr_err("led: Unknown LCD/LED model type %d\n", lcd_info.model);
436 return 1;
437 }
438
439 platform_register_drivers(drivers, ARRAY_SIZE(drivers));
440
441 return register_reboot_notifier(&lcd_system_halt_notifier);
442}
443
444/**
445 * early_led_init()
446 *
447 * early_led_init() is called early in the bootup-process and asks the
448 * PDC for an usable chassis LCD or LED. If the PDC doesn't return any
449 * info, then a LED might be detected by the LASI or ASP drivers later.
450 * KittyHawk machines have often a buggy PDC, so that we explicitly check
451 * for those machines here.
452 */
453static int __init early_led_init(void)
454{
455 struct pdc_chassis_info chassis_info;
456 int ret;
457
458 scnprintf(lcd_text, sizeof(lcd_text),
459 "Linux %s", init_utsname()->release);
460 lcd_new_text = 1;
461
462 /* Work around the buggy PDC of KittyHawk-machines */
463 switch (CPU_HVERSION) {
464 case 0x580: /* KittyHawk DC2-100 (K100) */
465 case 0x581: /* KittyHawk DC3-120 (K210) */
466 case 0x582: /* KittyHawk DC3 100 (K400) */
467 case 0x583: /* KittyHawk DC3 120 (K410) */
468 case 0x58B: /* KittyHawk DC2 100 (K200) */
469 pr_info("LCD on KittyHawk-Machine found.\n");
470 lcd_info.model = DISPLAY_MODEL_LCD;
471 /* KittyHawk has no LED support on its LCD, so skip LED detection */
472 lcd_no_led_support = 1;
473 goto found; /* use the preinitialized values of lcd_info */
474 }
475
476 /* initialize the struct, so that we can check for valid return values */
477 chassis_info.actcnt = chassis_info.maxcnt = 0;
478
479 ret = pdc_chassis_info(&chassis_info, &lcd_info, sizeof(lcd_info));
480 if (ret != PDC_OK) {
481not_found:
482 lcd_info.model = DISPLAY_MODEL_NONE;
483 return 1;
484 }
485
486 /* check the results. Some machines have a buggy PDC */
487 if (chassis_info.actcnt <= 0 || chassis_info.actcnt != chassis_info.maxcnt)
488 goto not_found;
489
490 switch (lcd_info.model) {
491 case DISPLAY_MODEL_LCD: /* LCD display */
492 if (chassis_info.actcnt <
493 offsetof(struct pdc_chassis_lcd_info_ret_block, _pad)-1)
494 goto not_found;
495 if (!lcd_info.act_enable) {
496 /* PDC tells LCD should not be used. */
497 goto not_found;
498 }
499 break;
500
501 case DISPLAY_MODEL_NONE: /* no LED or LCD available */
502 goto not_found;
503
504 case DISPLAY_MODEL_LASI: /* Lasi style 8 bit LED display */
505 if (chassis_info.actcnt != 8 && chassis_info.actcnt != 32)
506 goto not_found;
507 break;
508
509 default:
510 pr_warn("PDC reported unknown LCD/LED model %d\n",
511 lcd_info.model);
512 goto not_found;
513 }
514
515found:
516 /* register the LCD/LED driver */
517 return register_led_driver(lcd_info.model, LCD_CMD_REG, LCD_DATA_REG);
518}
519arch_initcall(early_led_init);
520
521/**
522 * register_led_regions()
523 *
524 * Register_led_regions() registers the LCD/LED regions for /procfs.
525 * At bootup - where the initialisation of the LCD/LED often happens
526 * not all internal structures of request_region() are properly set up,
527 * so that we delay the led-registration until after busdevices_init()
528 * has been executed.
529 */
530static void __init register_led_regions(void)
531{
532 switch (lcd_info.model) {
533 case DISPLAY_MODEL_LCD:
534 request_mem_region((unsigned long)LCD_CMD_REG, 1, "lcd_cmd");
535 request_mem_region((unsigned long)LCD_DATA_REG, 1, "lcd_data");
536 break;
537 case DISPLAY_MODEL_LASI:
538 case DISPLAY_MODEL_OLD_ASP:
539 request_mem_region((unsigned long)LED_DATA_REG, 1, "led_data");
540 break;
541 }
542}
543
544static int __init startup_leds(void)
545{
546 if (platform_device_register(&platform_leds))
547 printk(KERN_INFO "LED: failed to register LEDs\n");
548 register_led_regions();
549 return 0;
550}
551device_initcall(startup_leds);