E55 status - THE DRIVER !

        n=0 (only)
-------------------------------------------------------
private:	[email protected]
company:	[email protected]
diff -u -r1.36 firmware.c
@@ -136,6 +136,15 @@
 }
 
 /**
+ * pdc_chassis_disp, used for E-series (for example E55)
+ */
+
+int pdc_chassis_disp(unsigned long disp)
+{
+        return mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_DISP, disp);
+}
+
+/**
  * pdc_chassis_info - Return chassis information.
  * @result: The return buffer.
  * @chassis_info: The memory buffer address.

@@ -681,6 +690,59 @@
                     PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
                     __pa(iodc_retbuf), 0, __pa(iodc_dbuf), n, 0);
         spin_unlock_irqrestore(&pdc_lock, flags);
+}
+
+/* write character directly without convertings */
+
+void pdc_iodc_outc(unsigned char c)
+{
+	/* fill buffer with one caracter and print it */
+        static int __attribute__((aligned(8)))   iodc_retbuf[32];
+        static char __attribute__((aligned(64))) iodc_dbuf[4096];
+	unsigned int n;
+
+	iodc_dbuf[0] = c;
+	n = 1;
+	{
+		real32_call(PAGE0->mem_cons.iodc_io,
+			(unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT,
+			PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
+			__pa(iodc_retbuf), 0, __pa(iodc_dbuf), n, 0);
+	}
+}
+
+/* read NON-BLOCKING a character from the PDC console,
+   returns -1, if no key is present */
+
+int pdc_iodc_getc(void)
+{
+        static int __attribute__((aligned(8)))   iodc_retbuf[32];
+        static char __attribute__((aligned(64))) iodc_dbuf[4096];
+	int ch;
+	int status;
+
+	/* Bail if no console input device. */
+	if (!PAGE0->mem_kbd.iodc_io)
+		return 0;
+	
+	/* wait for a keyboard (rs232)-input */
+	do {
+		unsigned long flags;
+
+		save_flags(flags);
+		cli();
+		status = real32_call(PAGE0->mem_kbd.iodc_io,
+			(unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN,
+			PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers),
+			__pa(iodc_retbuf), 0, __pa(iodc_dbuf), 1, 0);
+		restore_flags(flags);
+		ch = *iodc_dbuf;	/* save the character directly to ch */
+	} while (0) ;                   /* once !! */
+
+	if (*iodc_retbuf == 0)	        /* no key */
+	    ch = -1;
+	
+	return ch;
 }
 
 int pdc_sti_call(unsigned long func, unsigned long flags,

diff -u -r1.29 pdc_cons.c
@@ -12,9 +12,19 @@
 
 /* Define EARLY_BOOTUP_DEBUG to debug kernel related boot problems. 
  * On production kernels EARLY_BOOTUP_DEBUG should be undefined. */
-#undef EARLY_BOOTUP_DEBUG
 
+/* #undef EARLY_BOOTUP_DEBUG */
 
+/* CP 
+   activate PDC console in any case for testing the ttyB0
+
+   TODO: This must be activated if a "CONFIG_PDC_CONSOLE" is
+   configured (necessary), otherwise the EARLY_BOOTUP_DEBUG should
+   be undefined !
+*/
+#define EARLY_BOOTUP_DEBUG
+
+
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/console.h>

@@ -35,16 +45,32 @@
 		pdc_iodc_putc(*s++);
 }
 
+void pdc_outc(unsigned char c)
+{
+	pdc_iodc_outc(c);
+}
+
+
+int pdc_console_poll_key(struct console *co)
+{
+	return pdc_iodc_getc();
+}
+
 static int pdc_console_setup(struct console *co, char *options)
 {
 	return 0;
 }
 
+static kdev_t pdc_console_device (struct console *c)
+{
+        return MKDEV(PDCCONS_MAJOR, 0);
+}
+
 static struct console pdc_cons = {
 	name:		"ttyB",
 	write:		pdc_console_write,
 	read:		NULL,
-	device:		NULL, 
+	device:		pdc_console_device, 
 	wait_key:	NULL,
 	unblank:	NULL,
 	setup:		pdc_console_setup,

diff -u -r1.23 Makefile
@@ -64,6 +64,10 @@
 endif
 
 ifeq ($(ARCH),parisc)
+   # XXX CP: Added for all PA-RISC architecture, 
+   #         should be made configurable ...
+   obj-y += pdc_drv.o
+
    ifdef CONFIG_GSC_PS2
      KEYBD   = hp_psaux.o hp_keyb.o
    else

diff -u -r1.37 pdc.h
@@ -816,7 +816,9 @@
 int pdc_do_reset(void);
 int pdc_soft_power_info(unsigned long *power_reg);
 void pdc_soft_power_shutdown(void);
+int pdc_iodc_getc(void);
 void pdc_iodc_putc(unsigned char c);
+void pdc_iodc_outc(unsigned char c);
 
 int pdc_sti_call(unsigned long func, unsigned long flags,
                  unsigned long inptr, unsigned long outputr,

diff -u -r1.10 major.h
@@ -63,6 +63,7 @@
 #define ACSI_MAJOR	28
 #define AZTECH_CDROM_MAJOR 29
 #define GRAPHDEV_MAJOR	29	/* SparcLinux & Linux/68k /dev/fb */
+#define PDCCONS_MAJOR   30      /* CP: PDC console */
 #define SHMIQ_MAJOR	85	/* Linux/mips, SGI /dev/shmiq */
 #define CM206_CDROM_MAJOR 32
 #define IDE2_MAJOR	33

{
	struct tty_struct *tty = info->tty;
	unsigned char ch;
	int __ch;

	while (1) {
		__ch = pdc_console_poll_key (NULL);

		if (__ch == -1)   /* no character available */
		    break;

		ch = (unsigned char)((unsigned)__ch & 0x000000ffu);
		
		if (tty->flip.count >= TTY_FLIPBUF_SIZE)
			continue;

		*tty->flip.char_buf_ptr = ch;
		*tty->flip.flag_buf_ptr = 0;

		tty->flip.flag_buf_ptr++;
		tty->flip.char_buf_ptr++;
		tty->flip.count++;
	}
#if (LINUX_VERSION_CODE > 131394) /* 2.1.66 */
	tty_flip_buffer_push(tty);
#else
	queue_task_irq_off(&tty->flip.tqueue, &tq_timer);
{
    struct async_struct * info;
    int status = 0;

    info = pdc_drv_info;
    
    if (!info || !info->tty || (pdc_drv_refcount == 0)) 
    {
	/* do nothing */
    }
    else
    {
	receive_chars(info, &status, NULL);
	info->last_active = jiffies;
    }

    mod_timer (& pdc_drv_timer, jiffies + PDC_POLL_DELAY);
}
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: return\n");
#endif	
	pdc_outc (ch);
}
{
	/* PCD console always flushed all characters */
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: return\n");
	/* nothing to do */
}
{
	char pdc_tmp_buf [PDC_DUMMY_BUF];
	char * pdc_tmp_buf_ptr;
	int len;
	int ret = 0;
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: entry\n");
#endif	
	while (count) {
		if (count < PDC_DUMMY_BUF)
			len = count;
		else 
			len = PDC_DUMMY_BUF;
		
		if (from_user) {
			copy_from_user (pdc_tmp_buf, buf, len);
			pdc_tmp_buf_ptr = pdc_tmp_buf;
		}
		else
			pdc_tmp_buf_ptr = (char *) buf;
		
		while (len) {
			pdc_outc (*pdc_tmp_buf_ptr);
			buf++;
			pdc_tmp_buf_ptr++;
			ret++;
			count--;
			len--;
		}
	}
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: return\n");
#endif	
	return ret;
}
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: entry\n");
#endif	
	return PDC_DUMMY_BUF;
}
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: entry\n");
#ifdef PDC_DRV_DEBUG
	printk (KERN_NOTICE "%s: %s: return\n");
{
	struct async_struct *info = (struct async_struct *)tty->driver_data;
	
	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
	    (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
	    (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
		if (tty->flags & (1 << TTY_IO_ERROR))
		    return -EIO;
	}
	
	switch (cmd) {
		case TIOCMGET:
			return 0;
		case TIOCMBIS:
		case TIOCMBIC:
		case TIOCMSET:
			return 0;
		case TIOCGSERIAL:
			return 0;
		case TIOCSSERIAL:
			return 0;
		case TIOCSERCONFIG:
			return 0;

		case TIOCSERGETLSR: /* Get line status register */
			return 0;

		case TIOCSERGSTRUCT:
			if (copy_to_user((struct async_struct *) arg,
					 info, sizeof(struct async_struct)))
				return -EFAULT;
			return 0;
				
		case TIOCMIWAIT:
			return 0;

		case TIOCGICOUNT:
			return 0;
		case TIOCSERGWILD:
		case TIOCSERSWILD:
			/* "setserial -W" is called in Debian boot */
			printk ("TIOCSER?WILD ioctl obsolete, ignored.\n");
			return 0;

		default:
			return -ENOIOCTLCMD;
		}
	return 0;
}
#if 0	/* XXX CP, has to be checked, if there is stuff to do */
	struct async_struct *info = (struct async_struct *)tty->driver_data;
	unsigned long flags;
	unsigned int cflag = tty->termios->c_cflag;

	if (   (cflag == old_termios->c_cflag)
	    && (   RELEVANT_IFLAG(tty->termios->c_iflag) 
		== RELEVANT_IFLAG(old_termios->c_iflag)))
	  return;
#if 0
	change_speed(info, old_termios);
#endif
	/* Handle turning off CRTSCTS */
	if ((old_termios->c_cflag & CRTSCTS) &&
	    !(tty->termios->c_cflag & CRTSCTS)) {
		tty->hw_stopped = 0;
		pdc_start(tty);
	}
{
	struct async_struct * info = (struct async_struct *)tty->driver_data;
#ifdef PDC_DEBUG_OPEN
	printk("pdc_close ttyB%d, count = %d\n", info->line, state->count);
#endif
	pdc_drv_refcount--;
	if (pdc_drv_refcount > 0)
	    return;
	
	info->flags |= ASYNC_CLOSING;

	/*
	 * Save the termios structure, since this port may have
	 * separate termios for callout and dialin.
	 */
	if (info->flags & ASYNC_NORMAL_ACTIVE)
		info->state->normal_termios = *tty->termios;
	if (info->flags & ASYNC_CALLOUT_ACTIVE)
		info->state->callout_termios = *tty->termios;

	/*
	 * At this point we stop accepting input.  To do this, we
	 * disable the receive line status interrupts, and tell the
	 * interrupt driver to stop checking the data ready bit in the
	 * line status register.
	 */

	/* XXX CP: make mask for receive !!! */

	if (tty->driver.flush_buffer)
		tty->driver.flush_buffer(tty);
	if (tty->ldisc.flush_buffer)
		tty->ldisc.flush_buffer(tty);
	tty->closing = 0;
	info->event = 0;
	info->tty = 0;
	pdc_drv_info = NULL;
	if (info->blocked_open) {
		if (info->close_delay) {
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(info->close_delay);
		}
		wake_up_interruptible(&info->open_wait);
	}
	info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
			 ASYNC_CLOSING);
	wake_up_interruptible(&info->close_wait);
	MOD_DEC_USE_COUNT;
}
{
	/* we always send immideate */
}
{
	struct async_struct *info;
	
	info = kmalloc(sizeof(struct async_struct), GFP_KERNEL);
	if (!info) {
		return -ENOMEM;
	}
	memset(info, 0, sizeof(struct async_struct));
	init_waitqueue_head(&info->open_wait);
	init_waitqueue_head(&info->close_wait);
	init_waitqueue_head(&info->delta_msr_wait);
	info->magic = SERIAL_MAGIC;
	info->port = 0;
	info->flags = 0;
	info->io_type = 0;
	info->iomem_base = 0;
	info->iomem_reg_shift = 0;
	info->xmit_fifo_size = PDC_DUMMY_BUF;
	info->line = line;
	info->tqueue.routine = NULL;
	info->tqueue.data = info;
	info->state = NULL;
	*ret_info = info;
	return 0;
}
{
	struct async_struct	*info;
	int 			retval, line;
	unsigned long		page;
	
	MOD_INC_USE_COUNT;
	line = MINOR(tty->device) - tty->driver.minor_start;
	if ((line < 0) || (line >= NR_PORTS)) {
		MOD_DEC_USE_COUNT;
		return -ENODEV;
	}
	retval = get_async_struct(line, &info);
	if (retval) {
		MOD_DEC_USE_COUNT;
		return retval;
	}
	tty->driver_data = info;
	info->tty = tty;
	pdc_drv_info = info;
#ifdef PDC_DEBUG_OPEN
	printk("pdc_open %s%d, count = %d\n", tty->driver.name, info->line,
	       info->state->count);
#endif
#if (LINUX_VERSION_CODE > 0x20100)
	info->tty->low_latency = 0;
	if (!tmp_buf) {
		page = get_zeroed_page(GFP_KERNEL);
		if (!page) {
			MOD_DEC_USE_COUNT;
			return -ENOMEM;
		}
		if (tmp_buf)
			free_page(page);
		else
			tmp_buf = (unsigned char *) page;
	}

	info->session = current->session;
	info->pgrp = current->pgrp;
#ifdef PDC_DEBUG_OPEN
	printk("pdc_open ttyB%d successful...", info->line);
#endif
	pdc_drv_refcount++;
	return 0;
}
	       pdc_drv_version, LOCAL_VERSTRING, pdc_drv_revdate,
	       AUTHOR);
}
{
	init_timer(&pdc_drv_timer);
	pdc_drv_timer.function = pdc_drv_poll;
	mod_timer(&pdc_drv_timer, jiffies + PDC_POLL_DELAY);

	show_pdc_drv_version();

	/* Initialize the tty_driver structure */
	
	memset(&pdc_drv_driver, 0, sizeof(struct tty_driver));
	pdc_drv_driver.magic = TTY_DRIVER_MAGIC;
#if (LINUX_VERSION_CODE > 0x20100)
	pdc_drv_driver.driver_name = "pdc_drv";
#endif
#if (LINUX_VERSION_CODE > 0x2032D && defined(CONFIG_DEVFS_FS))
	pdc_drv_driver.name = "ttb/%d";
#else
	pdc_drv_driver.name = "ttyB";
#endif
	pdc_drv_driver.major = PDCCONS_MAJOR;
	pdc_drv_driver.minor_start = 0;
	pdc_drv_driver.num = NR_PORTS;
	pdc_drv_driver.type = TTY_DRIVER_TYPE_SERIAL;
	pdc_drv_driver.subtype = SERIAL_TYPE_NORMAL;
	pdc_drv_driver.init_termios = tty_std_termios;
	pdc_drv_driver.init_termios.c_cflag =
		B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	pdc_drv_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
	pdc_drv_driver.refcount = &pdc_drv_refcount;
	pdc_drv_driver.table = pdc_drv_table;
	pdc_drv_driver.termios = pdc_drv_termios;
	pdc_drv_driver.termios_locked = pdc_drv_termios_locked;

	pdc_drv_driver.open = pdc_open;
	pdc_drv_driver.close = pdc_close;
	pdc_drv_driver.write = pdc_write;
	pdc_drv_driver.put_char = pdc_put_char;
	pdc_drv_driver.flush_chars = pdc_flush_chars;
	pdc_drv_driver.write_room = pdc_write_room;
	pdc_drv_driver.chars_in_buffer = pdc_chars_in_buffer;
	pdc_drv_driver.flush_buffer = pdc_flush_buffer;
	pdc_drv_driver.ioctl = pdc_ioctl;
	pdc_drv_driver.throttle = pdc_throttle;
	pdc_drv_driver.unthrottle = pdc_unthrottle;
	pdc_drv_driver.set_termios = pdc_set_termios;
	pdc_drv_driver.stop = pdc_stop;
	pdc_drv_driver.start = pdc_start;
	pdc_drv_driver.hangup = pdc_hangup;
#if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */
	pdc_drv_driver.break_ctl = pdc_break;
#endif
#if (LINUX_VERSION_CODE >= 131343)
	pdc_drv_driver.send_xchar = pdc_send_xchar;
	pdc_drv_driver.wait_until_sent = pdc_wait_until_sent;
	pdc_drv_driver.read_proc = NULL;
#endif
	
	if (tty_register_driver(&pdc_drv_driver))
		panic("Couldn't register pdc_drv driver\n");
	
	return 0;
}
{
	int e1;

	if ((e1 = tty_unregister_driver(&pdc_drv_driver)))
		printk("pdc_drv: failed to unregister pdc_drv driver (%d)\n",
		       e1);
}
-------------------------------------------------------
private:	[email protected]
company:	[email protected]
-------------------------------------------------------
private:	[email protected]
company:	[email protected]


_______________________________________________
parisc-linux mailing list
[email protected]
http://lists.parisc-linux.org/mailman/listinfo/parisc-linux
-------------------------------------------------------
private:	[email protected]
company:	[email protected]
-------------------------------------------------------
private:	[email protected]
company:	[email protected]


_______________________________________________
parisc-linux mailing list
[email protected]
http://lists.parisc-linux.org/mailman/listinfo/parisc-linux
private:      [email protected]
company:      [email protected]
-------------------------------------------------------
private:	[email protected]
company:	[email protected]
-------------------------------------------------------
private:	[email protected]
company:	[email protected]

E55 status - THE DRIVER !

Christoph Plattner

Ryan Bradetich

Ryan Bradetich

Christoph Plattner

Ryan Bradetich

Christoph Plattner

Ryan Bradetich

Christoph Plattner

Christoph Plattner