Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-25 12:21:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

[PARISC] Use work queue in LED/LCD driver instead of tasklet.

Browse Source 
2.6.12-rc1-pa6 use work queue in LED/LCD driver instead of tasklet.

Main advantage is it allows use of msleep() in the led_LCD_driver to
"atomically" perform two MMIO writes (CMD, then DATA).
Lead to nice cleanup of the main led_work_func() and led_LCD_driver().
Kudos to David for being persistent.

From: David Pye <dmp@davidmpye.dyndns.org>
Signed-off-by: Grant Grundler <grundler@parisc-linux.org>

Signed-off-by: Kyle McMartin <kyle@parisc-linux.org>
This commit is contained in:
Grant Grundler 2005-10-21 22:46:18 -04:00 committed by Kyle McMartin
parent ba1f188cae
commit 3499495205
3 changed files with 112 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
arch/parisc/kernel/time.c
View File

@ -89,14 +89,6 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
} }
} }
#ifdef CONFIG_CHASSIS_LCD_LED
/* Only schedule the led tasklet on cpu 0, and only if it
* is enabled.
*/
if (cpu == 0 && !atomic_read(&led_tasklet.count))
tasklet_schedule(&led_tasklet);
#endif
/* check soft power switch status */ /* check soft power switch status */
if (cpu == 0 && !atomic_read(&power_tasklet.count)) if (cpu == 0 && !atomic_read(&power_tasklet.count))
tasklet_schedule(&power_tasklet); tasklet_schedule(&power_tasklet);

225
drivers/parisc/led.c
View File

@ -18,6 +18,9 @@
* Changes: * Changes:
* - Audit copy_from_user in led_proc_write. * - Audit copy_from_user in led_proc_write.
* Daniele Bellucci <bellucda@tiscali.it> * Daniele Bellucci <bellucda@tiscali.it>
* - Switch from using a tasklet to a work queue, so the led_LCD_driver
* can sleep.
* David Pye <dmp@davidmpye.dyndns.org>
*/ */
#include <linux/config.h> #include <linux/config.h>
@ -37,6 +40,7 @@
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/workqueue.h>
#include <linux/rcupdate.h> #include <linux/rcupdate.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/processor.h> #include <asm/processor.h>
@ -47,25 +51,30 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
/* The control of the LEDs and LCDs on PARISC-machines have to be done /* The control of the LEDs and LCDs on PARISC-machines have to be done
completely in software. The necessary calculations are done in a tasklet completely in software. The necessary calculations are done in a work queue
which is scheduled at every timer interrupt and since the calculations task which is scheduled regularly, and since the calculations may consume a
may consume relatively much CPU-time some of the calculations can be relatively large amount of CPU time, some of the calculations can be
turned off with the following variables (controlled via procfs) */ turned off with the following variables (controlled via procfs) */
static int led_type = -1; static int led_type = -1;
static int led_heartbeat = 1; static unsigned char lastleds; /* LED state from most recent update */
static int led_diskio = 1; static unsigned int led_heartbeat = 1;
static int led_lanrxtx = 1; static unsigned int led_diskio = 1;
static unsigned int led_lanrxtx = 1;
static char lcd_text[32]; static char lcd_text[32];
static char lcd_text_default[32]; static char lcd_text_default[32];
static struct workqueue_struct *led_wq;
static void led_work_func(void *);
static DECLARE_WORK(led_task, led_work_func, NULL);
#if 0 #if 0
#define DPRINTK(x) printk x #define DPRINTK(x) printk x
#else #else
#define DPRINTK(x) #define DPRINTK(x)
#endif #endif
struct lcd_block { struct lcd_block {
unsigned char command; /* stores the command byte */ unsigned char command; /* stores the command byte */
unsigned char on; /* value for turning LED on */ unsigned char on; /* value for turning LED on */
@ -116,12 +125,27 @@ lcd_info __attribute__((aligned(8))) =
#define LCD_DATA_REG lcd_info.lcd_data_reg_addr #define LCD_DATA_REG lcd_info.lcd_data_reg_addr
#define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */ #define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
#define LED_HASLCD 1
#define LED_NOLCD 0
/* The workqueue must be created at init-time */
static int start_task(void)
{
/* Display the default text now */
if (led_type == LED_HASLCD) lcd_print( lcd_text_default );
/* Create the work queue and queue the LED task */
led_wq = create_singlethread_workqueue("led_wq");
queue_work(led_wq, &led_task);
return 0;
}
device_initcall(start_task);
/* ptr to LCD/LED-specific function */ /* ptr to LCD/LED-specific function */
static void (*led_func_ptr) (unsigned char); static void (*led_func_ptr) (unsigned char);
#define LED_HASLCD 1
#define LED_NOLCD 0
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int led_proc_read(char *page, char **start, off_t off, int count, static int led_proc_read(char *page, char **start, off_t off, int count,
int *eof, void *data) int *eof, void *data)
@ -286,52 +310,35 @@ static void led_LASI_driver(unsigned char leds)
/* /*
** **
** led_LCD_driver() ** led_LCD_driver()
**
** The logic of the LCD driver is, that we write at every scheduled call
** only to one of LCD_CMD_REG _or_ LCD_DATA_REG - registers.
** That way we don't need to let this tasklet busywait for min_cmd_delay
** milliseconds.
**
** TODO: check the value of "min_cmd_delay" against the value of HZ.
** **
*/ */
static void led_LCD_driver(unsigned char leds) static void led_LCD_driver(unsigned char leds)
{ {
static int last_index; /* 0:heartbeat, 1:disk, 2:lan_in, 3:lan_out */ static int i;
static int last_was_cmd;/* 0: CMD was written last, 1: DATA was last */ static unsigned char mask[4] = { LED_HEARTBEAT, LED_DISK_IO,
struct lcd_block *block_ptr; LED_LAN_RCV, LED_LAN_TX };
int value;
switch (last_index) {
case 0: block_ptr = &lcd_info.heartbeat;
value = leds & LED_HEARTBEAT;
break;
case 1: block_ptr = &lcd_info.disk_io;
value = leds & LED_DISK_IO;
break;
case 2: block_ptr = &lcd_info.lan_rcv;
value = leds & LED_LAN_RCV;
break;
case 3: block_ptr = &lcd_info.lan_tx;
value = leds & LED_LAN_TX;
break;
default: /* should never happen: */
return;
}
if (last_was_cmd) {
/* write the value to the LCD data port */
gsc_writeb( value ? block_ptr->on : block_ptr->off, LCD_DATA_REG );
} else {
/* write the command-byte to the LCD command register */
gsc_writeb( block_ptr->command, LCD_CMD_REG );
}
/* now update the vars for the next interrupt iteration */ static struct lcd_block * blockp[4] = {
if (++last_was_cmd == 2) { /* switch between cmd & data */ &lcd_info.heartbeat,
last_was_cmd = 0; &lcd_info.disk_io,
if (++last_index == 4) &lcd_info.lan_rcv,
last_index = 0; /* switch back to heartbeat index */ &lcd_info.lan_tx
};
/* Convert min_cmd_delay to milliseconds */
unsigned int msec_cmd_delay = 1 + (lcd_info.min_cmd_delay / 1000);
for (i=0; i<4; ++i)
{
if ((leds & mask[i]) != (lastleds & mask[i]))
{
gsc_writeb( blockp[i]->command, LCD_CMD_REG );
msleep(msec_cmd_delay);
gsc_writeb( leds & mask[i] ? blockp[i]->on :
blockp[i]->off, LCD_DATA_REG );
msleep(msec_cmd_delay);
}
} }
} }
@ -356,7 +363,7 @@ static __inline__ int led_get_net_activity(void)
rx_total = tx_total = 0; rx_total = tx_total = 0;
/* we are running as tasklet, so locking dev_base /* we are running as a workqueue task, so locking dev_base
* for reading should be OK */ * for reading should be OK */
read_lock(&dev_base_lock); read_lock(&dev_base_lock);
rcu_read_lock(); rcu_read_lock();
@ -405,7 +412,7 @@ static __inline__ int led_get_diskio_activity(void)
static unsigned long last_pgpgin, last_pgpgout; static unsigned long last_pgpgin, last_pgpgout;
struct page_state pgstat; struct page_state pgstat;
int changed; int changed;
get_full_page_state(&pgstat); /* get no of sectors in & out */ get_full_page_state(&pgstat); /* get no of sectors in & out */
/* Just use a very simple calculation here. Do not care about overflow, /* Just use a very simple calculation here. Do not care about overflow,
@ -413,87 +420,71 @@ static __inline__ int led_get_diskio_activity(void)
changed = (pgstat.pgpgin != last_pgpgin) || (pgstat.pgpgout != last_pgpgout); changed = (pgstat.pgpgin != last_pgpgin) || (pgstat.pgpgout != last_pgpgout);
last_pgpgin = pgstat.pgpgin; last_pgpgin = pgstat.pgpgin;
last_pgpgout = pgstat.pgpgout; last_pgpgout = pgstat.pgpgout;
return (changed ? LED_DISK_IO : 0); return (changed ? LED_DISK_IO : 0);
} }
/* /*
** led_tasklet_func() ** led_work_func()
** **
** is scheduled at every timer interrupt from time.c and ** manages when and which chassis LCD/LED gets updated
** updates the chassis LCD/LED
TODO: TODO:
- display load average (older machines like 715/64 have 4 "free" LED's for that) - display load average (older machines like 715/64 have 4 "free" LED's for that)
- optimizations - optimizations
*/ */
#define HEARTBEAT_LEN (HZ*6/100) #define HEARTBEAT_LEN (HZ*10/100)
#define HEARTBEAT_2ND_RANGE_START (HZ*22/100) #define HEARTBEAT_2ND_RANGE_START (HZ*28/100)
#define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN) #define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN)
#define NORMALIZED_COUNT(count) (count/(HZ/100)) #define LED_UPDATE_INTERVAL (1 + (HZ*19/1000))
static void led_tasklet_func(unsigned long unused) static void led_work_func (void *unused)
{ {
static unsigned char lastleds; static unsigned long last_jiffies;
unsigned char currentleds; /* stores current value of the LEDs */
static unsigned long count; /* static incremented value, not wrapped */
static unsigned long count_HZ; /* counter in range 0..HZ */ static unsigned long count_HZ; /* counter in range 0..HZ */
unsigned char currentleds = 0; /* stores current value of the LEDs */
/* exit if not initialized */ /* exit if not initialized */
if (!led_func_ptr) if (!led_func_ptr)
return; return;
/* increment the local counters */ /* increment the heartbeat timekeeper */
++count; count_HZ += jiffies - last_jiffies;
if (++count_HZ == HZ) last_jiffies = jiffies;
if (count_HZ >= HZ)
count_HZ = 0; count_HZ = 0;
currentleds = lastleds; if (likely(led_heartbeat))
if (led_heartbeat)
{ {
/* flash heartbeat-LED like a real heart (2 x short then a long delay) */ /* flash heartbeat-LED like a real heart
if (count_HZ<HEARTBEAT_LEN || * (2 x short then a long delay)
(count_HZ>=HEARTBEAT_2ND_RANGE_START && count_HZ<HEARTBEAT_2ND_RANGE_END)) */
currentleds |= LED_HEARTBEAT; if (count_HZ < HEARTBEAT_LEN ||
else (count_HZ >= HEARTBEAT_2ND_RANGE_START &&
currentleds &= ~LED_HEARTBEAT; count_HZ < HEARTBEAT_2ND_RANGE_END))
currentleds |= LED_HEARTBEAT;
} }
/* look for network activity and flash LEDs respectively */ if (likely(led_lanrxtx)) currentleds |= led_get_net_activity();
if (led_lanrxtx && ((NORMALIZED_COUNT(count)+(8/2)) & 7) == 0) if (likely(led_diskio)) currentleds |= led_get_diskio_activity();
{
currentleds &= ~(LED_LAN_RCV | LED_LAN_TX);
currentleds |= led_get_net_activity();
}
/* avoid to calculate diskio-stats at same irq as netio-stats */
if (led_diskio && (NORMALIZED_COUNT(count) & 7) == 0)
{
currentleds &= ~LED_DISK_IO;
currentleds |= led_get_diskio_activity();
}
/* blink all LEDs twice a second if we got an Oops (HPMC) */ /* blink all LEDs twice a second if we got an Oops (HPMC) */
if (oops_in_progress) { if (unlikely(oops_in_progress))
currentleds = (count_HZ<=(HZ/2)) ? 0 : 0xff; currentleds = (count_HZ<=(HZ/2)) ? 0 : 0xff;
if (currentleds != lastleds)
{
led_func_ptr(currentleds); /* Update the LCD/LEDs */
lastleds = currentleds;
} }
/* update the LCD/LEDs */ queue_delayed_work(led_wq, &led_task, LED_UPDATE_INTERVAL);
if (currentleds != lastleds) {
led_func_ptr(currentleds);
lastleds = currentleds;
}
} }
/* main led tasklet struct (scheduled from time.c) */
DECLARE_TASKLET_DISABLED(led_tasklet, led_tasklet_func, 0);
/* /*
** led_halt() ** led_halt()
** **
@ -522,9 +513,13 @@ static int led_halt(struct notifier_block *nb, unsigned long event, void *buf)
default: return NOTIFY_DONE; default: return NOTIFY_DONE;
} }
/* completely stop the LED/LCD tasklet */ /* Cancel the work item and delete the queue */
tasklet_disable(&led_tasklet); if (led_wq) {
cancel_rearming_delayed_workqueue(led_wq, &led_task);
destroy_workqueue(led_wq);
led_wq = NULL;
}
if (lcd_info.model == DISPLAY_MODEL_LCD) if (lcd_info.model == DISPLAY_MODEL_LCD)
lcd_print(txt); lcd_print(txt);
else else
@ -559,7 +554,6 @@ int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long d
printk(KERN_INFO "LCD display at %lx,%lx registered\n", printk(KERN_INFO "LCD display at %lx,%lx registered\n",
LCD_CMD_REG , LCD_DATA_REG); LCD_CMD_REG , LCD_DATA_REG);
led_func_ptr = led_LCD_driver; led_func_ptr = led_LCD_driver;
lcd_print( lcd_text_default );
led_type = LED_HASLCD; led_type = LED_HASLCD;
break; break;
@ -589,9 +583,11 @@ int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long d
initialized++; initialized++;
register_reboot_notifier(&led_notifier); register_reboot_notifier(&led_notifier);
/* start the led tasklet for the first time */ /* Ensure the work is queued */
tasklet_enable(&led_tasklet); if (led_wq) {
queue_work(led_wq, &led_task);
}
return 0; return 0;
} }
@ -626,8 +622,8 @@ void __init register_led_regions(void)
** lcd_print() ** lcd_print()
** **
** Displays the given string on the LCD-Display of newer machines. ** Displays the given string on the LCD-Display of newer machines.
** lcd_print() disables the timer-based led tasklet during its ** lcd_print() disables/enables the timer-based led work queue to
** execution and enables it afterwards again. ** avoid a race condition while writing the CMD/DATA register pair.
** **
*/ */
int lcd_print( char *str ) int lcd_print( char *str )
@ -637,12 +633,13 @@ int lcd_print( char *str )
if (!led_func_ptr || lcd_info.model != DISPLAY_MODEL_LCD) if (!led_func_ptr || lcd_info.model != DISPLAY_MODEL_LCD)
return 0; return 0;
/* temporarily disable the led tasklet */ /* temporarily disable the led work task */
tasklet_disable(&led_tasklet); if (led_wq)
cancel_rearming_delayed_workqueue(led_wq, &led_task);
/* copy display string to buffer for procfs */ /* copy display string to buffer for procfs */
strlcpy(lcd_text, str, sizeof(lcd_text)); strlcpy(lcd_text, str, sizeof(lcd_text));
/* Set LCD Cursor to 1st character */ /* Set LCD Cursor to 1st character */
gsc_writeb(lcd_info.reset_cmd1, LCD_CMD_REG); gsc_writeb(lcd_info.reset_cmd1, LCD_CMD_REG);
udelay(lcd_info.min_cmd_delay); udelay(lcd_info.min_cmd_delay);
@ -656,8 +653,10 @@ int lcd_print( char *str )
udelay(lcd_info.min_cmd_delay); udelay(lcd_info.min_cmd_delay);
} }
/* re-enable the led tasklet */ /* re-queue the work */
tasklet_enable(&led_tasklet); if (led_wq) {
queue_work(led_wq, &led_task);
}
return lcd_info.lcd_width; return lcd_info.lcd_width;
} }

3
include/asm-parisc/led.h
View File

@ -23,9 +23,6 @@
#define LED_CMD_REG_NONE 0 /* NULL == no addr for the cmd register */ #define LED_CMD_REG_NONE 0 /* NULL == no addr for the cmd register */
/* led tasklet struct */
extern struct tasklet_struct led_tasklet;
/* register_led_driver() */ /* register_led_driver() */
int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long data_reg); int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long data_reg);