xref: /linux/drivers/parisc/led.c (revision e822b8f01b40eb193cf7ebb059ac7c560a562d6f)
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 <hdeller@redhat.com>
7  *	(c) Copyright 2001 Randolph Chung <tausq@debian.org>
8  *	(c) Copyright 2000-2023 Helge Deller <deller@gmx.de>
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 
38 static unsigned char led_type;		/* bitmask of LED_HAS_XXX */
39 static unsigned char lastleds;		/* LED state from most recent update */
40 static unsigned char lcd_new_text;
41 static unsigned char lcd_text[20];
42 static unsigned char lcd_no_led_support; /* KittyHawk doesn't support LED on its LCD */
43 
44 struct 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 */
53 struct 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. */
76 static struct pdc_chassis_lcd_info_ret_block
77 lcd_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 */
94 static void (*led_func_ptr) (unsigned char);
95 
96 
97 static 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  */
127 void 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  */
147 static 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  */
166 static 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  */
177 static 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  */
219 static 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 
238 static struct notifier_block lcd_system_halt_notifier = {
239 	.notifier_call = lcd_system_halt,
240 };
241 
242 static void set_led(struct led_classdev *led_cdev, enum led_brightness brightness);
243 
244 struct 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 
250 typedef void (*set_handler)(struct led_classdev *, enum led_brightness);
251 struct led_type {
252 	const char	*name;
253 	set_handler	handler;
254 	const char	*default_trigger;
255 };
256 
257 #define NUM_LEDS_PER_BOARD	8
258 struct hppa_drvdata {
259 	struct hppa_led	leds[NUM_LEDS_PER_BOARD];
260 };
261 
262 static 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 
277 static 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 
310 static 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 
319 static 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 
362 static int platform_led_probe(struct platform_device *pdev)
363 {
364 	return hppa_led_generic_probe(pdev, mainboard_led_types);
365 }
366 
367 MODULE_ALIAS("platform:platform-leds");
368 
369 static 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 
377 static struct platform_driver * const drivers[] = {
378 	&hppa_mainboard_led_driver,
379 };
380 
381 static 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  */
395 int __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  */
453 static 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) {
481 not_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 
515 found:
516 	/* register the LCD/LED driver */
517 	return register_led_driver(lcd_info.model, LCD_CMD_REG, LCD_DATA_REG);
518 }
519 arch_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  */
530 static 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 
544 static 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 }
551 device_initcall(startup_leds);
552