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 */ 41 struct sclp_vt220_request { 42 struct list_head list; 43 struct sclp_req sclp_req; 44 int retry_count; 45 }; 46 47 /* VT220 SCCB */ 48 struct 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 */ 58 static struct tty_driver *sclp_vt220_driver; 59 60 /* The tty_struct that the kernel associated with us */ 61 static struct tty_struct *sclp_vt220_tty; 62 63 /* Lock to protect internal data from concurrent access */ 64 static spinlock_t sclp_vt220_lock; 65 66 /* List of empty pages to be used as write request buffers */ 67 static struct list_head sclp_vt220_empty; 68 69 /* List of pending requests */ 70 static struct list_head sclp_vt220_outqueue; 71 72 /* Number of requests in outqueue */ 73 static int sclp_vt220_outqueue_count; 74 75 /* Timer used for delaying write requests to merge subsequent messages into 76 * a single buffer */ 77 static struct timer_list sclp_vt220_timer; 78 79 /* Pointer to current request buffer which has been partially filled but not 80 * yet sent */ 81 static struct sclp_vt220_request *sclp_vt220_current_request; 82 83 /* Number of characters in current request buffer */ 84 static int sclp_vt220_buffered_chars; 85 86 /* Counter controlling core driver initialization. */ 87 static 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 */ 92 static int sclp_vt220_flush_later; 93 94 static void sclp_vt220_receiver_fn(struct evbuf_header *evbuf); 95 static int __sclp_vt220_emit(struct sclp_vt220_request *request); 96 static void sclp_vt220_emit_current(void); 97 98 /* Registration structure for our interest in SCLP event buffers */ 99 static 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 */ 111 static void 112 sclp_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 */ 146 static void 147 sclp_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 */ 199 static 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 */ 217 static void 218 sclp_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 */ 236 static void 237 sclp_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 */ 267 static struct sclp_vt220_request * 268 sclp_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 290 static inline unsigned int 291 sclp_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 299 static inline unsigned int 300 sclp_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 */ 311 static int 312 sclp_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 */ 361 static void 362 sclp_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 */ 381 static 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); 436 out: 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 */ 446 static int 447 sclp_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 */ 459 static void 460 sclp_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 */ 489 static int 490 sclp_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 */ 505 static void 506 sclp_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 */ 521 static int 522 sclp_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 */ 531 static void 532 sclp_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 */ 546 static int 547 sclp_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 */ 566 static int 567 sclp_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 586 static 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 */ 607 static void 608 sclp_vt220_flush_buffer(struct tty_struct *tty) 609 { 610 sclp_vt220_emit_current(); 611 } 612 613 /* Release allocated pages. */ 614 static 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. */ 629 static 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. */ 640 static 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); 672 out: 673 if (rc) { 674 __sclp_vt220_free_pages(); 675 sclp_vt220_init_count--; 676 } 677 return rc; 678 } 679 680 static 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 */ 694 static 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 725 out_init: 726 __sclp_vt220_cleanup(); 727 out_driver: 728 put_tty_driver(driver); 729 return rc; 730 } 731 __initcall(sclp_vt220_tty_init); 732 733 #ifdef CONFIG_SCLP_VT220_CONSOLE 734 735 static void 736 sclp_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 741 static struct tty_driver * 742 sclp_vt220_con_device(struct console *c, int *index) 743 { 744 *index = 0; 745 return sclp_vt220_driver; 746 } 747 748 static int 749 sclp_vt220_notify(struct notifier_block *self, 750 unsigned long event, void *data) 751 { 752 __sclp_vt220_flush_buffer(); 753 return NOTIFY_OK; 754 } 755 756 static struct notifier_block on_panic_nb = { 757 .notifier_call = sclp_vt220_notify, 758 .priority = 1, 759 }; 760 761 static struct notifier_block on_reboot_nb = { 762 .notifier_call = sclp_vt220_notify, 763 .priority = 1, 764 }; 765 766 /* Structure needed to register with printk */ 767 static 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 776 static int __init 777 sclp_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 793 console_initcall(sclp_vt220_con_init); 794 #endif /* CONFIG_SCLP_VT220_CONSOLE */ 795 796