sclp_vt220.c revision 2332ce1a97963b7769e0c2d40492a10a124efba5 
1/*
2 *  drivers/s390/char/sclp_vt220.c
3 *    SCLP VT220 terminal driver.
4 *
5 *  S390 version
6 *    Copyright IBM Corp. 2003,2008
7 *    Author(s): Peter Oberparleiter <Peter.Oberparleiter@de.ibm.com>
8 */
9
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>
20#include <linux/mm.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 <linux/reboot.h>
28
29#include <asm/uaccess.h>
30#include "sclp.h"
31
32#define SCLP_VT220_MAJOR		TTY_MAJOR
33#define SCLP_VT220_MINOR		65
34#define SCLP_VT220_DRIVER_NAME		"sclp_vt220"
35#define SCLP_VT220_DEVICE_NAME		"ttysclp"
36#define SCLP_VT220_CONSOLE_NAME		"ttyS"
37#define SCLP_VT220_CONSOLE_INDEX	1	/* console=ttyS1 */
38#define SCLP_VT220_BUF_SIZE		80
39
40/* Representation of a single write request */
41struct sclp_vt220_request {
42	struct list_head list;
43	struct sclp_req sclp_req;
44	int retry_count;
45};
46
47/* VT220 SCCB */
48struct sclp_vt220_sccb {
49	struct sccb_header header;
50	struct evbuf_header evbuf;
51};
52
53#define SCLP_VT220_MAX_CHARS_PER_BUFFER	(PAGE_SIZE - \
54					 sizeof(struct sclp_vt220_request) - \
55					 sizeof(struct sclp_vt220_sccb))
56
57/* Structures and data needed to register tty driver */
58static struct tty_driver *sclp_vt220_driver;
59
60/* The tty_struct that the kernel associated with us */
61static struct tty_struct *sclp_vt220_tty;
62
63/* Lock to protect internal data from concurrent access */
64static spinlock_t sclp_vt220_lock;
65
66/* List of empty pages to be used as write request buffers */
67static struct list_head sclp_vt220_empty;
68
69/* List of pending requests */
70static struct list_head sclp_vt220_outqueue;
71
72/* Number of requests in outqueue */
73static int sclp_vt220_outqueue_count;
74
75/* Timer used for delaying write requests to merge subsequent messages into
76 * a single buffer */
77static struct timer_list sclp_vt220_timer;
78
79/* Pointer to current request buffer which has been partially filled but not
80 * yet sent */
81static struct sclp_vt220_request *sclp_vt220_current_request;
82
83/* Number of characters in current request buffer */
84static int sclp_vt220_buffered_chars;
85
86/* Counter controlling core driver initialization. */
87static int __initdata sclp_vt220_init_count;
88
89/* Flag indicating that sclp_vt220_current_request should really
90 * have been already queued but wasn't because the SCLP was processing
91 * another buffer */
92static int sclp_vt220_flush_later;
93
94static void sclp_vt220_receiver_fn(struct evbuf_header *evbuf);
95static int __sclp_vt220_emit(struct sclp_vt220_request *request);
96static void sclp_vt220_emit_current(void);
97
98/* Registration structure for our interest in SCLP event buffers */
99static struct sclp_register sclp_vt220_register = {
100	.send_mask		= EVTYP_VT220MSG_MASK,
101	.receive_mask		= EVTYP_VT220MSG_MASK,
102	.state_change_fn	= NULL,
103	.receiver_fn		= sclp_vt220_receiver_fn
104};
105
106
107/*
108 * Put provided request buffer back into queue and check emit pending
109 * buffers if necessary.
110 */
111static void
112sclp_vt220_process_queue(struct sclp_vt220_request *request)
113{
114	unsigned long flags;
115	void *page;
116
117	do {
118		/* Put buffer back to list of empty buffers */
119		page = request->sclp_req.sccb;
120		spin_lock_irqsave(&sclp_vt220_lock, flags);
121		/* Move request from outqueue to empty queue */
122		list_del(&request->list);
123		sclp_vt220_outqueue_count--;
124		list_add_tail((struct list_head *) page, &sclp_vt220_empty);
125		/* Check if there is a pending buffer on the out queue. */
126		request = NULL;
127		if (!list_empty(&sclp_vt220_outqueue))
128			request = list_entry(sclp_vt220_outqueue.next,
129					     struct sclp_vt220_request, list);
130		spin_unlock_irqrestore(&sclp_vt220_lock, flags);
131	} while (request && __sclp_vt220_emit(request));
132	if (request == NULL && sclp_vt220_flush_later)
133		sclp_vt220_emit_current();
134	/* Check if the tty needs a wake up call */
135	if (sclp_vt220_tty != NULL) {
136		tty_wakeup(sclp_vt220_tty);
137	}
138}
139
140#define SCLP_BUFFER_MAX_RETRY		1
141
142/*
143 * Callback through which the result of a write request is reported by the
144 * SCLP.
145 */
146static void
147sclp_vt220_callback(struct sclp_req *request, void *data)
148{
149	struct sclp_vt220_request *vt220_request;
150	struct sclp_vt220_sccb *sccb;
151
152	vt220_request = (struct sclp_vt220_request *) data;
153	if (request->status == SCLP_REQ_FAILED) {
154		sclp_vt220_process_queue(vt220_request);
155		return;
156	}
157	sccb = (struct sclp_vt220_sccb *) vt220_request->sclp_req.sccb;
158
159	/* Check SCLP response code and choose suitable action	*/
160	switch (sccb->header.response_code) {
161	case 0x0020 :
162		break;
163
164	case 0x05f0: /* Target resource in improper state */
165		break;
166
167	case 0x0340: /* Contained SCLP equipment check */
168		if (++vt220_request->retry_count > SCLP_BUFFER_MAX_RETRY)
169			break;
170		/* Remove processed buffers and requeue rest */
171		if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {
172			/* Not all buffers were processed */
173			sccb->header.response_code = 0x0000;
174			vt220_request->sclp_req.status = SCLP_REQ_FILLED;
175			if (sclp_add_request(request) == 0)
176				return;
177		}
178		break;
179
180	case 0x0040: /* SCLP equipment check */
181		if (++vt220_request->retry_count > SCLP_BUFFER_MAX_RETRY)
182			break;
183		sccb->header.response_code = 0x0000;
184		vt220_request->sclp_req.status = SCLP_REQ_FILLED;
185		if (sclp_add_request(request) == 0)
186			return;
187		break;
188
189	default:
190		break;
191	}
192	sclp_vt220_process_queue(vt220_request);
193}
194
195/*
196 * Emit vt220 request buffer to SCLP. Return zero on success, non-zero
197 * otherwise.
198 */
199static int
200__sclp_vt220_emit(struct sclp_vt220_request *request)
201{
202	if (!(sclp_vt220_register.sclp_receive_mask & EVTYP_VT220MSG_MASK)) {
203		request->sclp_req.status = SCLP_REQ_FAILED;
204		return -EIO;
205	}
206	request->sclp_req.command = SCLP_CMDW_WRITE_EVENT_DATA;
207	request->sclp_req.status = SCLP_REQ_FILLED;
208	request->sclp_req.callback = sclp_vt220_callback;
209	request->sclp_req.callback_data = (void *) request;
210
211	return sclp_add_request(&request->sclp_req);
212}
213
214/*
215 * Queue and emit given request.
216 */
217static void
218sclp_vt220_emit(struct sclp_vt220_request *request)
219{
220	unsigned long flags;
221	int count;
222
223	spin_lock_irqsave(&sclp_vt220_lock, flags);
224	list_add_tail(&request->list, &sclp_vt220_outqueue);
225	count = sclp_vt220_outqueue_count++;
226	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
227	/* Emit only the first buffer immediately - callback takes care of
228	 * the rest */
229	if (count == 0 && __sclp_vt220_emit(request))
230		sclp_vt220_process_queue(request);
231}
232
233/*
234 * Queue and emit current request. Return zero on success, non-zero otherwise.
235 */
236static void
237sclp_vt220_emit_current(void)
238{
239	unsigned long flags;
240	struct sclp_vt220_request *request;
241	struct sclp_vt220_sccb *sccb;
242
243	spin_lock_irqsave(&sclp_vt220_lock, flags);
244	request = NULL;
245	if (sclp_vt220_current_request != NULL) {
246		sccb = (struct sclp_vt220_sccb *)
247				sclp_vt220_current_request->sclp_req.sccb;
248		/* Only emit buffers with content */
249		if (sccb->header.length != sizeof(struct sclp_vt220_sccb)) {
250			request = sclp_vt220_current_request;
251			sclp_vt220_current_request = NULL;
252			if (timer_pending(&sclp_vt220_timer))
253				del_timer(&sclp_vt220_timer);
254		}
255		sclp_vt220_flush_later = 0;
256	}
257	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
258	if (request != NULL)
259		sclp_vt220_emit(request);
260}
261
262#define SCLP_NORMAL_WRITE	0x00
263
264/*
265 * Helper function to initialize a page with the sclp request structure.
266 */
267static struct sclp_vt220_request *
268sclp_vt220_initialize_page(void *page)
269{
270	struct sclp_vt220_request *request;
271	struct sclp_vt220_sccb *sccb;
272
273	/* Place request structure at end of page */
274	request = ((struct sclp_vt220_request *)
275			((addr_t) page + PAGE_SIZE)) - 1;
276	request->retry_count = 0;
277	request->sclp_req.sccb = page;
278	/* SCCB goes at start of page */
279	sccb = (struct sclp_vt220_sccb *) page;
280	memset((void *) sccb, 0, sizeof(struct sclp_vt220_sccb));
281	sccb->header.length = sizeof(struct sclp_vt220_sccb);
282	sccb->header.function_code = SCLP_NORMAL_WRITE;
283	sccb->header.response_code = 0x0000;
284	sccb->evbuf.type = EVTYP_VT220MSG;
285	sccb->evbuf.length = sizeof(struct evbuf_header);
286
287	return request;
288}
289
290static inline unsigned int
291sclp_vt220_space_left(struct sclp_vt220_request *request)
292{
293	struct sclp_vt220_sccb *sccb;
294	sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
295	return PAGE_SIZE - sizeof(struct sclp_vt220_request) -
296	       sccb->header.length;
297}
298
299static inline unsigned int
300sclp_vt220_chars_stored(struct sclp_vt220_request *request)
301{
302	struct sclp_vt220_sccb *sccb;
303	sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
304	return sccb->evbuf.length - sizeof(struct evbuf_header);
305}
306
307/*
308 * Add msg to buffer associated with request. Return the number of characters
309 * added.
310 */
311static int
312sclp_vt220_add_msg(struct sclp_vt220_request *request,
313		   const unsigned char *msg, int count, int convertlf)
314{
315	struct sclp_vt220_sccb *sccb;
316	void *buffer;
317	unsigned char c;
318	int from;
319	int to;
320
321	if (count > sclp_vt220_space_left(request))
322		count = sclp_vt220_space_left(request);
323	if (count <= 0)
324		return 0;
325
326	sccb = (struct sclp_vt220_sccb *) request->sclp_req.sccb;
327	buffer = (void *) ((addr_t) sccb + sccb->header.length);
328
329	if (convertlf) {
330		/* Perform Linefeed conversion (0x0a -> 0x0a 0x0d)*/
331		for (from=0, to=0;
332		     (from < count) && (to < sclp_vt220_space_left(request));
333		     from++) {
334			/* Retrieve character */
335			c = msg[from];
336			/* Perform conversion */
337			if (c == 0x0a) {
338				if (to + 1 < sclp_vt220_space_left(request)) {
339					((unsigned char *) buffer)[to++] = c;
340					((unsigned char *) buffer)[to++] = 0x0d;
341				} else
342					break;
343
344			} else
345				((unsigned char *) buffer)[to++] = c;
346		}
347		sccb->header.length += to;
348		sccb->evbuf.length += to;
349		return from;
350	} else {
351		memcpy(buffer, (const void *) msg, count);
352		sccb->header.length += count;
353		sccb->evbuf.length += count;
354		return count;
355	}
356}
357
358/*
359 * Emit buffer after having waited long enough for more data to arrive.
360 */
361static void
362sclp_vt220_timeout(unsigned long data)
363{
364	sclp_vt220_emit_current();
365}
366
367#define BUFFER_MAX_DELAY	HZ/20
368
369/*
370 * Internal implementation of the write function. Write COUNT bytes of data
371 * from memory at BUF
372 * to the SCLP interface. In case that the data does not fit into the current
373 * write buffer, emit the current one and allocate a new one. If there are no
374 * more empty buffers available, wait until one gets emptied. If DO_SCHEDULE
375 * is non-zero, the buffer will be scheduled for emitting after a timeout -
376 * otherwise the user has to explicitly call the flush function.
377 * A non-zero CONVERTLF parameter indicates that 0x0a characters in the message
378 * buffer should be converted to 0x0a 0x0d. After completion, return the number
379 * of bytes written.
380 */
381static int
382__sclp_vt220_write(const unsigned char *buf, int count, int do_schedule,
383		   int convertlf, int may_fail)
384{
385	unsigned long flags;
386	void *page;
387	int written;
388	int overall_written;
389
390	if (count <= 0)
391		return 0;
392	overall_written = 0;
393	spin_lock_irqsave(&sclp_vt220_lock, flags);
394	do {
395		/* Create an sclp output buffer if none exists yet */
396		if (sclp_vt220_current_request == NULL) {
397			while (list_empty(&sclp_vt220_empty)) {
398				spin_unlock_irqrestore(&sclp_vt220_lock, flags);
399				if (may_fail)
400					goto out;
401				else
402					sclp_sync_wait();
403				spin_lock_irqsave(&sclp_vt220_lock, flags);
404			}
405			page = (void *) sclp_vt220_empty.next;
406			list_del((struct list_head *) page);
407			sclp_vt220_current_request =
408				sclp_vt220_initialize_page(page);
409		}
410		/* Try to write the string to the current request buffer */
411		written = sclp_vt220_add_msg(sclp_vt220_current_request,
412					     buf, count, convertlf);
413		overall_written += written;
414		if (written == count)
415			break;
416		/*
417		 * Not all characters could be written to the current
418		 * output buffer. Emit the buffer, create a new buffer
419		 * and then output the rest of the string.
420		 */
421		spin_unlock_irqrestore(&sclp_vt220_lock, flags);
422		sclp_vt220_emit_current();
423		spin_lock_irqsave(&sclp_vt220_lock, flags);
424		buf += written;
425		count -= written;
426	} while (count > 0);
427	/* Setup timer to output current console buffer after some time */
428	if (sclp_vt220_current_request != NULL &&
429	    !timer_pending(&sclp_vt220_timer) && do_schedule) {
430		sclp_vt220_timer.function = sclp_vt220_timeout;
431		sclp_vt220_timer.data = 0UL;
432		sclp_vt220_timer.expires = jiffies + BUFFER_MAX_DELAY;
433		add_timer(&sclp_vt220_timer);
434	}
435	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
436out:
437	return overall_written;
438}
439
440/*
441 * This routine is called by the kernel to write a series of
442 * characters to the tty device.  The characters may come from
443 * user space or kernel space.  This routine will return the
444 * number of characters actually accepted for writing.
445 */
446static int
447sclp_vt220_write(struct tty_struct *tty, const unsigned char *buf, int count)
448{
449	return __sclp_vt220_write(buf, count, 1, 0, 1);
450}
451
452#define SCLP_VT220_SESSION_ENDED	0x01
453#define	SCLP_VT220_SESSION_STARTED	0x80
454#define SCLP_VT220_SESSION_DATA		0x00
455
456/*
457 * Called by the SCLP to report incoming event buffers.
458 */
459static void
460sclp_vt220_receiver_fn(struct evbuf_header *evbuf)
461{
462	char *buffer;
463	unsigned int count;
464
465	/* Ignore input if device is not open */
466	if (sclp_vt220_tty == NULL)
467		return;
468
469	buffer = (char *) ((addr_t) evbuf + sizeof(struct evbuf_header));
470	count = evbuf->length - sizeof(struct evbuf_header);
471
472	switch (*buffer) {
473	case SCLP_VT220_SESSION_ENDED:
474	case SCLP_VT220_SESSION_STARTED:
475		break;
476	case SCLP_VT220_SESSION_DATA:
477		/* Send input to line discipline */
478		buffer++;
479		count--;
480		tty_insert_flip_string(sclp_vt220_tty, buffer, count);
481		tty_flip_buffer_push(sclp_vt220_tty);
482		break;
483	}
484}
485
486/*
487 * This routine is called when a particular tty device is opened.
488 */
489static int
490sclp_vt220_open(struct tty_struct *tty, struct file *filp)
491{
492	if (tty->count == 1) {
493		sclp_vt220_tty = tty;
494		tty->driver_data = kmalloc(SCLP_VT220_BUF_SIZE, GFP_KERNEL);
495		if (tty->driver_data == NULL)
496			return -ENOMEM;
497		tty->low_latency = 0;
498	}
499	return 0;
500}
501
502/*
503 * This routine is called when a particular tty device is closed.
504 */
505static void
506sclp_vt220_close(struct tty_struct *tty, struct file *filp)
507{
508	if (tty->count == 1) {
509		sclp_vt220_tty = NULL;
510		kfree(tty->driver_data);
511		tty->driver_data = NULL;
512	}
513}
514
515/*
516 * This routine is called by the kernel to write a single
517 * character to the tty device.  If the kernel uses this routine,
518 * it must call the flush_chars() routine (if defined) when it is
519 * done stuffing characters into the driver.
520 */
521static int
522sclp_vt220_put_char(struct tty_struct *tty, unsigned char ch)
523{
524	return __sclp_vt220_write(&ch, 1, 0, 0, 1);
525}
526
527/*
528 * This routine is called by the kernel after it has written a
529 * series of characters to the tty device using put_char().
530 */
531static void
532sclp_vt220_flush_chars(struct tty_struct *tty)
533{
534	if (sclp_vt220_outqueue_count == 0)
535		sclp_vt220_emit_current();
536	else
537		sclp_vt220_flush_later = 1;
538}
539
540/*
541 * This routine returns the numbers of characters the tty driver
542 * will accept for queuing to be written.  This number is subject
543 * to change as output buffers get emptied, or if the output flow
544 * control is acted.
545 */
546static int
547sclp_vt220_write_room(struct tty_struct *tty)
548{
549	unsigned long flags;
550	struct list_head *l;
551	int count;
552
553	spin_lock_irqsave(&sclp_vt220_lock, flags);
554	count = 0;
555	if (sclp_vt220_current_request != NULL)
556		count = sclp_vt220_space_left(sclp_vt220_current_request);
557	list_for_each(l, &sclp_vt220_empty)
558		count += SCLP_VT220_MAX_CHARS_PER_BUFFER;
559	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
560	return count;
561}
562
563/*
564 * Return number of buffered chars.
565 */
566static int
567sclp_vt220_chars_in_buffer(struct tty_struct *tty)
568{
569	unsigned long flags;
570	struct list_head *l;
571	struct sclp_vt220_request *r;
572	int count;
573
574	spin_lock_irqsave(&sclp_vt220_lock, flags);
575	count = 0;
576	if (sclp_vt220_current_request != NULL)
577		count = sclp_vt220_chars_stored(sclp_vt220_current_request);
578	list_for_each(l, &sclp_vt220_outqueue) {
579		r = list_entry(l, struct sclp_vt220_request, list);
580		count += sclp_vt220_chars_stored(r);
581	}
582	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
583	return count;
584}
585
586static void
587__sclp_vt220_flush_buffer(void)
588{
589	unsigned long flags;
590
591	sclp_vt220_emit_current();
592	spin_lock_irqsave(&sclp_vt220_lock, flags);
593	if (timer_pending(&sclp_vt220_timer))
594		del_timer(&sclp_vt220_timer);
595	while (sclp_vt220_outqueue_count > 0) {
596		spin_unlock_irqrestore(&sclp_vt220_lock, flags);
597		sclp_sync_wait();
598		spin_lock_irqsave(&sclp_vt220_lock, flags);
599	}
600	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
601}
602
603/*
604 * Pass on all buffers to the hardware. Return only when there are no more
605 * buffers pending.
606 */
607static void
608sclp_vt220_flush_buffer(struct tty_struct *tty)
609{
610	sclp_vt220_emit_current();
611}
612
613/* Release allocated pages. */
614static void __init __sclp_vt220_free_pages(void)
615{
616	struct list_head *page, *p;
617
618	list_for_each_safe(page, p, &sclp_vt220_empty) {
619		list_del(page);
620		if (slab_is_available())
621			free_page((unsigned long) page);
622		else
623			free_bootmem((unsigned long) page, PAGE_SIZE);
624	}
625}
626
627/* Release memory and unregister from sclp core. Controlled by init counting -
628 * only the last invoker will actually perform these actions. */
629static void __init __sclp_vt220_cleanup(void)
630{
631	sclp_vt220_init_count--;
632	if (sclp_vt220_init_count != 0)
633		return;
634	sclp_unregister(&sclp_vt220_register);
635	__sclp_vt220_free_pages();
636}
637
638/* Allocate buffer pages and register with sclp core. Controlled by init
639 * counting - only the first invoker will actually perform these actions. */
640static int __init __sclp_vt220_init(int num_pages)
641{
642	void *page;
643	int i;
644	int rc;
645
646	sclp_vt220_init_count++;
647	if (sclp_vt220_init_count != 1)
648		return 0;
649	spin_lock_init(&sclp_vt220_lock);
650	INIT_LIST_HEAD(&sclp_vt220_empty);
651	INIT_LIST_HEAD(&sclp_vt220_outqueue);
652	init_timer(&sclp_vt220_timer);
653	sclp_vt220_current_request = NULL;
654	sclp_vt220_buffered_chars = 0;
655	sclp_vt220_outqueue_count = 0;
656	sclp_vt220_tty = NULL;
657	sclp_vt220_flush_later = 0;
658
659	/* Allocate pages for output buffering */
660	for (i = 0; i < num_pages; i++) {
661		if (slab_is_available())
662			page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
663		else
664			page = alloc_bootmem_low_pages(PAGE_SIZE);
665		if (!page) {
666			rc = -ENOMEM;
667			goto out;
668		}
669		list_add_tail((struct list_head *) page, &sclp_vt220_empty);
670	}
671	rc = sclp_register(&sclp_vt220_register);
672out:
673	if (rc) {
674		__sclp_vt220_free_pages();
675		sclp_vt220_init_count--;
676	}
677	return rc;
678}
679
680static const struct tty_operations sclp_vt220_ops = {
681	.open = sclp_vt220_open,
682	.close = sclp_vt220_close,
683	.write = sclp_vt220_write,
684	.put_char = sclp_vt220_put_char,
685	.flush_chars = sclp_vt220_flush_chars,
686	.write_room = sclp_vt220_write_room,
687	.chars_in_buffer = sclp_vt220_chars_in_buffer,
688	.flush_buffer = sclp_vt220_flush_buffer,
689};
690
691/*
692 * Register driver with SCLP and Linux and initialize internal tty structures.
693 */
694static int __init sclp_vt220_tty_init(void)
695{
696	struct tty_driver *driver;
697	int rc;
698
699	/* Note: we're not testing for CONSOLE_IS_SCLP here to preserve
700	 * symmetry between VM and LPAR systems regarding ttyS1. */
701	driver = alloc_tty_driver(1);
702	if (!driver)
703		return -ENOMEM;
704	rc = __sclp_vt220_init(MAX_KMEM_PAGES);
705	if (rc)
706		goto out_driver;
707
708	driver->owner = THIS_MODULE;
709	driver->driver_name = SCLP_VT220_DRIVER_NAME;
710	driver->name = SCLP_VT220_DEVICE_NAME;
711	driver->major = SCLP_VT220_MAJOR;
712	driver->minor_start = SCLP_VT220_MINOR;
713	driver->type = TTY_DRIVER_TYPE_SYSTEM;
714	driver->subtype = SYSTEM_TYPE_TTY;
715	driver->init_termios = tty_std_termios;
716	driver->flags = TTY_DRIVER_REAL_RAW;
717	tty_set_operations(driver, &sclp_vt220_ops);
718
719	rc = tty_register_driver(driver);
720	if (rc)
721		goto out_init;
722	sclp_vt220_driver = driver;
723	return 0;
724
725out_init:
726	__sclp_vt220_cleanup();
727out_driver:
728	put_tty_driver(driver);
729	return rc;
730}
731__initcall(sclp_vt220_tty_init);
732
733#ifdef CONFIG_SCLP_VT220_CONSOLE
734
735static void
736sclp_vt220_con_write(struct console *con, const char *buf, unsigned int count)
737{
738	__sclp_vt220_write((const unsigned char *) buf, count, 1, 1, 0);
739}
740
741static struct tty_driver *
742sclp_vt220_con_device(struct console *c, int *index)
743{
744	*index = 0;
745	return sclp_vt220_driver;
746}
747
748static int
749sclp_vt220_notify(struct notifier_block *self,
750			  unsigned long event, void *data)
751{
752	__sclp_vt220_flush_buffer();
753	return NOTIFY_OK;
754}
755
756static struct notifier_block on_panic_nb = {
757	.notifier_call = sclp_vt220_notify,
758	.priority = 1,
759};
760
761static struct notifier_block on_reboot_nb = {
762	.notifier_call = sclp_vt220_notify,
763	.priority = 1,
764};
765
766/* Structure needed to register with printk */
767static struct console sclp_vt220_console =
768{
769	.name = SCLP_VT220_CONSOLE_NAME,
770	.write = sclp_vt220_con_write,
771	.device = sclp_vt220_con_device,
772	.flags = CON_PRINTBUFFER,
773	.index = SCLP_VT220_CONSOLE_INDEX
774};
775
776static int __init
777sclp_vt220_con_init(void)
778{
779	int rc;
780
781	if (!CONSOLE_IS_SCLP)
782		return 0;
783	rc = __sclp_vt220_init(MAX_CONSOLE_PAGES);
784	if (rc)
785		return rc;
786	/* Attach linux console */
787	atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
788	register_reboot_notifier(&on_reboot_nb);
789	register_console(&sclp_vt220_console);
790	return 0;
791}
792
793console_initcall(sclp_vt220_con_init);
794#endif /* CONFIG_SCLP_VT220_CONSOLE */
795
796