2 * SCLP line mode terminal driver.
5 * Copyright IBM Corp. 1999
6 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
7 * Martin Schwidefsky <schwidefsky@de.ibm.com>
10 #include <linux/module.h>
11 #include <linux/kmod.h>
12 #include <linux/tty.h>
13 #include <linux/tty_driver.h>
14 #include <linux/tty_flip.h>
15 #include <linux/err.h>
16 #include <linux/init.h>
17 #include <linux/interrupt.h>
18 #include <linux/gfp.h>
19 #include <asm/uaccess.h>
27 * size of a buffer that collects single characters coming in
28 * via sclp_tty_put_char()
30 #define SCLP_TTY_BUF_SIZE 512
33 * There is exactly one SCLP terminal, so we can keep things simple
34 * and allocate all variables statically.
37 /* Lock to guard over changes to global variables. */
38 static spinlock_t sclp_tty_lock
;
39 /* List of free pages that can be used for console output buffering. */
40 static struct list_head sclp_tty_pages
;
41 /* List of full struct sclp_buffer structures ready for output. */
42 static struct list_head sclp_tty_outqueue
;
43 /* Counter how many buffers are emitted. */
44 static int sclp_tty_buffer_count
;
45 /* Pointer to current console buffer. */
46 static struct sclp_buffer
*sclp_ttybuf
;
47 /* Timer for delayed output of console messages. */
48 static struct timer_list sclp_tty_timer
;
50 static struct tty_port sclp_port
;
51 static unsigned char sclp_tty_chars
[SCLP_TTY_BUF_SIZE
];
52 static unsigned short int sclp_tty_chars_count
;
54 struct tty_driver
*sclp_tty_driver
;
56 static int sclp_tty_tolower
;
57 static int sclp_tty_columns
= 80;
59 #define SPACES_PER_TAB 8
60 #define CASE_DELIMITER 0x6c /* to separate upper and lower case (% in EBCDIC) */
62 /* This routine is called whenever we try to open a SCLP terminal. */
64 sclp_tty_open(struct tty_struct
*tty
, struct file
*filp
)
66 tty_port_tty_set(&sclp_port
, tty
);
67 tty
->driver_data
= NULL
;
72 /* This routine is called when the SCLP terminal is closed. */
74 sclp_tty_close(struct tty_struct
*tty
, struct file
*filp
)
78 tty_port_tty_set(&sclp_port
, NULL
);
82 * This routine returns the numbers of characters the tty driver
83 * will accept for queuing to be written. This number is subject
84 * to change as output buffers get emptied, or if the output flow
85 * control is acted. This is not an exact number because not every
86 * character needs the same space in the sccb. The worst case is
87 * a string of newlines. Every newlines creates a new mto which
91 sclp_tty_write_room (struct tty_struct
*tty
)
97 spin_lock_irqsave(&sclp_tty_lock
, flags
);
99 if (sclp_ttybuf
!= NULL
)
100 count
= sclp_buffer_space(sclp_ttybuf
) / sizeof(struct mto
);
101 list_for_each(l
, &sclp_tty_pages
)
102 count
+= NR_EMPTY_MTO_PER_SCCB
;
103 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
108 sclp_ttybuf_callback(struct sclp_buffer
*buffer
, int rc
)
110 struct tty_struct
*tty
;
115 page
= sclp_unmake_buffer(buffer
);
116 spin_lock_irqsave(&sclp_tty_lock
, flags
);
117 /* Remove buffer from outqueue */
118 list_del(&buffer
->list
);
119 sclp_tty_buffer_count
--;
120 list_add_tail((struct list_head
*) page
, &sclp_tty_pages
);
121 /* Check if there is a pending buffer on the out queue. */
123 if (!list_empty(&sclp_tty_outqueue
))
124 buffer
= list_entry(sclp_tty_outqueue
.next
,
125 struct sclp_buffer
, list
);
126 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
127 } while (buffer
&& sclp_emit_buffer(buffer
, sclp_ttybuf_callback
));
128 /* check if the tty needs a wake up call */
129 tty
= tty_port_tty_get(&sclp_port
);
137 __sclp_ttybuf_emit(struct sclp_buffer
*buffer
)
143 spin_lock_irqsave(&sclp_tty_lock
, flags
);
144 list_add_tail(&buffer
->list
, &sclp_tty_outqueue
);
145 count
= sclp_tty_buffer_count
++;
146 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
149 rc
= sclp_emit_buffer(buffer
, sclp_ttybuf_callback
);
151 sclp_ttybuf_callback(buffer
, rc
);
155 * When this routine is called from the timer then we flush the
156 * temporary write buffer.
159 sclp_tty_timeout(unsigned long data
)
162 struct sclp_buffer
*buf
;
164 spin_lock_irqsave(&sclp_tty_lock
, flags
);
167 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
170 __sclp_ttybuf_emit(buf
);
175 * Write a string to the sclp tty.
177 static int sclp_tty_write_string(const unsigned char *str
, int count
, int may_fail
)
183 struct sclp_buffer
*buf
;
188 spin_lock_irqsave(&sclp_tty_lock
, flags
);
190 /* Create a sclp output buffer if none exists yet */
191 if (sclp_ttybuf
== NULL
) {
192 while (list_empty(&sclp_tty_pages
)) {
193 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
198 spin_lock_irqsave(&sclp_tty_lock
, flags
);
200 page
= sclp_tty_pages
.next
;
201 list_del((struct list_head
*) page
);
202 sclp_ttybuf
= sclp_make_buffer(page
, sclp_tty_columns
,
205 /* try to write the string to the current output buffer */
206 written
= sclp_write(sclp_ttybuf
, str
, count
);
207 overall_written
+= written
;
208 if (written
== count
)
211 * Not all characters could be written to the current
212 * output buffer. Emit the buffer, create a new buffer
213 * and then output the rest of the string.
217 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
218 __sclp_ttybuf_emit(buf
);
219 spin_lock_irqsave(&sclp_tty_lock
, flags
);
223 /* Setup timer to output current console buffer after 1/10 second */
224 if (sclp_ttybuf
&& sclp_chars_in_buffer(sclp_ttybuf
) &&
225 !timer_pending(&sclp_tty_timer
)) {
226 init_timer(&sclp_tty_timer
);
227 sclp_tty_timer
.function
= sclp_tty_timeout
;
228 sclp_tty_timer
.data
= 0UL;
229 sclp_tty_timer
.expires
= jiffies
+ HZ
/10;
230 add_timer(&sclp_tty_timer
);
232 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
234 return overall_written
;
238 * This routine is called by the kernel to write a series of characters to the
239 * tty device. The characters may come from user space or kernel space. This
240 * routine will return the number of characters actually accepted for writing.
243 sclp_tty_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
245 if (sclp_tty_chars_count
> 0) {
246 sclp_tty_write_string(sclp_tty_chars
, sclp_tty_chars_count
, 0);
247 sclp_tty_chars_count
= 0;
249 return sclp_tty_write_string(buf
, count
, 1);
253 * This routine is called by the kernel to write a single character to the tty
254 * device. If the kernel uses this routine, it must call the flush_chars()
255 * routine (if defined) when it is done stuffing characters into the driver.
257 * Characters provided to sclp_tty_put_char() are buffered by the SCLP driver.
258 * If the given character is a '\n' the contents of the SCLP write buffer
259 * - including previous characters from sclp_tty_put_char() and strings from
260 * sclp_write() without final '\n' - will be written.
263 sclp_tty_put_char(struct tty_struct
*tty
, unsigned char ch
)
265 sclp_tty_chars
[sclp_tty_chars_count
++] = ch
;
266 if (ch
== '\n' || sclp_tty_chars_count
>= SCLP_TTY_BUF_SIZE
) {
267 sclp_tty_write_string(sclp_tty_chars
, sclp_tty_chars_count
, 0);
268 sclp_tty_chars_count
= 0;
274 * This routine is called by the kernel after it has written a series of
275 * characters to the tty device using put_char().
278 sclp_tty_flush_chars(struct tty_struct
*tty
)
280 if (sclp_tty_chars_count
> 0) {
281 sclp_tty_write_string(sclp_tty_chars
, sclp_tty_chars_count
, 0);
282 sclp_tty_chars_count
= 0;
287 * This routine returns the number of characters in the write buffer of the
288 * SCLP driver. The provided number includes all characters that are stored
289 * in the SCCB (will be written next time the SCLP is not busy) as well as
290 * characters in the write buffer (will not be written as long as there is a
291 * final line feed missing).
294 sclp_tty_chars_in_buffer(struct tty_struct
*tty
)
298 struct sclp_buffer
*t
;
301 spin_lock_irqsave(&sclp_tty_lock
, flags
);
303 if (sclp_ttybuf
!= NULL
)
304 count
= sclp_chars_in_buffer(sclp_ttybuf
);
305 list_for_each(l
, &sclp_tty_outqueue
) {
306 t
= list_entry(l
, struct sclp_buffer
, list
);
307 count
+= sclp_chars_in_buffer(t
);
309 spin_unlock_irqrestore(&sclp_tty_lock
, flags
);
314 * removes all content from buffers of low level driver
317 sclp_tty_flush_buffer(struct tty_struct
*tty
)
319 if (sclp_tty_chars_count
> 0) {
320 sclp_tty_write_string(sclp_tty_chars
, sclp_tty_chars_count
, 0);
321 sclp_tty_chars_count
= 0;
329 sclp_tty_input(unsigned char* buf
, unsigned int count
)
331 struct tty_struct
*tty
= tty_port_tty_get(&sclp_port
);
335 * If this tty driver is currently closed
336 * then throw the received input away.
340 cchar
= ctrlchar_handle(buf
, count
, tty
);
341 switch (cchar
& CTRLCHAR_MASK
) {
345 tty_insert_flip_char(tty
, cchar
, TTY_NORMAL
);
346 tty_flip_buffer_push(tty
);
349 /* send (normal) input to line discipline */
351 (strncmp((const char *) buf
+ count
- 2, "^n", 2) &&
352 strncmp((const char *) buf
+ count
- 2, "\252n", 2))) {
353 /* add the auto \n */
354 tty_insert_flip_string(tty
, buf
, count
);
355 tty_insert_flip_char(tty
, '\n', TTY_NORMAL
);
357 tty_insert_flip_string(tty
, buf
, count
- 2);
358 tty_flip_buffer_push(tty
);
365 * get a EBCDIC string in upper/lower case,
366 * find out characters in lower/upper case separated by a special character,
367 * modifiy original string,
368 * returns length of resulting string
370 static int sclp_switch_cases(unsigned char *buf
, int count
)
372 unsigned char *ip
, *op
;
375 /* initially changing case is off */
378 while (count
-- > 0) {
379 /* compare with special character */
380 if (*ip
== CASE_DELIMITER
) {
381 /* followed by another special character? */
382 if (count
&& ip
[1] == CASE_DELIMITER
) {
384 * ... then put a single copy of the special
385 * character to the output string
391 * ... special character follower by a normal
392 * character toggles the case change behaviour
395 /* skip special character */
398 /* not the special character */
400 /* but case switching is on */
401 if (sclp_tty_tolower
)
402 /* switch to uppercase */
403 *op
++ = _ebc_toupper
[(int) *ip
++];
405 /* switch to lowercase */
406 *op
++ = _ebc_tolower
[(int) *ip
++];
408 /* no case switching, copy the character */
411 /* return length of reformatted string. */
415 static void sclp_get_input(struct gds_subvector
*sv
)
420 str
= (unsigned char *) (sv
+ 1);
421 count
= sv
->length
- sizeof(*sv
);
422 if (sclp_tty_tolower
)
423 EBC_TOLOWER(str
, count
);
424 count
= sclp_switch_cases(str
, count
);
425 /* convert EBCDIC to ASCII (modify original input in SCCB) */
426 sclp_ebcasc_str(str
, count
);
428 /* transfer input to high level driver */
429 sclp_tty_input(str
, count
);
432 static inline void sclp_eval_selfdeftextmsg(struct gds_subvector
*sv
)
436 end
= (void *) sv
+ sv
->length
;
437 for (sv
= sv
+ 1; (void *) sv
< end
; sv
= (void *) sv
+ sv
->length
)
442 static inline void sclp_eval_textcmd(struct gds_vector
*v
)
444 struct gds_subvector
*sv
;
447 end
= (void *) v
+ v
->length
;
448 for (sv
= (struct gds_subvector
*) (v
+ 1);
449 (void *) sv
< end
; sv
= (void *) sv
+ sv
->length
)
450 if (sv
->key
== GDS_KEY_SELFDEFTEXTMSG
)
451 sclp_eval_selfdeftextmsg(sv
);
455 static inline void sclp_eval_cpmsu(struct gds_vector
*v
)
459 end
= (void *) v
+ v
->length
;
460 for (v
= v
+ 1; (void *) v
< end
; v
= (void *) v
+ v
->length
)
461 if (v
->gds_id
== GDS_ID_TEXTCMD
)
462 sclp_eval_textcmd(v
);
466 static inline void sclp_eval_mdsmu(struct gds_vector
*v
)
468 v
= sclp_find_gds_vector(v
+ 1, (void *) v
+ v
->length
, GDS_ID_CPMSU
);
473 static void sclp_tty_receiver(struct evbuf_header
*evbuf
)
475 struct gds_vector
*v
;
477 v
= sclp_find_gds_vector(evbuf
+ 1, (void *) evbuf
+ evbuf
->length
,
484 sclp_tty_state_change(struct sclp_register
*reg
)
488 static struct sclp_register sclp_input_event
=
490 .receive_mask
= EVTYP_OPCMD_MASK
| EVTYP_PMSGCMD_MASK
,
491 .state_change_fn
= sclp_tty_state_change
,
492 .receiver_fn
= sclp_tty_receiver
495 static const struct tty_operations sclp_ops
= {
496 .open
= sclp_tty_open
,
497 .close
= sclp_tty_close
,
498 .write
= sclp_tty_write
,
499 .put_char
= sclp_tty_put_char
,
500 .flush_chars
= sclp_tty_flush_chars
,
501 .write_room
= sclp_tty_write_room
,
502 .chars_in_buffer
= sclp_tty_chars_in_buffer
,
503 .flush_buffer
= sclp_tty_flush_buffer
,
509 struct tty_driver
*driver
;
514 if (!CONSOLE_IS_SCLP
)
516 driver
= alloc_tty_driver(1);
522 put_tty_driver(driver
);
525 /* Allocate pages for output buffering */
526 INIT_LIST_HEAD(&sclp_tty_pages
);
527 for (i
= 0; i
< MAX_KMEM_PAGES
; i
++) {
528 page
= (void *) get_zeroed_page(GFP_KERNEL
| GFP_DMA
);
530 put_tty_driver(driver
);
533 list_add_tail((struct list_head
*) page
, &sclp_tty_pages
);
535 INIT_LIST_HEAD(&sclp_tty_outqueue
);
536 spin_lock_init(&sclp_tty_lock
);
537 init_timer(&sclp_tty_timer
);
539 sclp_tty_buffer_count
= 0;
542 * save 4 characters for the CPU number
543 * written at start of each line by VM/CP
545 sclp_tty_columns
= 76;
546 /* case input lines to lowercase */
547 sclp_tty_tolower
= 1;
549 sclp_tty_chars_count
= 0;
551 rc
= sclp_register(&sclp_input_event
);
553 put_tty_driver(driver
);
557 tty_port_init(&sclp_port
);
559 driver
->driver_name
= "sclp_line";
560 driver
->name
= "sclp_line";
561 driver
->major
= TTY_MAJOR
;
562 driver
->minor_start
= 64;
563 driver
->type
= TTY_DRIVER_TYPE_SYSTEM
;
564 driver
->subtype
= SYSTEM_TYPE_TTY
;
565 driver
->init_termios
= tty_std_termios
;
566 driver
->init_termios
.c_iflag
= IGNBRK
| IGNPAR
;
567 driver
->init_termios
.c_oflag
= ONLCR
| XTABS
;
568 driver
->init_termios
.c_lflag
= ISIG
| ECHO
;
569 driver
->flags
= TTY_DRIVER_REAL_RAW
;
570 tty_set_operations(driver
, &sclp_ops
);
571 tty_port_link_device(&sclp_port
, driver
, 0);
572 rc
= tty_register_driver(driver
);
574 put_tty_driver(driver
);
575 tty_port_destroy(&sclp_port
);
578 sclp_tty_driver
= driver
;
581 module_init(sclp_tty_init
);