[Linuxconsole-commit]CVS: ruby/ruby-2.6/drivers/char Kconfig,1.5,1.6 Makefile,1.7,1.8 keyboard.c,1.12,1.13 selection.c,1.2,1.3 tty_io.c,1.7,1.8 vc_screen.c,1.3,1.4 vt.c,1.16,1.17 vt_ioctl.c,1.5,1.6

[Aivils S. <ai...@us...>]

Update of /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7020/ruby-2.6/drivers/char

Modified Files:
	Kconfig Makefile keyboard.c selection.c tty_io.c vc_screen.c 
	vt.c vt_ioctl.c 
Log Message:
sync to 2.6.3

Index: Kconfig
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/Kconfig,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- Kconfig	9 Feb 2004 07:31:07 -0000	1.5
+++ Kconfig	20 Feb 2004 06:52:18 -0000	1.6
@@ -969,12 +969,16 @@
 	  If compiled as a module, it will be called scx200_gpio.
 
 config RAW_DRIVER
-	tristate "RAW driver (/dev/raw/rawN)"
+	tristate "RAW driver (/dev/raw/rawN) (OBSOLETE)"
 	help
 	  The raw driver permits block devices to be bound to /dev/raw/rawN. 
 	  Once bound, I/O against /dev/raw/rawN uses efficient zero-copy I/O. 
 	  See the raw(8) manpage for more details.
 
+          The raw driver is deprecated and may be removed from 2.7
+          kernels.  Applications should simply open the device (eg /dev/hda1)
+          with the O_DIRECT flag.
+
 config MAX_RAW_DEVS
 	int "Maximum number of RAW devices to support (1-8192)"
 	depends on RAW_DRIVER

Index: Makefile
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/Makefile,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- Makefile	9 Feb 2004 07:33:28 -0000	1.7
+++ Makefile	20 Feb 2004 06:52:18 -0000	1.8
@@ -57,7 +57,9 @@
 obj-$(CONFIG_RTC) += rtc.o
 obj-$(CONFIG_GEN_RTC) += genrtc.o
 obj-$(CONFIG_EFI_RTC) += efirtc.o
-ifeq ($(CONFIG_PPC),)
+ifeq ($(CONFIG_GENERIC_NVRAM),y)
+  obj-$(CONFIG_NVRAM) += generic_nvram.o
+else
   obj-$(CONFIG_NVRAM) += nvram.o
 endif
 obj-$(CONFIG_TOSHIBA) += toshiba.o

Index: keyboard.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/keyboard.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- keyboard.c	9 Feb 2004 07:31:07 -0000	1.12
+++ keyboard.c	20 Feb 2004 06:52:18 -0000	1.13
@@ -150,8 +150,7 @@
 	if (!dev->keycodesize || (scancode < 0 || scancode >= dev->keycodemax))
 		return -EINVAL;
 
-	oldkey = INPUT_KEYCODE(dev, scancode);
-	INPUT_KEYCODE(dev, scancode) = keycode;
+        oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
 
         clear_bit(oldkey, dev->keybit);
         set_bit(keycode, dev->keybit);
@@ -920,11 +919,6 @@
 static int emulate_raw(struct vc_data *vc, unsigned int keycode, 
 		       unsigned char up_flag)
 {
-#ifdef CONFIG_MAC_EMUMOUSEBTN
-	if (mac_hid_mouse_emulate_buttons(1, keycode, !up_flag))
-		return 0;
-#endif /* CONFIG_MAC_EMUMOUSEBTN */
-
 	if (keycode > 255 || !x86_keycodes[keycode])
 		return -1; 
 
@@ -1001,6 +995,11 @@
 
 	rep = (down == 2);
 
+#ifdef CONFIG_MAC_EMUMOUSEBTN
+        if (mac_hid_mouse_emulate_buttons(1, keycode, down))
+                return;
+#endif /* CONFIG_MAC_EMUMOUSEBTN */
+
 	if ((raw_mode = (vc->kbd_table.kbdmode == VC_RAW)))
 		if (emulate_raw(vc, keycode, !down << 7))
 			if (keycode < BTN_MISC)

Index: selection.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/selection.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- selection.c	12 Sep 2003 08:33:21 -0000	1.2
+++ selection.c	20 Feb 2004 06:52:18 -0000	1.3
@@ -300,7 +300,10 @@
 	int	pasted = 0, count;
 	DECLARE_WAITQUEUE(wait, current);
 
+        acquire_console_sem();
 	poke_blanked_console(vc->display_fg);
+        release_console_sem();
+
 	add_wait_queue(&vc->paste_wait, &wait);
 	while (sel_buffer && sel_buffer_lth > pasted) {
 		set_current_state(TASK_INTERRUPTIBLE);

Index: tty_io.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/tty_io.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- tty_io.c	9 Feb 2004 07:31:07 -0000	1.7
+++ tty_io.c	20 Feb 2004 06:52:18 -0000	1.8
@@ -1490,8 +1490,14 @@
 #ifdef CONFIG_VT
 	if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
 		struct vc_data *vc = (struct vc_data *) tty->driver_data;
-		
-		if (!vc || vc_resize(vc, tmp_ws.ws_col, tmp_ws.ws_row))
+		int rc = 0;
+
+		if (!vc) {
+			acquire_console_sem();
+			rc = vc_resize(vc, tmp_ws.ws_col, tmp_ws.ws_row);
+			release_console_sem();
+		}
+		if (rc)
 			return -ENXIO;
 	}
 #endif
@@ -2266,7 +2272,6 @@
 	if (driver->refcount)
 		return -EBUSY;
 
-	cdev_unmap(MKDEV(driver->major, driver->minor_start), driver->num);
 	unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
 				driver->num);
 

Index: vc_screen.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/vc_screen.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- vc_screen.c	2 Oct 2003 09:32:18 -0000	1.3
+++ vc_screen.c	20 Feb 2004 06:52:18 -0000	1.4
@@ -49,13 +49,13 @@
 	return screenpos(vc, 2 * w_offset, viewed);
 }
 
-void getconsxy(struct vc_data *vc, char *p)
+void getconsxy(struct vc_data *vc, unsigned char *p)
 {
 	p[0] = vc->vc_x;
 	p[1] = vc->vc_y;
 }
 
-void putconsxy(struct vc_data *vc, char *p)
+void putconsxy(struct vc_data *vc, unsigned char *p)
 {
 	gotoxy(vc, p[0], p[1]);
 	set_cursor(vc);

Index: vt.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/vt.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- vt.c	12 Feb 2004 06:33:04 -0000	1.16
+++ vt.c	20 Feb 2004 06:52:18 -0000	1.17
@@ -41,6 +41,7 @@
  *     - David Carter <ca...@cs...>
  * 
  *   Note that the abstract console driver allows all consoles to be of
+
  *   potentially different sizes, so the following variables depend on the
  *   current console (currcons):
  *
@@ -138,7 +139,12 @@
 LIST_HEAD(vt_list);		/* Head to link list of VTs */
 
 static void vt_flush_chars(struct tty_struct *tty);
-static void unblank_screen_t(unsigned long dummy);
+static void blank_screen_t(unsigned long dummy);
+enum {
+        blank_off = 0,
+        blank_normal_wait,
+        blank_vesa_wait,
+};
 
 #ifdef CONFIG_VT_CONSOLE
 static int kmsg_redirect = 0;	/* kmsg_redirect is the VC for printk */
@@ -282,6 +288,8 @@
  */
 void set_palette(struct vc_data *vc)
 {
+	WARN_CONSOLE_UNLOCKED();
+
 	if (IS_VISIBLE && sw->con_set_palette && vcmode != KD_GRAPHICS)
 		sw->con_set_palette(vc, color_table);
 }
@@ -492,6 +500,8 @@
  */
 void set_origin(struct vc_data *vc)
 {
+	WARN_CONSOLE_UNLOCKED();
+
 	if (!IS_VISIBLE ||
 	    !sw->con_set_origin ||
 	    !sw->con_set_origin(vc))
@@ -510,6 +520,8 @@
 
 inline void save_screen(struct vc_data *vc)
 {
+	WARN_CONSOLE_UNLOCKED();
+
 	if (sw->con_save_screen)
 		sw->con_save_screen(vc);
 }
@@ -562,6 +574,8 @@
 
 void update_region(struct vc_data *vc, unsigned long start, int count)
 {
+	WARN_CONSOLE_UNLOCKED();
+
 	if (DO_UPDATE) {
 		hide_cursor(vc);
 		do_update_region(vc, start, count);
@@ -602,6 +616,8 @@
 {
 	unsigned short *p;
 
+	WARN_CONSOLE_UNLOCKED();
+
 	count /= 2;
 	p = screenpos(vc, offset, viewed);
 	if (sw->con_invert_region)
@@ -656,6 +672,8 @@
 	static unsigned short oldx, oldy, old;
 	static unsigned short *p;
 
+	WARN_CONSOLE_UNLOCKED();
+
 	if (p) {
 		scr_writew(old, p);
 		if (DO_UPDATE)
@@ -695,8 +713,6 @@
 	struct vt_struct *vt = (struct vt_struct *) private;
 	struct vc_data *vc = vt->fg_console;
 
-        vc->display_fg->timer.data = (long) vt;
-	vc->display_fg->timer.function = unblank_screen_t;
 	switch (vc->display_fg->blank_mode) {
 	case VESA_NO_BLANKING:
 		sw->con_blank(vc, VESA_VSYNC_SUSPEND+1);
@@ -708,13 +724,23 @@
 	}
 }
 
-static void timer_do_blank_screen(struct vt_struct *vt, int entering_gfx, int from_timer_handler)
+void do_blank_screen(struct vt_struct *vt, int entering_gfx)
 {
 	struct vc_data *vc = vt->fg_console;
 	int i;
 
-	if (vc->display_fg->vt_blanked)
+	WARN_CONSOLE_UNLOCKED();
+
+	if (vc->display_fg->vt_blanked) {
+		if (vc->display_fg->blank_state == blank_vesa_wait) {
+			vc->display_fg->blank_state = blank_off;
+			powerdown_screen((unsigned long)vt);
+		}
 		return;
+	}
+	if (vc->display_fg->blank_state != blank_normal_wait)
+		return;
+	vc->display_fg->blank_state = blank_off;
 
 	/* entering graphics mode? */
 	if (entering_gfx) {
@@ -733,10 +759,8 @@
 	}
 
 	hide_cursor(vc);
-	if (!from_timer_handler)
-		del_timer_sync(&vc->display_fg->timer);
-        vc->display_fg->timer.data = (long) vc->display_fg;
-	vc->display_fg->timer.function = unblank_screen_t;
+	del_timer_sync(&vc->display_fg->timer);
+	vc->display_fg->blank_timer_expired = 0;
 
 	save_screen(vc);
 	/* In case we need to reset origin, blanking hook returns 1 */
@@ -748,33 +772,24 @@
 	if (console_blank_hook && console_blank_hook(1))
 		return;
 	if (vc->display_fg->off_interval) {
-	        vc->display_fg->timer.data = (long) vc->display_fg;
-		vc->display_fg->timer.function = powerdown_screen;
+		vc->display_fg->blank_state = blank_vesa_wait;
 		mod_timer(&vc->display_fg->timer, jiffies + vc->display_fg->off_interval);
 	}
 	if (vc->display_fg->blank_mode)
 		sw->con_blank(vc, vc->display_fg->blank_mode + 1);
 }
 
-void do_blank_screen(struct vt_struct *vt, int entering_gfx)
-{
-	timer_do_blank_screen(vt, entering_gfx, 0);
-}
-
 /*
- * This is a timer handler
+ * We defer the timer blanking to work queue so it can take the console semaphore
+ * (console operations can still happen at irq time, but only from printk which
+ * has the console semaphore. Not perfect yet, but better than no locking
  */
-static void unblank_screen_t(unsigned long dummy)
+static void blank_screen_t(unsigned long dummy)
 {
-	unblank_vt((struct vt_struct *) dummy);
-}
+	struct vt_struct *vt = (struct vt_struct*) dummy;
 
-/*
- * This is both a user-level callable and a timer handler
- */
-static void blank_screen(unsigned long dummy)
-{
-	timer_do_blank_screen((struct vt_struct *) dummy, 0, 1);
+	vt->blank_timer_expired = 1;
+	schedule_work(&vt->vt_work);
 }
 
 /*
@@ -795,10 +810,9 @@
 	if (vcmode != KD_TEXT)
 		return; /* but leave vc->vc_display_fg->vt_blanked != 0 */
 
-	vc->display_fg->timer.data = (long) vt;
-	vc->display_fg->timer.function = blank_screen;
 	if (vc->display_fg->blank_interval) {
 		mod_timer(&vc->display_fg->timer, jiffies + vc->display_fg->blank_interval);
+		vc->display_fg->blank_state = blank_normal_wait;
 	}
 
 	vc->display_fg->vt_blanked = 0;
@@ -827,14 +841,18 @@
 {
 	struct vc_data *vc = vt->fg_console;
 
+	WARN_CONSOLE_UNLOCKED();
+
 	del_timer(&vt->timer);
+	vt->blank_timer_expired = 0;
 	if (ignore_poke || !vc || vcmode == KD_GRAPHICS)
 		return;
 	if (vt->vt_blanked) {
-		vt->timer.function = unblank_screen_t;
-		mod_timer(&vt->timer, jiffies);	/* Now */
-	} else if (vt->blank_interval) 
+		unblank_vt(vt);
+	} else if (vt->blank_interval) {
 		mod_timer(&vt->timer, jiffies + vt->blank_interval);
+		vt->blank_state = blank_normal_wait;
+	}
 }
 
 /*
@@ -842,20 +860,24 @@
  */
 static int pm_con_request(struct pm_dev *dev, pm_request_t rqst, void *data)
 {
-        struct vt_struct *vt = admin_vt; /*FIXME*/
+	struct vt_struct *vt = admin_vt; /*FIXME*/
 
-        if (vt) {
-                switch (rqst)
-                {
-                case PM_RESUME:
-                        unblank_vt(vt);
-                        break;
-                case PM_SUSPEND:
-                        do_blank_screen(vt, 0);
-                        break;
-                }
-        }
-        return 0;
+	if (vt) {
+		switch (rqst)
+		{
+		case PM_RESUME:
+			acquire_console_sem();
+			unblank_vt(vt);
+			release_console_sem();
+			break;
+		case PM_SUSPEND:
+			acquire_console_sem();
+			do_blank_screen(vt, 0);
+			release_console_sem();
+			break;
+		}
+	}
+	return 0;
 }
 /*
  * This is the console switching callback.
@@ -893,6 +915,11 @@
 			sw->con_scroll(vc, vt->scrollback_delta);
 		vt->scrollback_delta = 0;
 	}
+        if (vt->blank_timer_expired) {
+                do_blank_screen(vt, 0);
+                vt->blank_timer_expired = 0;
+        }
+
 	release_console_sem();
 }
 
@@ -952,6 +979,8 @@
 	struct vc_data *vc = NULL;
 	struct vt_struct *vt;
 
+	WARN_CONSOLE_UNLOCKED();
+
 	if (currcons >= MAX_NR_CONSOLES) {
 		currcons = -ENXIO;
 		return NULL;
@@ -1024,7 +1053,8 @@
 {
 	struct vt_struct *vt = vc->display_fg;
 
-	acquire_console_sem();
+	WARN_CONSOLE_UNLOCKED();
+
 	if (vc && vc->vc_num > MIN_NR_CONSOLES) {
 		sw->con_deinit(vc);
 		vt->vc_cons[cons_num - vt->first_vc] = NULL;
@@ -1032,7 +1062,6 @@
 			kfree(screenbuf);
 		kfree(vc);
 	}
-	release_console_sem();
 	return 0;
 }
 
@@ -1063,6 +1092,8 @@
 	unsigned int new_cols, new_rows, ss, new_row_size, err = 0;
 	unsigned short *newscreen;
 
+	WARN_CONSOLE_UNLOCKED();
+
 	if (!vc)
 		return 0;
 
@@ -1383,7 +1414,9 @@
 	if (!vc) {
 		vc = find_vc(index);
 		if (!vc) {
+			acquire_console_sem();
 			vc = vc_allocate(index);
+			release_console_sem();
 			if (!vc)
 				return -ENODEV;
 		}	
@@ -1750,9 +1783,10 @@
 	vt->vt_blanked = 0;
 	vt->blank_interval = 10 * 60 * HZ;
 	vt->off_interval = 0;
+	vt->blank_state = blank_normal_wait;
 	init_timer(&vt->timer);
 	vt->timer.data = (long) vt;
-	vt->timer.function = blank_screen;
+	vt->timer.function = blank_screen_t;
 	mod_timer(&vt->timer, jiffies + vt->blank_interval);
 	if (vt->pm_con)
 		vt->pm_con->data = vt;
@@ -1873,6 +1907,8 @@
 	const char *desc;
 	int i;
 
+	acquire_console_sem();
+
 	/* First shutdown old console driver */
 	hide_cursor(vc);
 
@@ -1887,6 +1923,7 @@
 	if (!desc) {
 		/* Make sure the original driver state is restored to normal */
 		vt->vt_sw->con_startup(vt, 1);
+		release_console_sem();
 		return;
 	}
 	vt->vt_sw = csw;
@@ -1918,6 +1955,8 @@
 			vc->vc_can_do_color ? "colour" : "mono",
 			desc, vc->vc_cols, vc->vc_rows,
 			vt->first_vc + 1, vt->first_vc + vt->vc_count);
+
+	release_console_sem();
 }
 
 /*

Index: vt_ioctl.c
===================================================================
RCS file: /cvsroot/linuxconsole/ruby/ruby-2.6/drivers/char/vt_ioctl.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- vt_ioctl.c	12 Nov 2003 12:16:59 -0000	1.5
+++ vt_ioctl.c	20 Feb 2004 06:52:18 -0000	1.6
@@ -786,6 +786,9 @@
 		 * currently, setting the mode from KD_TEXT to KD_GRAPHICS
 		 * doesn't do a whole lot. i'm not sure if it should do any
 		 * restoration of modes or what...
+                 *
+                 * XXX It should at least call into the driver, fbdev's definitely
+                 * need to restore their engine state. --BenH
 		 */
 		if (!perm)
 			return -EPERM;
@@ -808,10 +811,12 @@
 		/*
 		 * explicitly blank/unblank the screen if switching modes
 		 */
+		acquire_console_sem();
 		if (arg == KD_TEXT)
 			unblank_vt(vc->display_fg);
 		else
 			do_blank_screen(vc->display_fg, 1);
+		release_console_sem();
 		return 0;
 
 	case KDGETMODE:
@@ -981,17 +986,29 @@
 			return -EFAULT;
 		if (tmp.mode != VT_AUTO && tmp.mode != VT_PROCESS)
 			return -EINVAL;
+		acquire_console_sem();
 		vc->vt_mode = tmp;
 		/* the frsig is ignored, so we set it to 0 */
 		vc->vt_mode.frsig = 0;
 		vc->vt_pid = current->pid;
 		/* no switch is required -- sa...@sh... */
 		vc->vt_newvt = -1; 
+		release_console_sem();
 		return 0;
 	}
 
 	case VT_GETMODE:
-		return copy_to_user((void*)arg, &(vc->vt_mode), sizeof(struct vt_mode)) ? -EFAULT : 0;
+	{
+		struct vt_mode tmp;
+		int rc;
+
+		acquire_console_sem();
+		memcpy(&tmp, &(vc->vt_mode), sizeof(struct vt_mode));
+		release_console_sem();
+
+		rc = copy_to_user((void*)arg, &tmp, sizeof(struct vt_mode));
+		return rc ? -EFAULT : 0;
+	}
 
 	/*
 	 * Returns global vt state. Note that VT 0 is always open, since
@@ -1047,7 +1064,9 @@
 		arg--;
 		tmp = find_vc(arg);
 		if (!tmp) {
+			acquire_console_sem();
 			tmp = vc_allocate(arg);
+			release_console_sem();
 			if (!tmp)
 				return arg;
 		}
@@ -1105,11 +1124,13 @@
 				 */
 				struct vc_data *tmp = find_vc(vc->vt_newvt); 
 								
+				acquire_console_sem();
 				if (!tmp) {	
 					tmp = vc_allocate(vc->vt_newvt);
 					if (!tmp) {
 						i = vc->vt_newvt;
 						vc->vt_newvt = -1;
+						release_console_sem();
 						return i;
 					}
 				}
@@ -1119,7 +1140,6 @@
 				 * make sure we are atomic with respect to
 				 * other console switches..
 				 */
-				acquire_console_sem();
 				complete_change_console(tmp, vc->display_fg->fg_console);
 				release_console_sem();
 			}
@@ -1144,18 +1164,22 @@
 			return -ENXIO;
 		if (arg == 0) {
 			/* disallocate all unused consoles, but leave visible VC */
+			acquire_console_sem();
 			for (i = 1; i < vt->vc_count; i++) {
 				tmp = find_vc(i + vt->first_vc);
 		
 				if (tmp && !VT_BUSY(tmp)) 
 					vc_disallocate(tmp);
 			}
+			release_console_sem();
 		} else {
 			/* disallocate a single console, if possible */
 			tmp = find_vc(arg-1);
 			if (!tmp || VT_BUSY(tmp))
 				return -EBUSY;
+			acquire_console_sem();
 			vc_disallocate(tmp);
+			release_console_sem();
 		}
 		return 0;
 	}
@@ -1171,7 +1195,9 @@
 		for (i = 0; i < vc->display_fg->vc_count; i++) {
 			struct vc_data *tmp = vc->display_fg->vc_cons[i];
 
+			acquire_console_sem();
 			vc_resize(tmp, cc, ll);
+			release_console_sem();
 		}
 		return 0;
 	}
@@ -1214,11 +1240,13 @@
 		for (i = 0; i < vc->display_fg->vc_count; i++) {
 			struct vc_data *tmp = vc->display_fg->vc_cons[i];
 
+			acquire_console_sem();
 			if (vlin)
 				tmp->vc_scan_lines = vlin;
 			if (clin)
 				tmp->vc_font.height = clin;
 			vc_resize(tmp, cc, ll);
+			release_console_sem();
 		}
 		return 0;
 	}