Skip to content

L
linux
Commit d022be21 authored by Martin Schwidefsky's avatar Martin Schwidefsky Committed by Linus Torvalds
Browse files
Options

[PATCH] s390: 3215 driver. 

Convert 3215 console driver to new channel subsystem driver

this adds support for the driver model to the 3215 driver. The console
is one of the biggest problems because the regular device detection
is now done at initcall time although we actually want full
support for channel attached console devices as early as possible.
con3215_init() now uses a special ccw_device_probe_console() function
to do an early initialization of a single device.

The main backdraw for users is that the console can no longer
be autodetected when not running under VM. LPAR or P390 users
with a channel attached console now have to specify
console_device=f00 as a kernel parameter.

Authors:
	Martin Schwidefsky <schwidefsky@de.ibm.com>
	Arnd Bergmann <arndb@de.ibm.com>
parent 49a09376
Hide whitespace changes
Inline Side-by-side
Showing with 493 additions and 447 deletions
drivers/char/tty_io.c
View file @ d022be21
...@@ -2222,7 +2222,7 @@ void __init console_init(void) ...@@ -2222,7 +2222,7 @@ void __init console_init(void)
#ifdef CONFIG_TN3270_CONSOLE #ifdef CONFIG_TN3270_CONSOLE
tub3270_con_init(); tub3270_con_init();
#endif #endif
#ifdef CONFIG_TN3215 #ifdef CONFIG_TN3215_CONSOLE
con3215_init(); con3215_init();
#endif #endif
#ifdef CONFIG_SCLP_CONSOLE #ifdef CONFIG_SCLP_CONSOLE
...@@ -2363,10 +2363,7 @@ void __init tty_init(void) ...@@ -2363,10 +2363,7 @@ void __init tty_init(void)
#ifdef CONFIG_TN3270 #ifdef CONFIG_TN3270
tub3270_init(); tub3270_init();
#endif #endif
#ifdef CONFIG_TN3215 #ifdef CONFIG_SCLP_TTY
tty3215_init();
#endif
#ifdef CONFIG_SCLP
sclp_tty_init(); sclp_tty_init();
#endif #endif
#ifdef CONFIG_A2232 #ifdef CONFIG_A2232
......
drivers/s390/char/con3215.c
View file @ d022be21
...@@ -8,10 +8,11 @@ ...@@ -8,10 +8,11 @@
* *
* Updated: * Updated:
* Aug-2000: Added tab support * Aug-2000: Added tab support
* Dan Morrison, IBM Corporation (dmorriso@cse.buffalo.edu) * Dan Morrison, IBM Corporation (dmorriso@cse.buffalo.edu)
*/ */
#include <linux/config.h> #include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/kdev_t.h> #include <linux/kdev_t.h>
#include <linux/tty.h> #include <linux/tty.h>
...@@ -22,14 +23,14 @@ ...@@ -22,14 +23,14 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/bootmem.h> #include <linux/bootmem.h>
#include <linux/devfs_fs_kernel.h>
#include <asm/ccwdev.h>
#include <asm/cio.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/ebcdic.h> #include <asm/ebcdic.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/delay.h> #include <asm/delay.h>
#include <asm/cpcmd.h> #include <asm/cpcmd.h>
#include <asm/irq.h>
#include <asm/setup.h> #include <asm/setup.h>
#include "ctrlchar.h" #include "ctrlchar.h"
...@@ -41,7 +42,7 @@ ...@@ -41,7 +42,7 @@
#define RAW3215_MIN_SPACE 128 /* minimum free space for wakeup */ #define RAW3215_MIN_SPACE 128 /* minimum free space for wakeup */
#define RAW3215_MIN_WRITE 1024 /* min. length for immediate output */ #define RAW3215_MIN_WRITE 1024 /* min. length for immediate output */
#define RAW3215_MAX_BYTES 3968 /* max. bytes to write with one ssch */ #define RAW3215_MAX_BYTES 3968 /* max. bytes to write with one ssch */
#define RAW3215_MAX_NEWLINE 50 /* max. lines to write with one ssch */ #define RAW3215_MAX_NEWLINE 50 /* max. lines to write with one ssch */
#define RAW3215_NR_CCWS 3 #define RAW3215_NR_CCWS 3
#define RAW3215_TIMEOUT HZ/10 /* time for delayed output */ #define RAW3215_TIMEOUT HZ/10 /* time for delayed output */
...@@ -53,56 +54,58 @@ ...@@ -53,56 +54,58 @@
#define RAW3215_CLOSING 32 /* set while in close process */ #define RAW3215_CLOSING 32 /* set while in close process */
#define RAW3215_TIMER_RUNS 64 /* set if the output delay timer is on */ #define RAW3215_TIMER_RUNS 64 /* set if the output delay timer is on */
#define RAW3215_FLUSHING 128 /* set to flush buffer (no delay) */ #define RAW3215_FLUSHING 128 /* set to flush buffer (no delay) */
#define RAW3215_BH_PENDING 256 /* indication for bh scheduling */
#define TAB_STOP_SIZE 8 /* tab stop size */ #define TAB_STOP_SIZE 8 /* tab stop size */
struct _raw3215_info; /* forward declaration ... */
/* /*
* Request types for a 3215 device * Request types for a 3215 device
*/ */
typedef enum { enum raw3215_type {
RAW3215_FREE, RAW3215_READ, RAW3215_WRITE RAW3215_FREE, RAW3215_READ, RAW3215_WRITE
} raw3215_type; };
/* /*
* Request structure for a 3215 device * Request structure for a 3215 device
*/ */
typedef struct _raw3215_req { struct raw3215_req {
raw3215_type type; /* type of the request */ enum raw3215_type type; /* type of the request */
int start, len; /* start index & len in output buffer */ int start, len; /* start index & len in output buffer */
int delayable; /* indication to wait for more data */ int delayable; /* indication to wait for more data */
int residual; /* residual count for read request */ int residual; /* residual count for read request */
ccw1_t ccws[RAW3215_NR_CCWS]; /* space for the channel program */ struct ccw1 ccws[RAW3215_NR_CCWS]; /* space for the channel program */
struct _raw3215_info *info; /* pointer to main structure */ struct raw3215_info *info; /* pointer to main structure */
struct _raw3215_req *next; /* pointer to next request */ struct raw3215_req *next; /* pointer to next request */
} raw3215_req __attribute__ ((aligned(8))); } __attribute__ ((aligned(8)));
typedef struct _raw3215_info { struct raw3215_info {
struct ccw_device *cdev; /* device for tty driver */
spinlock_t *lock; /* pointer to irq lock */
int flags; /* state flags */ int flags; /* state flags */
int irq; /* interrupt number to do_IO */
char *buffer; /* pointer to output buffer */ char *buffer; /* pointer to output buffer */
char *inbuf; /* pointer to input buffer */ char *inbuf; /* pointer to input buffer */
int head; /* first free byte in output buffer */ int head; /* first free byte in output buffer */
int count; /* number of bytes in output buffer */ int count; /* number of bytes in output buffer */
int written; /* number of bytes in write requests */ int written; /* number of bytes in write requests */
devstat_t devstat; /* device status structure for do_IO */
struct tty_struct *tty; /* pointer to tty structure if present */ struct tty_struct *tty; /* pointer to tty structure if present */
struct tasklet_struct tasklet; struct tasklet_struct tasklet;
raw3215_req *queued_read; /* pointer to queued read requests */ struct raw3215_req *queued_read; /* pointer to queued read requests */
raw3215_req *queued_write; /* pointer to queued write requests */ struct raw3215_req *queued_write;/* pointer to queued write requests */
wait_queue_head_t empty_wait; /* wait queue for flushing */ wait_queue_head_t empty_wait; /* wait queue for flushing */
struct timer_list timer; /* timer for delayed output */ struct timer_list timer; /* timer for delayed output */
char *message; /* pending message from raw3215_irq */ char *message; /* pending message from raw3215_irq */
int msg_dstat; /* dstat for pending message */ int msg_dstat; /* dstat for pending message */
int msg_cstat; /* cstat for pending message */ int msg_cstat; /* cstat for pending message */
int line_pos; /* position on the line (for tabs) */ int line_pos; /* position on the line (for tabs) */
} raw3215_info; };
static raw3215_info *raw3215[NR_3215]; /* array of 3215 devices structures */ /* array of 3215 devices structures */
static raw3215_req *raw3215_freelist; /* list of free request structures */ static struct raw3215_info *raw3215[NR_3215];
static spinlock_t raw3215_freelist_lock;/* spinlock to protect free list */ /* spinlock to protect the raw3215 array */
static spinlock_t raw3215_device_lock = SPIN_LOCK_UNLOCKED;
/* list of free request structures */
static struct raw3215_req *raw3215_freelist;
/* spinlock to protect free list */
static spinlock_t raw3215_freelist_lock;
static struct tty_driver tty3215_driver; static struct tty_driver tty3215_driver;
static struct tty_struct *tty3215_table[NR_3215]; static struct tty_struct *tty3215_table[NR_3215];
...@@ -110,15 +113,12 @@ static struct termios *tty3215_termios[NR_3215]; ...@@ -110,15 +113,12 @@ static struct termios *tty3215_termios[NR_3215];
static struct termios *tty3215_termios_locked[NR_3215]; static struct termios *tty3215_termios_locked[NR_3215];
static int tty3215_refcount; static int tty3215_refcount;
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
/* /*
* Get a request structure from the free list * Get a request structure from the free list
*/ */
extern inline raw3215_req *raw3215_alloc_req(void) { static inline struct raw3215_req *
raw3215_req *req; raw3215_alloc_req(void) {
struct raw3215_req *req;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&raw3215_freelist_lock, flags); spin_lock_irqsave(&raw3215_freelist_lock, flags);
...@@ -131,12 +131,13 @@ extern inline raw3215_req *raw3215_alloc_req(void) { ...@@ -131,12 +131,13 @@ extern inline raw3215_req *raw3215_alloc_req(void) {
/* /*
* Put a request structure back to the free list * Put a request structure back to the free list
*/ */
extern inline void raw3215_free_req(raw3215_req *req) { static inline void
raw3215_free_req(struct raw3215_req *req) {
unsigned long flags; unsigned long flags;
if (req->type == RAW3215_FREE) if (req->type == RAW3215_FREE)
return; /* don't free a free request */ return; /* don't free a free request */
req->type = RAW3215_FREE; req->type = RAW3215_FREE;
spin_lock_irqsave(&raw3215_freelist_lock, flags); spin_lock_irqsave(&raw3215_freelist_lock, flags);
req->next = raw3215_freelist; req->next = raw3215_freelist;
raw3215_freelist = req; raw3215_freelist = req;
...@@ -149,10 +150,11 @@ extern inline void raw3215_free_req(raw3215_req *req) { ...@@ -149,10 +150,11 @@ extern inline void raw3215_free_req(raw3215_req *req) {
* because a 3215 terminal won't accept a new read before the old one is * because a 3215 terminal won't accept a new read before the old one is
* completed. * completed.
*/ */
static void raw3215_mk_read_req(raw3215_info *raw) static void
raw3215_mk_read_req(struct raw3215_info *raw)
{ {
raw3215_req *req; struct raw3215_req *req;
ccw1_t *ccw; struct ccw1 *ccw;
/* there can only be ONE read request at a time */ /* there can only be ONE read request at a time */
req = raw->queued_read; req = raw->queued_read;
...@@ -161,14 +163,14 @@ static void raw3215_mk_read_req(raw3215_info *raw) ...@@ -161,14 +163,14 @@ static void raw3215_mk_read_req(raw3215_info *raw)
req = raw3215_alloc_req(); req = raw3215_alloc_req();
req->type = RAW3215_READ; req->type = RAW3215_READ;
req->info = raw; req->info = raw;
raw->queued_read = req; raw->queued_read = req;
} }
ccw = req->ccws; ccw = req->ccws;
ccw->cmd_code = 0x0A; /* read inquiry */ ccw->cmd_code = 0x0A; /* read inquiry */
ccw->flags = 0x20; /* ignore incorrect length */ ccw->flags = 0x20; /* ignore incorrect length */
ccw->count = 160; ccw->count = 160;
ccw->cda = (__u32) __pa(raw->inbuf); ccw->cda = (__u32) __pa(raw->inbuf);
} }
/* /*
...@@ -177,49 +179,50 @@ static void raw3215_mk_read_req(raw3215_info *raw) ...@@ -177,49 +179,50 @@ static void raw3215_mk_read_req(raw3215_info *raw)
* buffer to the 3215 device. If a queued write exists it is replaced by * buffer to the 3215 device. If a queued write exists it is replaced by
* the new, probably lengthened request. * the new, probably lengthened request.
*/ */
static void raw3215_mk_write_req(raw3215_info *raw) static void
raw3215_mk_write_req(struct raw3215_info *raw)
{ {
raw3215_req *req; struct raw3215_req *req;
ccw1_t *ccw; struct ccw1 *ccw;
int len, count, ix, lines; int len, count, ix, lines;
if (raw->count <= raw->written) if (raw->count <= raw->written)
return; return;
/* check if there is a queued write request */ /* check if there is a queued write request */
req = raw->queued_write; req = raw->queued_write;
if (req == NULL) { if (req == NULL) {
/* no queued write request, use new req structure */ /* no queued write request, use new req structure */
req = raw3215_alloc_req(); req = raw3215_alloc_req();
req->type = RAW3215_WRITE; req->type = RAW3215_WRITE;
req->info = raw; req->info = raw;
raw->queued_write = req; raw->queued_write = req;
} else { } else {
raw->written -= req->len; raw->written -= req->len;
} }
ccw = req->ccws; ccw = req->ccws;
req->start = (raw->head - raw->count + raw->written) & req->start = (raw->head - raw->count + raw->written) &
(RAW3215_BUFFER_SIZE - 1); (RAW3215_BUFFER_SIZE - 1);
/* /*
* now we have to count newlines. We can at max accept * now we have to count newlines. We can at max accept
* RAW3215_MAX_NEWLINE newlines in a single ssch due to * RAW3215_MAX_NEWLINE newlines in a single ssch due to
* a restriction in VM * a restriction in VM
*/ */
lines = 0; lines = 0;
ix = req->start; ix = req->start;
while (lines < RAW3215_MAX_NEWLINE && ix != raw->head) { while (lines < RAW3215_MAX_NEWLINE && ix != raw->head) {
if (raw->buffer[ix] == 0x15) if (raw->buffer[ix] == 0x15)
lines++; lines++;
ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1); ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1);
} }
len = ((ix - 1 - req->start) & (RAW3215_BUFFER_SIZE - 1)) + 1; len = ((ix - 1 - req->start) & (RAW3215_BUFFER_SIZE - 1)) + 1;
if (len > RAW3215_MAX_BYTES) if (len > RAW3215_MAX_BYTES)
len = RAW3215_MAX_BYTES; len = RAW3215_MAX_BYTES;
req->len = len; req->len = len;
raw->written += len; raw->written += len;
/* set the indication if we should try to enlarge this request */ /* set the indication if we should try to enlarge this request */
req->delayable = (ix == raw->head) && (len < RAW3215_MIN_WRITE); req->delayable = (ix == raw->head) && (len < RAW3215_MIN_WRITE);
ix = req->start; ix = req->start;
while (len > 0) { while (len > 0) {
...@@ -237,25 +240,26 @@ static void raw3215_mk_write_req(raw3215_info *raw) ...@@ -237,25 +240,26 @@ static void raw3215_mk_write_req(raw3215_info *raw)
ix = (ix + count) & (RAW3215_BUFFER_SIZE - 1); ix = (ix + count) & (RAW3215_BUFFER_SIZE - 1);
ccw++; ccw++;
} }
/* /*
* Add a NOP to the channel program. 3215 devices are purely * Add a NOP to the channel program. 3215 devices are purely
* emulated and its much better to avoid the channel end * emulated and its much better to avoid the channel end
* interrupt in this case. * interrupt in this case.
*/ */
if (ccw > req->ccws) if (ccw > req->ccws)
ccw[-1].flags |= 0x40; /* use command chaining */ ccw[-1].flags |= 0x40; /* use command chaining */
ccw->cmd_code = 0x03; /* NOP */ ccw->cmd_code = 0x03; /* NOP */
ccw->flags = 0; ccw->flags = 0;
ccw->cda = 0; ccw->cda = 0;
ccw->count = 1; ccw->count = 1;
} }
/* /*
* Start a read or a write request * Start a read or a write request
*/ */
static void raw3215_start_io(raw3215_info *raw) static void
raw3215_start_io(struct raw3215_info *raw)
{ {
raw3215_req *req; struct raw3215_req *req;
int res; int res;
req = raw->queued_read; req = raw->queued_read;
...@@ -263,20 +267,22 @@ static void raw3215_start_io(raw3215_info *raw) ...@@ -263,20 +267,22 @@ static void raw3215_start_io(raw3215_info *raw)
!(raw->flags & (RAW3215_WORKING | RAW3215_THROTTLED))) { !(raw->flags & (RAW3215_WORKING | RAW3215_THROTTLED))) {
/* dequeue request */ /* dequeue request */
raw->queued_read = NULL; raw->queued_read = NULL;
res = do_IO(raw->irq, req->ccws, (unsigned long) req, 0, 0); res = ccw_device_start(raw->cdev, req->ccws,
(unsigned long) req, 0, 0);
if (res != 0) { if (res != 0) {
/* do_IO failed, put request back to queue */ /* do_IO failed, put request back to queue */
raw->queued_read = req; raw->queued_read = req;
} else { } else {
raw->flags |= RAW3215_WORKING; raw->flags |= RAW3215_WORKING;
} }
} }
req = raw->queued_write; req = raw->queued_write;
if (req != NULL && if (req != NULL &&
!(raw->flags & (RAW3215_WORKING | RAW3215_STOPPED))) { !(raw->flags & (RAW3215_WORKING | RAW3215_STOPPED))) {
/* dequeue request */ /* dequeue request */
raw->queued_write = NULL; raw->queued_write = NULL;
res = do_IO(raw->irq, req->ccws, (unsigned long) req, 0, 0); res = ccw_device_start(raw->cdev, req->ccws,
(unsigned long) req, 0, 0);
if (res != 0) { if (res != 0) {
/* do_IO failed, put request back to queue */ /* do_IO failed, put request back to queue */
raw->queued_write = req; raw->queued_write = req;
...@@ -289,19 +295,20 @@ static void raw3215_start_io(raw3215_info *raw) ...@@ -289,19 +295,20 @@ static void raw3215_start_io(raw3215_info *raw)
/* /*
* Function to start a delayed output after RAW3215_TIMEOUT seconds * Function to start a delayed output after RAW3215_TIMEOUT seconds
*/ */
static void raw3215_timeout(unsigned long __data) static void
raw3215_timeout(unsigned long __data)
{ {
raw3215_info *raw = (raw3215_info *) __data; struct raw3215_info *raw = (struct raw3215_info *) __data;
unsigned long flags; unsigned long flags;
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
if (raw->flags & RAW3215_TIMER_RUNS) { if (raw->flags & RAW3215_TIMER_RUNS) {
del_timer(&raw->timer); del_timer(&raw->timer);
raw->flags &= ~RAW3215_TIMER_RUNS; raw->flags &= ~RAW3215_TIMER_RUNS;
raw3215_mk_write_req(raw); raw3215_mk_write_req(raw);
raw3215_start_io(raw); raw3215_start_io(raw);
} }
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
/* /*
...@@ -310,7 +317,8 @@ static void raw3215_timeout(unsigned long __data) ...@@ -310,7 +317,8 @@ static void raw3215_timeout(unsigned long __data)
* amount of data is bigger than RAW3215_MIN_WRITE. If a write is not * amount of data is bigger than RAW3215_MIN_WRITE. If a write is not
* done immediatly a timer is started with a delay of RAW3215_TIMEOUT. * done immediatly a timer is started with a delay of RAW3215_TIMEOUT.
*/ */
extern inline void raw3215_try_io(raw3215_info *raw) static inline void
raw3215_try_io(struct raw3215_info *raw)
{ {
if (!(raw->flags & RAW3215_ACTIVE)) if (!(raw->flags & RAW3215_ACTIVE))
return; return;
...@@ -320,7 +328,7 @@ extern inline void raw3215_try_io(raw3215_info *raw) ...@@ -320,7 +328,7 @@ extern inline void raw3215_try_io(raw3215_info *raw)
if ((raw->queued_write->delayable == 0) || if ((raw->queued_write->delayable == 0) ||
(raw->flags & RAW3215_FLUSHING)) { (raw->flags & RAW3215_FLUSHING)) {
/* execute write requests bigger than minimum size */ /* execute write requests bigger than minimum size */
raw3215_start_io(raw); raw3215_start_io(raw);
if (raw->flags & RAW3215_TIMER_RUNS) { if (raw->flags & RAW3215_TIMER_RUNS) {
del_timer(&raw->timer); del_timer(&raw->timer);
raw->flags &= ~RAW3215_TIMER_RUNS; raw->flags &= ~RAW3215_TIMER_RUNS;
...@@ -341,21 +349,21 @@ extern inline void raw3215_try_io(raw3215_info *raw) ...@@ -341,21 +349,21 @@ extern inline void raw3215_try_io(raw3215_info *raw)
* The bottom half handler routine for 3215 devices. It tries to start * The bottom half handler routine for 3215 devices. It tries to start
* the next IO and wakes up processes waiting on the tty. * the next IO and wakes up processes waiting on the tty.
*/ */
static void raw3215_tasklet(void *data) static void
raw3215_tasklet(void *data)
{ {
raw3215_info *raw; struct raw3215_info *raw;
struct tty_struct *tty; struct tty_struct *tty;
unsigned long flags; unsigned long flags;
raw = (raw3215_info *) data; raw = (struct raw3215_info *) data;
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
raw3215_mk_write_req(raw); raw3215_mk_write_req(raw);
raw3215_try_io(raw); raw3215_try_io(raw);
raw->flags &= ~RAW3215_BH_PENDING; spin_unlock_irqrestore(raw->lock, flags);
s390irq_spin_unlock_irqrestore(raw->irq, flags);
/* Check for pending message from raw3215_irq */ /* Check for pending message from raw3215_irq */
if (raw->message != NULL) { if (raw->message != NULL) {
printk(raw->message, raw->irq, raw->msg_dstat, raw->msg_cstat); printk(raw->message, raw->msg_dstat, raw->msg_cstat);
raw->message = NULL; raw->message = NULL;
} }
tty = raw->tty; tty = raw->tty;
...@@ -369,99 +377,67 @@ static void raw3215_tasklet(void *data) ...@@ -369,99 +377,67 @@ static void raw3215_tasklet(void *data)
} }
/* /*
* Interrupt routine, called from common io layer
*/ */
static inline void raw3215_sched_tasklet(raw3215_info *raw) static void
{ raw3215_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
if (raw->flags & RAW3215_BH_PENDING)
return; /* already pending */
raw->flags |= RAW3215_BH_PENDING;
tasklet_hi_schedule(&raw->tasklet);
}
/*
* Find the raw3215_info structure associated with irq
*/
static inline raw3215_info *raw3215_find_info(int irq) {
raw3215_info *raw;
int i;
for (i = 0; i < NR_3215; i++) {
raw = raw3215[i];
if (raw != NULL && raw->irq == irq &&
(raw->flags & RAW3215_ACTIVE))
break;
}
return (i >= NR_3215) ? NULL : raw;
}
/*
* Interrupt routine, called from Ingo's I/O layer
*/
static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw3215_req *req; struct raw3215_req *req;
struct tty_struct *tty; struct tty_struct *tty;
devstat_t *stat; int cstat, dstat;
int cstat, dstat;
int count, slen; int count, slen;
stat = (devstat_t *) int_parm; raw = cdev->dev.driver_data;
req = (raw3215_req *) stat->intparm; req = (struct raw3215_req *) intparm;
cstat = stat->cstat; cstat = irb->scsw.cstat;
dstat = stat->dstat; dstat = irb->scsw.dstat;
if (cstat != 0) { if (cstat != 0) {
raw = raw3215_find_info(irq); raw->message = KERN_WARNING
if (raw != NULL) { "Got nonzero channel status in raw3215_irq "
raw->message = KERN_WARNING "(dev sts 0x%2x, sch sts 0x%2x)";
"Got nonzero channel status in raw3215_irq " raw->msg_dstat = dstat;
"(dev %i, dev sts 0x%2x, sch sts 0x%2x)"; raw->msg_cstat = cstat;
raw->msg_dstat = dstat; tasklet_schedule(&raw->tasklet);
raw->msg_cstat = cstat; }
raw3215_sched_tasklet(raw); if (dstat & 0x01) { /* we got a unit exception */
} dstat &= ~0x01; /* we can ignore it */
} }
if (dstat & 0x01) { /* we got a unit exception */
dstat &= ~0x01; /* we can ignore it */
}
switch (dstat) { switch (dstat) {
case 0x80: case 0x80:
if (cstat != 0) if (cstat != 0)
break; break;
/* Attention interrupt, someone hit the enter key */ /* Attention interrupt, someone hit the enter key */
if ((raw = raw3215_find_info(irq)) == NULL)
return; /* That shouldn't happen ... */
/* Setup a read request */
raw3215_mk_read_req(raw); raw3215_mk_read_req(raw);
if (MACHINE_IS_P390) if (MACHINE_IS_P390)
memset(raw->inbuf, 0, RAW3215_INBUF_SIZE); memset(raw->inbuf, 0, RAW3215_INBUF_SIZE);
raw3215_sched_tasklet(raw); tasklet_schedule(&raw->tasklet);
break; break;
case 0x08: case 0x08:
case 0x0C: case 0x0C:
/* Channel end interrupt. */ /* Channel end interrupt. */
if ((raw = req->info) == NULL) if ((raw = req->info) == NULL)
return; /* That shouldn't happen ... */ return; /* That shouldn't happen ... */
if (req->type == RAW3215_READ) { if (req->type == RAW3215_READ) {
/* store residual count, then wait for device end */ /* store residual count, then wait for device end */
req->residual = stat->rescnt; req->residual = irb->scsw.count;
} }
if (dstat == 0x08) if (dstat == 0x08)
break; break;
case 0x04: case 0x04:
/* Device end interrupt. */ /* Device end interrupt. */
if ((raw = req->info) == NULL) if ((raw = req->info) == NULL)
return; /* That shouldn't happen ... */ return; /* That shouldn't happen ... */
if (req->type == RAW3215_READ && raw->tty != NULL) { if (req->type == RAW3215_READ && raw->tty != NULL) {
unsigned int cchar; unsigned int cchar;
tty = raw->tty; tty = raw->tty;
count = 160 - req->residual; count = 160 - req->residual;
if (MACHINE_IS_P390) { if (MACHINE_IS_P390) {
slen = strnlen(raw->inbuf, RAW3215_INBUF_SIZE); slen = strnlen(raw->inbuf, RAW3215_INBUF_SIZE);
if (count > slen) if (count > slen)
count = slen; count = slen;
} else } else
if (count >= TTY_FLIPBUF_SIZE - tty->flip.count) if (count >= TTY_FLIPBUF_SIZE - tty->flip.count)
count = TTY_FLIPBUF_SIZE - tty->flip.count - 1; count = TTY_FLIPBUF_SIZE - tty->flip.count - 1;
EBCASC(raw->inbuf, count); EBCASC(raw->inbuf, count);
...@@ -498,9 +474,8 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs) ...@@ -498,9 +474,8 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs)
} }
} else if (req->type == RAW3215_WRITE) { } else if (req->type == RAW3215_WRITE) {
raw->count -= req->len; raw->count -= req->len;
raw->written -= req->len; raw->written -= req->len;
} }
raw->flags &= ~RAW3215_WORKING; raw->flags &= ~RAW3215_WORKING;
raw3215_free_req(req); raw3215_free_req(req);
/* check for empty wait */ /* check for empty wait */
...@@ -509,27 +484,24 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs) ...@@ -509,27 +484,24 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs)
raw->queued_read == NULL) { raw->queued_read == NULL) {
wake_up_interruptible(&raw->empty_wait); wake_up_interruptible(&raw->empty_wait);
} }
raw3215_sched_tasklet(raw); tasklet_schedule(&raw->tasklet);
break; break;
default: default:
/* Strange interrupt, I'll do my best to clean up */ /* Strange interrupt, I'll do my best to clean up */
if ((raw = raw3215_find_info(irq)) == NULL)
return; /* That shouldn't happen ... */
if (raw == NULL) break;
if (req != NULL && req->type != RAW3215_FREE) { if (req != NULL && req->type != RAW3215_FREE) {
if (req->type == RAW3215_WRITE) { if (req->type == RAW3215_WRITE) {
raw->count -= req->len; raw->count -= req->len;
raw->written -= req->len; raw->written -= req->len;
} }
raw->flags &= ~RAW3215_WORKING; raw->flags &= ~RAW3215_WORKING;
raw3215_free_req(req); raw3215_free_req(req);
} }
raw->message = KERN_WARNING raw->message = KERN_WARNING
"Spurious interrupt in in raw3215_irq " "Spurious interrupt in in raw3215_irq "
"(dev %i, dev sts 0x%2x, sch sts 0x%2x)"; "(dev sts 0x%2x, sch sts 0x%2x)";
raw->msg_dstat = dstat; raw->msg_dstat = dstat;
raw->msg_cstat = cstat; raw->msg_cstat = cstat;
raw3215_sched_tasklet(raw); tasklet_schedule(&raw->tasklet);
} }
return; return;
} }
...@@ -539,7 +511,8 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs) ...@@ -539,7 +511,8 @@ static void raw3215_irq(int irq, void *int_parm, struct pt_regs *regs)
* Has to be called with the s390irq lock held. Can be called * Has to be called with the s390irq lock held. Can be called
* disabled. * disabled.
*/ */
static void raw3215_make_room(raw3215_info *raw, unsigned int length) static void
raw3215_make_room(struct raw3215_info *raw, unsigned int length)
{ {
while (RAW3215_BUFFER_SIZE - raw->count < length) { while (RAW3215_BUFFER_SIZE - raw->count < length) {
/* there might be a request pending */ /* there might be a request pending */
...@@ -547,18 +520,16 @@ static void raw3215_make_room(raw3215_info *raw, unsigned int length) ...@@ -547,18 +520,16 @@ static void raw3215_make_room(raw3215_info *raw, unsigned int length)
raw3215_mk_write_req(raw); raw3215_mk_write_req(raw);
raw3215_try_io(raw); raw3215_try_io(raw);
raw->flags &= ~RAW3215_FLUSHING; raw->flags &= ~RAW3215_FLUSHING;
if (wait_cons_dev(raw->irq) != 0) { #ifdef CONFIG_TN3215_CONSOLE
/* that shouldn't happen */ wait_cons_dev();
raw->count = 0; #endif
raw->written = 0;
}
/* Enough room freed up ? */ /* Enough room freed up ? */
if (RAW3215_BUFFER_SIZE - raw->count >= length) if (RAW3215_BUFFER_SIZE - raw->count >= length)
break; break;
/* there might be another cpu waiting for the lock */ /* there might be another cpu waiting for the lock */
s390irq_spin_unlock(raw->irq); spin_unlock(raw->lock);
udelay(100); udelay(100);
s390irq_spin_lock(raw->irq); spin_lock(raw->lock);
} }
} }
...@@ -566,27 +537,27 @@ static void raw3215_make_room(raw3215_info *raw, unsigned int length) ...@@ -566,27 +537,27 @@ static void raw3215_make_room(raw3215_info *raw, unsigned int length)
* String write routine for 3215 devices * String write routine for 3215 devices
*/ */
static int static int
raw3215_write(raw3215_info *raw, const char *str, raw3215_write(struct raw3215_info *raw, const char *str,
int from_user, unsigned int length) int from_user, unsigned int length)
{ {
unsigned long flags; unsigned long flags;
int ret, c; int ret, c;
int count; int count;
ret = 0; ret = 0;
while (length > 0) { while (length > 0) {
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
count = (length > RAW3215_BUFFER_SIZE) ? count = (length > RAW3215_BUFFER_SIZE) ?
RAW3215_BUFFER_SIZE : length; RAW3215_BUFFER_SIZE : length;
length -= count; length -= count;
raw3215_make_room(raw, count); raw3215_make_room(raw, count);
/* copy string to output buffer and convert it to EBCDIC */ /* copy string to output buffer and convert it to EBCDIC */
if (from_user) { if (from_user) {
while (1) { while (1) {
c = MIN(count, c = min_t(int, count,
MIN(RAW3215_BUFFER_SIZE - raw->count, min(RAW3215_BUFFER_SIZE - raw->count,
RAW3215_BUFFER_SIZE - raw->head)); RAW3215_BUFFER_SIZE - raw->head));
if (c <= 0) if (c <= 0)
break; break;
...@@ -608,8 +579,8 @@ raw3215_write(raw3215_info *raw, const char *str, ...@@ -608,8 +579,8 @@ raw3215_write(raw3215_info *raw, const char *str,
} }
} else { } else {
while (1) { while (1) {
c = MIN(count, c = min_t(int, count,
MIN(RAW3215_BUFFER_SIZE - raw->count, min(RAW3215_BUFFER_SIZE - raw->count,
RAW3215_BUFFER_SIZE - raw->head)); RAW3215_BUFFER_SIZE - raw->head));
if (c <= 0) if (c <= 0)
break; break;
...@@ -624,12 +595,12 @@ raw3215_write(raw3215_info *raw, const char *str, ...@@ -624,12 +595,12 @@ raw3215_write(raw3215_info *raw, const char *str,
ret += c; ret += c;
} }
} }
if (!(raw->flags & RAW3215_WORKING)) { if (!(raw->flags & RAW3215_WORKING)) {
raw3215_mk_write_req(raw); raw3215_mk_write_req(raw);
/* start or queue request */ /* start or queue request */
raw3215_try_io(raw); raw3215_try_io(raw);
} }
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
return ret; return ret;
...@@ -638,162 +609,239 @@ raw3215_write(raw3215_info *raw, const char *str, ...@@ -638,162 +609,239 @@ raw3215_write(raw3215_info *raw, const char *str,
/* /*
* Put character routine for 3215 devices * Put character routine for 3215 devices
*/ */
static void
static void raw3215_putchar(raw3215_info *raw, unsigned char ch) raw3215_putchar(struct raw3215_info *raw, unsigned char ch)
{ {
unsigned long flags; unsigned long flags;
unsigned int length, i; unsigned int length, i;
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
if (ch == '\t') { if (ch == '\t') {
length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE); length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE);
raw->line_pos += length; raw->line_pos += length;
ch = ' '; ch = ' ';
} else if (ch == '\n') { } else if (ch == '\n') {
length = 1; length = 1;
raw->line_pos = 0; raw->line_pos = 0;
} else { } else {
length = 1; length = 1;
raw->line_pos++; raw->line_pos++;
} }
raw3215_make_room(raw, length); raw3215_make_room(raw, length);
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
raw->buffer[raw->head] = (char) _ascebc[(int) ch]; raw->buffer[raw->head] = (char) _ascebc[(int) ch];
raw->head = (raw->head + 1) & (RAW3215_BUFFER_SIZE - 1); raw->head = (raw->head + 1) & (RAW3215_BUFFER_SIZE - 1);
raw->count++; raw->count++;
} }
if (!(raw->flags & RAW3215_WORKING)) { if (!(raw->flags & RAW3215_WORKING)) {
raw3215_mk_write_req(raw); raw3215_mk_write_req(raw);
/* start or queue request */ /* start or queue request */
raw3215_try_io(raw); raw3215_try_io(raw);
} }
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
/* /*
* Flush routine, it simply sets the flush flag and tries to start * Flush routine, it simply sets the flush flag and tries to start
* pending IO. * pending IO.
*/ */
static void raw3215_flush_buffer(raw3215_info *raw) static void
raw3215_flush_buffer(struct raw3215_info *raw)
{ {
unsigned long flags; unsigned long flags;
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
if (raw->count > 0) { if (raw->count > 0) {
raw->flags |= RAW3215_FLUSHING; raw->flags |= RAW3215_FLUSHING;
raw3215_try_io(raw); raw3215_try_io(raw);
raw->flags &= ~RAW3215_FLUSHING; raw->flags &= ~RAW3215_FLUSHING;
} }
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
/* /*
* Fire up a 3215 device. * Fire up a 3215 device.
*/ */
static int raw3215_startup(raw3215_info *raw) static int
raw3215_startup(struct raw3215_info *raw)
{ {
unsigned long flags; unsigned long flags;
if (raw->flags & RAW3215_ACTIVE) if (raw->flags & RAW3215_ACTIVE)
return 0; return 0;
if (s390_request_console_irq(raw->irq, raw3215_irq, SA_INTERRUPT,
"3215 terminal driver", &raw->devstat) != 0)
return -1;
raw->line_pos = 0; raw->line_pos = 0;
raw->flags |= RAW3215_ACTIVE; raw->flags |= RAW3215_ACTIVE;
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
raw3215_try_io(raw); raw3215_try_io(raw);
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
return 0; return 0;
} }
/* /*
* Shutdown a 3215 device. * Shutdown a 3215 device.
*/ */
static void raw3215_shutdown(raw3215_info *raw) static void
raw3215_shutdown(struct raw3215_info *raw)
{ {
DECLARE_WAITQUEUE(wait, current); DECLARE_WAITQUEUE(wait, current);
unsigned long flags; unsigned long flags;
if (!(raw->flags & RAW3215_ACTIVE) || (raw->flags & RAW3215_FIXED)) if (!(raw->flags & RAW3215_ACTIVE) || (raw->flags & RAW3215_FIXED))
return; return;
/* Wait for outstanding requests, then free irq */ /* Wait for outstanding requests, then free irq */
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
if ((raw->flags & RAW3215_WORKING) || if ((raw->flags & RAW3215_WORKING) ||
raw->queued_write != NULL || raw->queued_write != NULL ||
raw->queued_read != NULL) { raw->queued_read != NULL) {
raw->flags |= RAW3215_CLOSING; raw->flags |= RAW3215_CLOSING;
add_wait_queue(&raw->empty_wait, &wait); add_wait_queue(&raw->empty_wait, &wait);
#warning FIXME: use set_current_state instead of current->state=
current->state = TASK_INTERRUPTIBLE; current->state = TASK_INTERRUPTIBLE;
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
/* FIXME: what if schedule is interrupted by a signal,
* shouldn't we loop here? */
schedule(); schedule();
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
remove_wait_queue(&raw->empty_wait, &wait); remove_wait_queue(&raw->empty_wait, &wait);
current->state = TASK_RUNNING; current->state = TASK_RUNNING;
raw->flags &= ~(RAW3215_ACTIVE | RAW3215_CLOSING); raw->flags &= ~(RAW3215_ACTIVE | RAW3215_CLOSING);
} }
free_irq(raw->irq, NULL); spin_unlock_irqrestore(raw->lock, flags);
s390irq_spin_unlock_irqrestore(raw->irq, flags);
} }
static int static int
raw3215_find_dev(int number) raw3215_probe (struct ccw_device *cdev)
{ {
s390_dev_info_t dinfo; struct raw3215_info *raw;
int irq; int line;
int count;
raw = kmalloc(sizeof(struct raw3215_info) +
RAW3215_INBUF_SIZE, GFP_KERNEL|GFP_DMA);
if (raw == NULL)
return -ENOMEM;
spin_lock(&raw3215_device_lock);
for (line = 0; line < NR_3215; line++) {
if (!raw3215[line]) {
raw3215[line] = raw;
break;
}
}
spin_unlock(&raw3215_device_lock);
if (line == NR_3215) {
kfree(raw);
return -ENODEV;
}
raw->cdev = cdev;
raw->lock = get_ccwdev_lock(cdev);
raw->inbuf = (char *) raw + sizeof(struct raw3215_info);
memset(raw, 0, sizeof(struct raw3215_info));
raw->buffer = (char *) kmalloc(RAW3215_BUFFER_SIZE,
GFP_KERNEL|GFP_DMA);
if (raw->buffer == NULL) {
spin_lock(&raw3215_device_lock);
raw3215[line] = 0;
spin_unlock(&raw3215_device_lock);
kfree(raw);
return -ENOMEM;
}
tasklet_init(&raw->tasklet,
(void (*)(unsigned long)) raw3215_tasklet,
(unsigned long) raw);
init_waitqueue_head(&raw->empty_wait);
cdev->dev.driver_data = raw;
cdev->handler = raw3215_irq;
irq = get_irq_first(); return 0;
count = 0;
while (count <= number && irq != -ENODEV) {
if (get_dev_info_by_irq(irq, &dinfo) == -ENODEV)
break;
if (dinfo.devno == console_device ||
dinfo.sid_data.cu_type == 0x3215) {
count++;
if (count > number)
return irq;
}
irq = get_irq_next(irq);
}
return -1; /* console not found */
} }
#ifdef CONFIG_TN3215_CONSOLE static int
raw3215_remove (struct ccw_device *cdev)
{
struct raw3215_info *raw;
raw = cdev->dev.driver_data;
if (raw) {
cdev->dev.driver_data = NULL;
if (raw->buffer)
kfree(raw->buffer);
kfree(raw);
}
return 0;
}
static int
raw3215_set_online (struct ccw_device *cdev)
{
struct raw3215_info *raw;
raw = cdev->dev.driver_data;
if (!raw)
return -ENODEV;
return raw3215_startup(raw);
}
static int
raw3215_set_offline (struct ccw_device *cdev)
{
struct raw3215_info *raw;
raw = cdev->dev.driver_data;
if (!raw)
return -ENODEV;
raw3215_shutdown(raw);
return 0;
}
static struct ccw_device_id raw3215_id[] = {
{ CCW_DEVICE(0x3215, 0) },
{ /* end of list */ },
};
static struct ccw_driver raw3215_ccw_driver = {
.name = "3215",
.owner = THIS_MODULE,
.ids = raw3215_id,
.probe = &raw3215_probe,
.remove = &raw3215_remove,
.set_online = &raw3215_set_online,
.set_offline = &raw3215_set_offline,
};
#ifdef CONFIG_TN3215_CONSOLE
/* /*
* Write a string to the 3215 console * Write a string to the 3215 console
*/ */
static void static void
con3215_write(struct console *co, const char *str, unsigned int count) con3215_write(struct console *co, const char *str, unsigned int count)
{ {
raw3215_info *raw; struct raw3215_info *raw;
int i; int i;
if (count <= 0) if (count <= 0)
return; return;
raw = raw3215[0]; /* console 3215 is the first one */ raw = raw3215[0]; /* console 3215 is the first one */
while (count > 0) { while (count > 0) {
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (str[i] == '\t' || str[i] == '\n') if (str[i] == '\t' || str[i] == '\n')
break; break;
raw3215_write(raw, str, 0, i); raw3215_write(raw, str, 0, i);
count -= i; count -= i;
str += i; str += i;
if (count > 0) { if (count > 0) {
raw3215_putchar(raw, *str); raw3215_putchar(raw, *str);
count--; count--;
str++; str++;
} }
} }
} }
static kdev_t con3215_device(struct console *c) static kdev_t
con3215_device(struct console *c)
{ {
return mk_kdev(TTY_MAJOR, c->index + 64 ); return mk_kdev(TTY_MAJOR, c->index + 64 );
} }
...@@ -802,18 +850,20 @@ static kdev_t con3215_device(struct console *c) ...@@ -802,18 +850,20 @@ static kdev_t con3215_device(struct console *c)
* panic() calls console_unblank before the system enters a * panic() calls console_unblank before the system enters a
* disabled, endless loop. * disabled, endless loop.
*/ */
static void con3215_unblank(void) static void
con3215_unblank(void)
{ {
raw3215_info *raw; struct raw3215_info *raw;
unsigned long flags; unsigned long flags;
raw = raw3215[0]; /* console 3215 is the first one */ raw = raw3215[0]; /* console 3215 is the first one */
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
raw3215_make_room(raw, RAW3215_BUFFER_SIZE); raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
static int __init con3215_consetup(struct console *co, char *options) static int __init
con3215_consetup(struct console *co, char *options)
{ {
return 0; return 0;
} }
...@@ -822,14 +872,76 @@ static int __init con3215_consetup(struct console *co, char *options) ...@@ -822,14 +872,76 @@ static int __init con3215_consetup(struct console *co, char *options)
* The console structure for the 3215 console * The console structure for the 3215 console
*/ */
static struct console con3215 = { static struct console con3215 = {
.name = "tty3215", .name = "tty3215",
.write = con3215_write, .write = con3215_write,
.device = con3215_device, .device = con3215_device,
.unblank = con3215_unblank, .unblank = con3215_unblank,
.setup = con3215_consetup, .setup = con3215_consetup,
.flags = CON_PRINTBUFFER, .flags = CON_PRINTBUFFER,
}; };
/*
* 3215 console initialization code called from console_init().
* NOTE: This is called before kmalloc is available.
*/
void __init
con3215_init(void)
{
struct ccw_device *cdev;
struct raw3215_info *raw;
struct raw3215_req *req;
int i;
/* Check if 3215 is to be the console */
if (!CONSOLE_IS_3215)
return;
/* Set the console mode for VM */
if (MACHINE_IS_VM) {
cpcmd("TERM CONMODE 3215", NULL, 0);
cpcmd("TERM AUTOCR OFF", NULL, 0);
}
/* allocate 3215 request structures */
raw3215_freelist = NULL;
spin_lock_init(&raw3215_freelist_lock);
for (i = 0; i < NR_3215_REQ; i++) {
req = (struct raw3215_req *) alloc_bootmem_low(sizeof(struct raw3215_req));
req->next = raw3215_freelist;
raw3215_freelist = req;
}
cdev = ccw_device_probe_console();
if (!cdev)
return;
raw3215[0] = raw = (struct raw3215_info *)
alloc_bootmem_low(sizeof(struct raw3215_info));
memset(raw, 0, sizeof(struct raw3215_info));
raw->buffer = (char *) alloc_bootmem_low(RAW3215_BUFFER_SIZE);
raw->inbuf = (char *) alloc_bootmem_low(RAW3215_INBUF_SIZE);
raw->cdev = cdev;
raw->lock = get_ccwdev_lock(cdev);
cdev->dev.driver_data = raw;
cdev->handler = raw3215_irq;
raw->flags |= RAW3215_FIXED;
tasklet_init(&raw->tasklet,
(void (*)(unsigned long)) raw3215_tasklet,
(unsigned long) raw);
init_waitqueue_head(&raw->empty_wait);
/* Request the console irq */
if (raw3215_startup(raw) != 0) {
free_bootmem((unsigned long) raw->inbuf, RAW3215_INBUF_SIZE);
free_bootmem((unsigned long) raw->buffer, RAW3215_BUFFER_SIZE);
free_bootmem((unsigned long) raw, sizeof(struct raw3215_info));
raw3215[0] = NULL;
printk("Couldn't find a 3215 console device\n");
return;
}
register_console(&con3215);
}
#endif #endif
/* /*
...@@ -837,9 +949,10 @@ static struct console con3215 = { ...@@ -837,9 +949,10 @@ static struct console con3215 = {
* *
* This routine is called whenever a 3215 tty is opened. * This routine is called whenever a 3215 tty is opened.
*/ */
static int tty3215_open(struct tty_struct *tty, struct file * filp) static int
tty3215_open(struct tty_struct *tty, struct file * filp)
{ {
raw3215_info *raw; struct raw3215_info *raw;
int retval, line; int retval, line;
line = minor(tty->device) - tty->driver.minor_start; line = minor(tty->device) - tty->driver.minor_start;
...@@ -847,27 +960,8 @@ static int tty3215_open(struct tty_struct *tty, struct file * filp) ...@@ -847,27 +960,8 @@ static int tty3215_open(struct tty_struct *tty, struct file * filp)
return -ENODEV; return -ENODEV;
raw = raw3215[line]; raw = raw3215[line];
if (raw == NULL) { if (raw == NULL)
raw = kmalloc(sizeof(raw3215_info) + return -ENODEV;
RAW3215_INBUF_SIZE, GFP_KERNEL|GFP_DMA);
if (raw == NULL)
return -ENOMEM;
raw->irq = raw3215_find_dev(line);
if (raw->irq == -1) {
kfree(raw);
return -ENODEV;
}
raw->inbuf = (char *) raw + sizeof(raw3215_info);
memset(raw, 0, sizeof(raw3215_info));
raw->buffer = (char *) kmalloc(RAW3215_BUFFER_SIZE,
GFP_KERNEL|GFP_DMA);
if (raw->buffer == NULL) {
kfree(raw);
return -ENOMEM;
}
init_waitqueue_head(&raw->empty_wait);
raw3215[line] = raw;
}
tty->driver_data = raw; tty->driver_data = raw;
raw->tty = tty; raw->tty = tty;
...@@ -889,11 +983,12 @@ static int tty3215_open(struct tty_struct *tty, struct file * filp) ...@@ -889,11 +983,12 @@ static int tty3215_open(struct tty_struct *tty, struct file * filp)
* This routine is called when the 3215 tty is closed. We wait * This routine is called when the 3215 tty is closed. We wait
* for the remaining request to be completed. Then we clean up. * for the remaining request to be completed. Then we clean up.
*/ */
static void tty3215_close(struct tty_struct *tty, struct file * filp) static void
tty3215_close(struct tty_struct *tty, struct file * filp)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
if (raw == NULL || tty->count > 1) if (raw == NULL || tty->count > 1)
return; return;
tty->closing = 1; tty->closing = 1;
...@@ -906,11 +1001,12 @@ static void tty3215_close(struct tty_struct *tty, struct file * filp) ...@@ -906,11 +1001,12 @@ static void tty3215_close(struct tty_struct *tty, struct file * filp)
/* /*
* Returns the amount of free space in the output buffer. * Returns the amount of free space in the output buffer.
*/ */
static int tty3215_write_room(struct tty_struct *tty) static int
tty3215_write_room(struct tty_struct *tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
/* Subtract TAB_STOP_SIZE to allow for a tab, 8 <<< 64K */ /* Subtract TAB_STOP_SIZE to allow for a tab, 8 <<< 64K */
if ((RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE) >= 0) if ((RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE) >= 0)
...@@ -922,15 +1018,16 @@ static int tty3215_write_room(struct tty_struct *tty) ...@@ -922,15 +1018,16 @@ static int tty3215_write_room(struct tty_struct *tty)
/* /*
* String write routine for 3215 ttys * String write routine for 3215 ttys
*/ */
static int tty3215_write(struct tty_struct * tty, int from_user, static int
const unsigned char *buf, int count) tty3215_write(struct tty_struct * tty, int from_user,
const unsigned char *buf, int count)
{ {
raw3215_info *raw; struct raw3215_info *raw;
int ret = 0; int ret = 0;
if (!tty) if (!tty)
return 0; return 0;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
ret = raw3215_write(raw, buf, from_user, count); ret = raw3215_write(raw, buf, from_user, count);
return ret; return ret;
} }
...@@ -938,36 +1035,40 @@ static int tty3215_write(struct tty_struct * tty, int from_user, ...@@ -938,36 +1035,40 @@ static int tty3215_write(struct tty_struct * tty, int from_user,
/* /*
* Put character routine for 3215 ttys * Put character routine for 3215 ttys
*/ */
static void tty3215_put_char(struct tty_struct *tty, unsigned char ch) static void
tty3215_put_char(struct tty_struct *tty, unsigned char ch)
{ {
raw3215_info *raw; struct raw3215_info *raw;
if (!tty) if (!tty)
return; return;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
raw3215_putchar(raw, ch); raw3215_putchar(raw, ch);
} }
static void tty3215_flush_chars(struct tty_struct *tty) static void
tty3215_flush_chars(struct tty_struct *tty)
{ {
} }
/* /*
* Returns the number of characters in the output buffer * Returns the number of characters in the output buffer
*/ */
static int tty3215_chars_in_buffer(struct tty_struct *tty) static int
tty3215_chars_in_buffer(struct tty_struct *tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
return raw->count; return raw->count;
} }
static void tty3215_flush_buffer(struct tty_struct *tty) static void
tty3215_flush_buffer(struct tty_struct *tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
raw3215_flush_buffer(raw); raw3215_flush_buffer(raw);
wake_up_interruptible(&tty->write_wait); wake_up_interruptible(&tty->write_wait);
if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
...@@ -978,8 +1079,9 @@ static void tty3215_flush_buffer(struct tty_struct *tty) ...@@ -978,8 +1079,9 @@ static void tty3215_flush_buffer(struct tty_struct *tty)
/* /*
* Currently we don't have any io controls for 3215 ttys * Currently we don't have any io controls for 3215 ttys
*/ */
static int tty3215_ioctl(struct tty_struct *tty, struct file * file, static int
unsigned int cmd, unsigned long arg) tty3215_ioctl(struct tty_struct *tty, struct file * file,
unsigned int cmd, unsigned long arg)
{ {
if (tty->flags & (1 << TTY_IO_ERROR)) if (tty->flags & (1 << TTY_IO_ERROR))
return -EIO; return -EIO;
...@@ -994,145 +1096,79 @@ static int tty3215_ioctl(struct tty_struct *tty, struct file * file, ...@@ -994,145 +1096,79 @@ static int tty3215_ioctl(struct tty_struct *tty, struct file * file,
/* /*
* Disable reading from a 3215 tty * Disable reading from a 3215 tty
*/ */
static void tty3215_throttle(struct tty_struct * tty) static void
tty3215_throttle(struct tty_struct * tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
raw->flags |= RAW3215_THROTTLED; raw->flags |= RAW3215_THROTTLED;
} }
/* /*
* Enable reading from a 3215 tty * Enable reading from a 3215 tty
*/ */
static void tty3215_unthrottle(struct tty_struct * tty) static void
tty3215_unthrottle(struct tty_struct * tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
unsigned long flags; unsigned long flags;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
if (raw->flags & RAW3215_THROTTLED) { if (raw->flags & RAW3215_THROTTLED) {
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
raw->flags &= ~RAW3215_THROTTLED; raw->flags &= ~RAW3215_THROTTLED;
raw3215_try_io(raw); raw3215_try_io(raw);
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
} }
/* /*
* Disable writing to a 3215 tty * Disable writing to a 3215 tty
*/ */
static void tty3215_stop(struct tty_struct *tty) static void
tty3215_stop(struct tty_struct *tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
raw->flags |= RAW3215_STOPPED; raw->flags |= RAW3215_STOPPED;
} }
/* /*
* Enable writing to a 3215 tty * Enable writing to a 3215 tty
*/ */
static void tty3215_start(struct tty_struct *tty) static void
tty3215_start(struct tty_struct *tty)
{ {
raw3215_info *raw; struct raw3215_info *raw;
unsigned long flags; unsigned long flags;
raw = (raw3215_info *) tty->driver_data; raw = (struct raw3215_info *) tty->driver_data;
if (raw->flags & RAW3215_STOPPED) { if (raw->flags & RAW3215_STOPPED) {
s390irq_spin_lock_irqsave(raw->irq, flags); spin_lock_irqsave(raw->lock, flags);
raw->flags &= ~RAW3215_STOPPED; raw->flags &= ~RAW3215_STOPPED;
raw3215_try_io(raw); raw3215_try_io(raw);
s390irq_spin_unlock_irqrestore(raw->irq, flags); spin_unlock_irqrestore(raw->lock, flags);
} }
} }
/* /*
* 3215 console initialization code called from console_init(). * 3215 tty registration code called from tty_init().
* NOTE: This is called before kmalloc is available. * Most kernel services (incl. kmalloc) are available at this poimt.
*/ */
void __init con3215_init(void) int __init
tty3215_init(void)
{ {
#ifdef CONFIG_TN3215_CONSOLE int ret;
raw3215_info *raw;
#endif
raw3215_req *req;
int irq;
int i;
/* Check if 3215 is to be the console */
if (!CONSOLE_IS_3215) if (!CONSOLE_IS_3215)
return; return 0;
/* Set the console mode for VM */
if (MACHINE_IS_VM) {
cpcmd("TERM CONMODE 3215", NULL, 0);
cpcmd("TERM AUTOCR OFF", NULL, 0);
}
if (console_device != -1) {
/* use the device number that was specified on the
* command line */
irq = raw3215_find_dev(0);
} else if (MACHINE_IS_VM) {
/* under VM, the console is at device number 0009
* by default, so try that */
irq = get_irq_by_devno(0x0009);
} else {
/* unlike in 2.4, we cannot autoprobe here, since
* the channel subsystem is not fully initialized.
* With some luck, the HWC console can take over */
printk(KERN_WARNING "3215 console not found\n");
return;
}
/* allocate 3215 request structures */
raw3215_freelist = NULL;
spin_lock_init(&raw3215_freelist_lock);
for (i = 0; i < NR_3215_REQ; i++) {
req = (raw3215_req *) alloc_bootmem_low(sizeof(raw3215_req));
req->next = raw3215_freelist;
raw3215_freelist = req;
}
#ifdef CONFIG_TN3215_CONSOLE
raw3215[0] = raw = (raw3215_info *)
alloc_bootmem_low(sizeof(raw3215_info));
memset(raw, 0, sizeof(raw3215_info));
raw->buffer = (char *) alloc_bootmem_low(RAW3215_BUFFER_SIZE);
raw->inbuf = (char *) alloc_bootmem_low(RAW3215_INBUF_SIZE);
/* Find the first console */
raw->irq = irq;
raw->flags |= RAW3215_FIXED;
tasklet_init(&raw->tasklet,
(void (*)(unsigned long)) raw3215_tasklet,
(unsigned long) raw);
init_waitqueue_head(&raw->empty_wait);
/* Request the console irq */
if ( raw3215_startup(raw) != 0 )
raw->irq = -1;
if (raw->irq != -1) {
register_console(&con3215);
} else {
free_bootmem((unsigned long) raw->inbuf, RAW3215_INBUF_SIZE);
free_bootmem((unsigned long) raw->buffer, RAW3215_BUFFER_SIZE);
free_bootmem((unsigned long) raw, sizeof(raw3215_info));
raw3215[0] = NULL;
printk("Couldn't find a 3215 console device\n");
}
#endif
}
/* ret = ccw_driver_register(&raw3215_ccw_driver);
* 3215 tty registration code called from tty_init(). if (ret)
* Most kernel services (incl. kmalloc) are available at this poimt. return ret;
*/
void __init tty3215_init(void)
{
/* /*
* Initialize the tty_driver structure * Initialize the tty_driver structure
* Entries in tty3215_driver that are NOT initialized: * Entries in tty3215_driver that are NOT initialized:
...@@ -1153,7 +1189,7 @@ void __init tty3215_init(void) ...@@ -1153,7 +1189,7 @@ void __init tty3215_init(void)
tty3215_driver.init_termios.c_iflag = IGNBRK | IGNPAR; tty3215_driver.init_termios.c_iflag = IGNBRK | IGNPAR;
tty3215_driver.init_termios.c_oflag = ONLCR | XTABS; tty3215_driver.init_termios.c_oflag = ONLCR | XTABS;
tty3215_driver.init_termios.c_lflag = ISIG; tty3215_driver.init_termios.c_lflag = ISIG;
tty3215_driver.flags = TTY_DRIVER_REAL_RAW; tty3215_driver.flags = TTY_DRIVER_REAL_RAW;
tty3215_driver.refcount = &tty3215_refcount; tty3215_driver.refcount = &tty3215_refcount;
tty3215_driver.table = tty3215_table; tty3215_driver.table = tty3215_table;
tty3215_driver.termios = tty3215_termios; tty3215_driver.termios = tty3215_termios;
...@@ -1179,6 +1215,18 @@ void __init tty3215_init(void) ...@@ -1179,6 +1215,18 @@ void __init tty3215_init(void)
tty3215_driver.wait_until_sent = NULL; tty3215_driver.wait_until_sent = NULL;
tty3215_driver.read_proc = NULL; tty3215_driver.read_proc = NULL;
if (tty_register_driver(&tty3215_driver)) ret = tty_register_driver(&tty3215_driver);
panic("Couldn't register tty3215 driver\n"); if (ret)
printk("Couldn't register tty3215 driver\n");
return ret;
}
static void __exit
tty3215_exit(void)
{
tty_unregister_driver(&tty3215_driver);
ccw_driver_unregister(&raw3215_ccw_driver);
} }
module_init(tty3215_init);
module_exit(tty3215_exit);
drivers/s390/char/ctrlchar.c
View file @ d022be21
...@@ -9,6 +9,7 @@ ...@@ -9,6 +9,7 @@
#include <linux/config.h> #include <linux/config.h>
#include <linux/stddef.h> #include <linux/stddef.h>
#include <asm/errno.h>
#include <linux/sysrq.h> #include <linux/sysrq.h>
#include <linux/ctype.h> #include <linux/ctype.h>
...@@ -20,7 +21,7 @@ static int ctrlchar_sysrq_key; ...@@ -20,7 +21,7 @@ static int ctrlchar_sysrq_key;
static void static void
ctrlchar_handle_sysrq(void *tty) ctrlchar_handle_sysrq(void *tty)
{ {
handle_sysrq(ctrlchar_sysrq_key, NULL, tty); handle_sysrq(ctrlchar_sysrq_key, NULL, (struct tty_struct *) tty);
} }
static DECLARE_WORK(ctrlchar_work, ctrlchar_handle_sysrq, 0); static DECLARE_WORK(ctrlchar_work, ctrlchar_handle_sysrq, 0);
...@@ -39,7 +40,7 @@ static DECLARE_WORK(ctrlchar_work, ctrlchar_handle_sysrq, 0); ...@@ -39,7 +40,7 @@ static DECLARE_WORK(ctrlchar_work, ctrlchar_handle_sysrq, 0);
* with CTRLCHAR_CTRL * with CTRLCHAR_CTRL
*/ */
unsigned int unsigned int
ctrlchar_handle(const char *buf, int len, struct tty_struct *tty) ctrlchar_handle(const unsigned char *buf, int len, struct tty_struct *tty)
{ {
if ((len < 2) || (len > 3)) if ((len < 2) || (len > 3))
return CTRLCHAR_NONE; return CTRLCHAR_NONE;
......
drivers/s390/char/ctrlchar.h
View file @ d022be21
...@@ -10,7 +10,7 @@ ...@@ -10,7 +10,7 @@
#include <linux/tty.h> #include <linux/tty.h>
extern unsigned int extern unsigned int
ctrlchar_handle(const char *buf, int len, struct tty_struct *tty); ctrlchar_handle(const unsigned char *buf, int len, struct tty_struct *tty);
#define CTRLCHAR_NONE (1 << 8) #define CTRLCHAR_NONE (1 << 8)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7