2 * drivers/s390/char/sclp_vt220.c
3 * SCLP VT220 terminal driver.
6 * Copyright IBM Corp. 2003,2008
7 * Author(s): Peter Oberparleiter <Peter.Oberparleiter@de.ibm.com>
10 #include <linux/module.h>
11 #include <linux/spinlock.h>
12 #include <linux/list.h>
13 #include <linux/wait.h>
14 #include <linux/timer.h>
15 #include <linux/kernel.h>
16 #include <linux/tty.h>
17 #include <linux/tty_driver.h>
18 #include <linux/tty_flip.h>
19 #include <linux/errno.h>
21 #include <linux/major.h>
22 #include <linux/console.h>
23 #include <linux/kdev_t.h>
24 #include <linux/bootmem.h>
25 #include <linux/interrupt.h>
26 #include <linux/init.h>
27 #include <asm/uaccess.h>
30 #define SCLP_VT220_PRINT_HEADER "sclp vt220 tty driver: "
31 #define SCLP_VT220_MAJOR TTY_MAJOR
32 #define SCLP_VT220_MINOR 65
33 #define SCLP_VT220_DRIVER_NAME "sclp_vt220"
34 #define SCLP_VT220_DEVICE_NAME "ttysclp"
35 #define SCLP_VT220_CONSOLE_NAME "ttyS"
36 #define SCLP_VT220_CONSOLE_INDEX 1 /* console=ttyS1 */
37 #define SCLP_VT220_BUF_SIZE 80
39 /* Representation of a single write request */
40 struct sclp_vt220_request {
41 struct list_head list;
42 struct sclp_req sclp_req;
47 struct sclp_vt220_sccb {
48 struct sccb_header header;
49 struct evbuf_header evbuf;
52 #define SCLP_VT220_MAX_CHARS_PER_BUFFER (PAGE_SIZE - \
53 sizeof(struct sclp_vt220_request) - \
54 sizeof(struct sclp_vt220_sccb))
56 /* Structures and data needed to register tty driver */
57 static struct tty_driver *sclp_vt220_driver;
59 /* The tty_struct that the kernel associated with us */
60 static struct tty_struct *sclp_vt220_tty;
62 /* Lock to protect internal data from concurrent access */
63 static spinlock_t sclp_vt220_lock;
65 /* List of empty pages to be used as write request buffers */
66 static struct list_head sclp_vt220_empty;
68 /* List of pending requests */
69 static struct list_head sclp_vt220_outqueue;
71 /* Number of requests in outqueue */
72 static int sclp_vt220_outqueue_count;
74 /* Wait queue used to delay write requests while we've run out of buffers */
75 static wait_queue_head_t sclp_vt220_waitq;
77 /* Timer used for delaying write requests to merge subsequent messages into
79 static struct timer_list sclp_vt220_timer;
81 /* Pointer to current request buffer which has been partially filled but not
83 static struct sclp_vt220_request *sclp_vt220_current_request;
85 /* Number of characters in current request buffer */
86 static int sclp_vt220_buffered_chars;
88 /* Flag indicating whether this driver has already been initialized */
89 static int sclp_vt220_initialized = 0;
91 /* Flag indicating that sclp_vt220_current_request should really
92 * have been already queued but wasn't because the SCLP was processing
94 static int sclp_vt220_flush_later;
96 static void sclp_vt220_receiver_fn(struct evbuf_header *evbuf);
97 static int __sclp_vt220_emit(struct sclp_vt220_request *request);
98 static void sclp_vt220_emit_current(void);
100 /* Registration structure for our interest in SCLP event buffers */
101 static struct sclp_register sclp_vt220_register = {
102 .send_mask = EVTYP_VT220MSG_MASK,
103 .receive_mask = EVTYP_VT220MSG_MASK,
104 .state_change_fn = NULL,
105 .receiver_fn = sclp_vt220_receiver_fn
110 * Put provided request buffer back into queue and check emit pending
111 * buffers if necessary.
114 sclp_vt220_process_queue(struct sclp_vt220_request *request)
120 /* Put buffer back to list of empty buffers */
121 page = request->sclp_req.sccb;
122 spin_lock_irqsave(&sclp_vt220_lock, flags);
123 /* Move request from outqueue to empty queue */
124 list_del(&request->list);
125 sclp_vt220_outqueue_count--;
126 list_add_tail((struct list_head *) page, &sclp_vt220_empty);
127 /* Check if there is a pending buffer on the out queue. */
129 if (!list_empty(&sclp_vt220_outqueue))
130 request = list_entry(sclp_vt220_outqueue.next,
131 struct sclp_vt220_request, list);
132 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
133 } while (request && __sclp_vt220_emit(request));
134 if (request == NULL && sclp_vt220_flush_later)
135 sclp_vt220_emit_current();
136 wake_up(&sclp_vt220_waitq);
137 /* Check if the tty needs a wake up call */
138 if (sclp_vt220_tty != NULL) {
139 tty_wakeup(sclp_vt220_tty);
143 #define SCLP_BUFFER_MAX_RETRY 1
146 * Callback through which the result of a write request is reported by the
150 sclp_vt220_callback(struct sclp_req *request, void *data)
152 struct sclp_vt220_request *vt220_request;
153 struct sclp_vt220_sccb *sccb;
155 vt220_request = (struct sclp_vt220_request *) data;
156 if (request->status == SCLP_REQ_FAILED) {
157 sclp_vt220_process_queue(vt220_request);
160 sccb = (struct sclp_vt220_sccb *) vt220_request->sclp_req.sccb;
162 /* Check SCLP response code and choose suitable action */
163 switch (sccb->header.response_code) {
167 case 0x05f0: /* Target resource in improper state */
170 case 0x0340: /* Contained SCLP equipment check */
171 if (++vt220_request->retry_count > SCLP_BUFFER_MAX_RETRY)
173 /* Remove processed buffers and requeue rest */
174 if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {
175 /* Not all buffers were processed */
176 sccb->header.response_code = 0x0000;
177 vt220_request->sclp_req.status = SCLP_REQ_FILLED;
178 if (sclp_add_request(request) == 0)
183 case 0x0040: /* SCLP equipment check */
184 if (++vt220_request->retry_count > SCLP_BUFFER_MAX_RETRY)
186 sccb->header.response_code = 0x0000;
187 vt220_request->sclp_req.status = SCLP_REQ_FILLED;
188 if (sclp_add_request(request) == 0)
195 sclp_vt220_process_queue(vt220_request);
199 * Emit vt220 request buffer to SCLP. Return zero on success, non-zero
203 __sclp_vt220_emit(struct sclp_vt220_request *request)
205 if (!(sclp_vt220_register.sclp_receive_mask & EVTYP_VT220MSG_MASK)) {
206 request->sclp_req.status = SCLP_REQ_FAILED;
209 request->sclp_req.command = SCLP_CMDW_WRITE_EVENT_DATA;
210 request->sclp_req.status = SCLP_REQ_FILLED;
211 request->sclp_req.callback = sclp_vt220_callback;
212 request->sclp_req.callback_data = (void *) request;
214 return sclp_add_request(&request->sclp_req);
218 * Queue and emit given request.
221 sclp_vt220_emit(struct sclp_vt220_request *request)
226 spin_lock_irqsave(&sclp_vt220_lock, flags);
227 list_add_tail(&request->list, &sclp_vt220_outqueue);
228 count = sclp_vt220_outqueue_count++;
229 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
230 /* Emit only the first buffer immediately - callback takes care of
232 if (count == 0 && __sclp_vt220_emit(request))
233 sclp_vt220_process_queue(request);
237 * Queue and emit current request. Return zero on success, non-zero otherwise.
240 sclp_vt220_emit_current(void)
243 struct sclp_vt220_request *request;
244 struct sclp_vt220_sccb *sccb;
246 spin_lock_irqsave(&sclp_vt220_lock, flags);
248 if (sclp_vt220_current_request != NULL) {
249 sccb = (struct sclp_vt220_sccb *)
250 sclp_vt220_current_request->sclp_req.sccb;
251 /* Only emit buffers with content */
252 if (sccb->header.length != sizeof(struct sclp_vt220_sccb)) {
253 request = sclp_vt220_current_request;
254 sclp_vt220_current_request = NULL;
255 if (timer_pending(&sclp_vt220_timer))
256 del_timer(&sclp_vt220_timer);
258 sclp_vt220_flush_later = 0;
260 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
262 sclp_vt220_emit(request);
265 #define SCLP_NORMAL_WRITE 0x00
268 * Helper function to initialize a page with the sclp request structure.
270 static struct sclp_vt220_request *
271 sclp_vt220_initialize_page(void *page)
273 struct sclp_vt220_request *request;
274 struct sclp_vt220_sccb *sccb;
276 /* Place request structure at end of page */
277 request = ((struct sclp_vt220_request *)
278 ((addr_t) page + PAGE_SIZE)) - 1;
279 request->retry_count = 0;
280 request->sclp_req.sccb = page;
281 /* SCCB goes at start of page */
282 sccb = (struct sclp_vt220_sccb *) page;
283 memset((void *) sccb, 0, sizeof(struct sclp_vt220_sccb));
284 sccb->header.length = sizeof(struct sclp_vt220_sccb);
285 sccb->header.function_code = SCLP_NORMAL_WRITE;
286 sccb->header.response_code = 0x0000;
287 sccb->evbuf.type = EVTYP_VT220MSG;
288 sccb->evbuf.length = sizeof(struct evbuf_header);
293 static inline unsigned int
294 sclp_vt220_space_left(struct sclp_vt220_request *request)
296 struct sclp_vt220_sccb *sccb;
297 sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
298 return PAGE_SIZE - sizeof(struct sclp_vt220_request) -
302 static inline unsigned int
303 sclp_vt220_chars_stored(struct sclp_vt220_request *request)
305 struct sclp_vt220_sccb *sccb;
306 sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
307 return sccb->evbuf.length - sizeof(struct evbuf_header);
311 * Add msg to buffer associated with request. Return the number of characters
315 sclp_vt220_add_msg(struct sclp_vt220_request *request,
316 const unsigned char *msg, int count, int convertlf)
318 struct sclp_vt220_sccb *sccb;
324 if (count > sclp_vt220_space_left(request))
325 count = sclp_vt220_space_left(request);
329 sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
330 buffer = (void *) ((addr_t) sccb + sccb->header.length);
333 /* Perform Linefeed conversion (0x0a -> 0x0a 0x0d)*/
335 (from < count) && (to < sclp_vt220_space_left(request));
337 /* Retrieve character */
339 /* Perform conversion */
341 if (to + 1 < sclp_vt220_space_left(request)) {
342 ((unsigned char *) buffer)[to++] = c;
343 ((unsigned char *) buffer)[to++] = 0x0d;
348 ((unsigned char *) buffer)[to++] = c;
350 sccb->header.length += to;
351 sccb->evbuf.length += to;
354 memcpy(buffer, (const void *) msg, count);
355 sccb->header.length += count;
356 sccb->evbuf.length += count;
362 * Emit buffer after having waited long enough for more data to arrive.
365 sclp_vt220_timeout(unsigned long data)
367 sclp_vt220_emit_current();
370 #define BUFFER_MAX_DELAY HZ/20
373 * Internal implementation of the write function. Write COUNT bytes of data
375 * to the SCLP interface. In case that the data does not fit into the current
376 * write buffer, emit the current one and allocate a new one. If there are no
377 * more empty buffers available, wait until one gets emptied. If DO_SCHEDULE
378 * is non-zero, the buffer will be scheduled for emitting after a timeout -
379 * otherwise the user has to explicitly call the flush function.
380 * A non-zero CONVERTLF parameter indicates that 0x0a characters in the message
381 * buffer should be converted to 0x0a 0x0d. After completion, return the number
385 __sclp_vt220_write(const unsigned char *buf, int count, int do_schedule,
386 int convertlf, int may_schedule)
396 spin_lock_irqsave(&sclp_vt220_lock, flags);
398 /* Create a sclp output buffer if none exists yet */
399 if (sclp_vt220_current_request == NULL) {
400 while (list_empty(&sclp_vt220_empty)) {
401 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
402 if (in_interrupt() || !may_schedule)
405 wait_event(sclp_vt220_waitq,
406 !list_empty(&sclp_vt220_empty));
407 spin_lock_irqsave(&sclp_vt220_lock, flags);
409 page = (void *) sclp_vt220_empty.next;
410 list_del((struct list_head *) page);
411 sclp_vt220_current_request =
412 sclp_vt220_initialize_page(page);
414 /* Try to write the string to the current request buffer */
415 written = sclp_vt220_add_msg(sclp_vt220_current_request,
416 buf, count, convertlf);
417 overall_written += written;
418 if (written == count)
421 * Not all characters could be written to the current
422 * output buffer. Emit the buffer, create a new buffer
423 * and then output the rest of the string.
425 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
426 sclp_vt220_emit_current();
427 spin_lock_irqsave(&sclp_vt220_lock, flags);
431 /* Setup timer to output current console buffer after some time */
432 if (sclp_vt220_current_request != NULL &&
433 !timer_pending(&sclp_vt220_timer) && do_schedule) {
434 sclp_vt220_timer.function = sclp_vt220_timeout;
435 sclp_vt220_timer.data = 0UL;
436 sclp_vt220_timer.expires = jiffies + BUFFER_MAX_DELAY;
437 add_timer(&sclp_vt220_timer);
439 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
440 return overall_written;
444 * This routine is called by the kernel to write a series of
445 * characters to the tty device. The characters may come from
446 * user space or kernel space. This routine will return the
447 * number of characters actually accepted for writing.
450 sclp_vt220_write(struct tty_struct *tty, const unsigned char *buf, int count)
452 return __sclp_vt220_write(buf, count, 1, 0, 1);
455 #define SCLP_VT220_SESSION_ENDED 0x01
456 #define SCLP_VT220_SESSION_STARTED 0x80
457 #define SCLP_VT220_SESSION_DATA 0x00
460 * Called by the SCLP to report incoming event buffers.
463 sclp_vt220_receiver_fn(struct evbuf_header *evbuf)
468 /* Ignore input if device is not open */
469 if (sclp_vt220_tty == NULL)
472 buffer = (char *) ((addr_t) evbuf + sizeof(struct evbuf_header));
473 count = evbuf->length - sizeof(struct evbuf_header);
476 case SCLP_VT220_SESSION_ENDED:
477 case SCLP_VT220_SESSION_STARTED:
479 case SCLP_VT220_SESSION_DATA:
480 /* Send input to line discipline */
483 tty_insert_flip_string(sclp_vt220_tty, buffer, count);
484 tty_flip_buffer_push(sclp_vt220_tty);
490 * This routine is called when a particular tty device is opened.
493 sclp_vt220_open(struct tty_struct *tty, struct file *filp)
495 if (tty->count == 1) {
496 sclp_vt220_tty = tty;
497 tty->driver_data = kmalloc(SCLP_VT220_BUF_SIZE, GFP_KERNEL);
498 if (tty->driver_data == NULL)
500 tty->low_latency = 0;
506 * This routine is called when a particular tty device is closed.
509 sclp_vt220_close(struct tty_struct *tty, struct file *filp)
511 if (tty->count == 1) {
512 sclp_vt220_tty = NULL;
513 kfree(tty->driver_data);
514 tty->driver_data = NULL;
519 * This routine is called by the kernel to write a single
520 * character to the tty device. If the kernel uses this routine,
521 * it must call the flush_chars() routine (if defined) when it is
522 * done stuffing characters into the driver.
524 * NOTE: include/linux/tty_driver.h specifies that a character should be
525 * ignored if there is no room in the queue. This driver implements a different
526 * semantic in that it will block when there is no more room left.
528 * FIXME: putchar can currently be called from BH and other non blocking
529 * handlers so this semantic isn't a good idea.
532 sclp_vt220_put_char(struct tty_struct *tty, unsigned char ch)
534 __sclp_vt220_write(&ch, 1, 0, 0, 1);
539 * This routine is called by the kernel after it has written a
540 * series of characters to the tty device using put_char().
543 sclp_vt220_flush_chars(struct tty_struct *tty)
545 if (sclp_vt220_outqueue_count == 0)
546 sclp_vt220_emit_current();
548 sclp_vt220_flush_later = 1;
552 * This routine returns the numbers of characters the tty driver
553 * will accept for queuing to be written. This number is subject
554 * to change as output buffers get emptied, or if the output flow
558 sclp_vt220_write_room(struct tty_struct *tty)
564 spin_lock_irqsave(&sclp_vt220_lock, flags);
566 if (sclp_vt220_current_request != NULL)
567 count = sclp_vt220_space_left(sclp_vt220_current_request);
568 list_for_each(l, &sclp_vt220_empty)
569 count += SCLP_VT220_MAX_CHARS_PER_BUFFER;
570 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
575 * Return number of buffered chars.
578 sclp_vt220_chars_in_buffer(struct tty_struct *tty)
582 struct sclp_vt220_request *r;
585 spin_lock_irqsave(&sclp_vt220_lock, flags);
587 if (sclp_vt220_current_request != NULL)
588 count = sclp_vt220_chars_stored(sclp_vt220_current_request);
589 list_for_each(l, &sclp_vt220_outqueue) {
590 r = list_entry(l, struct sclp_vt220_request, list);
591 count += sclp_vt220_chars_stored(r);
593 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
598 __sclp_vt220_flush_buffer(void)
602 sclp_vt220_emit_current();
603 spin_lock_irqsave(&sclp_vt220_lock, flags);
604 if (timer_pending(&sclp_vt220_timer))
605 del_timer(&sclp_vt220_timer);
606 while (sclp_vt220_outqueue_count > 0) {
607 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
609 spin_lock_irqsave(&sclp_vt220_lock, flags);
611 spin_unlock_irqrestore(&sclp_vt220_lock, flags);
615 * Pass on all buffers to the hardware. Return only when there are no more
619 sclp_vt220_flush_buffer(struct tty_struct *tty)
621 sclp_vt220_emit_current();
625 * Initialize all relevant components and register driver with system.
627 static void __init __sclp_vt220_cleanup(void)
629 struct list_head *page, *p;
631 list_for_each_safe(page, p, &sclp_vt220_empty) {
633 if (slab_is_available())
634 free_page((unsigned long) page);
636 free_bootmem((unsigned long) page, PAGE_SIZE);
638 if (!list_empty(&sclp_vt220_register.list))
639 sclp_unregister(&sclp_vt220_register);
640 sclp_vt220_initialized = 0;
643 static int __init __sclp_vt220_init(void)
650 if (sclp_vt220_initialized)
652 sclp_vt220_initialized = 1;
653 spin_lock_init(&sclp_vt220_lock);
654 INIT_LIST_HEAD(&sclp_vt220_empty);
655 INIT_LIST_HEAD(&sclp_vt220_outqueue);
656 init_waitqueue_head(&sclp_vt220_waitq);
657 init_timer(&sclp_vt220_timer);
658 sclp_vt220_current_request = NULL;
659 sclp_vt220_buffered_chars = 0;
660 sclp_vt220_outqueue_count = 0;
661 sclp_vt220_tty = NULL;
662 sclp_vt220_flush_later = 0;
664 /* Allocate pages for output buffering */
665 num_pages = slab_is_available() ? MAX_KMEM_PAGES : MAX_CONSOLE_PAGES;
666 for (i = 0; i < num_pages; i++) {
667 if (slab_is_available())
668 page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
670 page = alloc_bootmem_low_pages(PAGE_SIZE);
672 __sclp_vt220_cleanup();
675 list_add_tail((struct list_head *) page, &sclp_vt220_empty);
677 rc = sclp_register(&sclp_vt220_register);
679 printk(KERN_ERR SCLP_VT220_PRINT_HEADER
680 "could not register vt220 - "
681 "sclp_register returned %d\n", rc);
682 __sclp_vt220_cleanup();
687 static const struct tty_operations sclp_vt220_ops = {
688 .open = sclp_vt220_open,
689 .close = sclp_vt220_close,
690 .write = sclp_vt220_write,
691 .put_char = sclp_vt220_put_char,
692 .flush_chars = sclp_vt220_flush_chars,
693 .write_room = sclp_vt220_write_room,
694 .chars_in_buffer = sclp_vt220_chars_in_buffer,
695 .flush_buffer = sclp_vt220_flush_buffer,
699 * Register driver with SCLP and Linux and initialize internal tty structures.
701 static int __init sclp_vt220_tty_init(void)
703 struct tty_driver *driver;
707 /* Note: we're not testing for CONSOLE_IS_SCLP here to preserve
708 * symmetry between VM and LPAR systems regarding ttyS1. */
709 driver = alloc_tty_driver(1);
712 cleanup = !sclp_vt220_initialized;
713 rc = __sclp_vt220_init();
717 driver->owner = THIS_MODULE;
718 driver->driver_name = SCLP_VT220_DRIVER_NAME;
719 driver->name = SCLP_VT220_DEVICE_NAME;
720 driver->major = SCLP_VT220_MAJOR;
721 driver->minor_start = SCLP_VT220_MINOR;
722 driver->type = TTY_DRIVER_TYPE_SYSTEM;
723 driver->subtype = SYSTEM_TYPE_TTY;
724 driver->init_termios = tty_std_termios;
725 driver->flags = TTY_DRIVER_REAL_RAW;
726 tty_set_operations(driver, &sclp_vt220_ops);
728 rc = tty_register_driver(driver);
730 printk(KERN_ERR SCLP_VT220_PRINT_HEADER
731 "could not register tty - "
732 "tty_register_driver returned %d\n", rc);
735 sclp_vt220_driver = driver;
740 __sclp_vt220_cleanup();
742 put_tty_driver(driver);
745 __initcall(sclp_vt220_tty_init);
747 #ifdef CONFIG_SCLP_VT220_CONSOLE
750 sclp_vt220_con_write(struct console *con, const char *buf, unsigned int count)
752 __sclp_vt220_write((const unsigned char *) buf, count, 1, 1, 0);
755 static struct tty_driver *
756 sclp_vt220_con_device(struct console *c, int *index)
759 return sclp_vt220_driver;
763 * This routine is called from panic when the kernel is going to give up.
764 * We have to make sure that all buffers will be flushed to the SCLP.
765 * Note that this function may be called from within an interrupt context.
768 sclp_vt220_con_unblank(void)
770 __sclp_vt220_flush_buffer();
773 /* Structure needed to register with printk */
774 static struct console sclp_vt220_console =
776 .name = SCLP_VT220_CONSOLE_NAME,
777 .write = sclp_vt220_con_write,
778 .device = sclp_vt220_con_device,
779 .unblank = sclp_vt220_con_unblank,
780 .flags = CON_PRINTBUFFER,
781 .index = SCLP_VT220_CONSOLE_INDEX
785 sclp_vt220_con_init(void)
789 if (!CONSOLE_IS_SCLP)
791 rc = __sclp_vt220_init();
794 /* Attach linux console */
795 register_console(&sclp_vt220_console);
799 console_initcall(sclp_vt220_con_init);
800 #endif /* CONFIG_SCLP_VT220_CONSOLE */