1 /* 2 * 3215 line mode terminal driver. 3 * 4 * Copyright IBM Corp. 1999, 2009 5 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com> 6 * 7 * Updated: 8 * Aug-2000: Added tab support 9 * Dan Morrison, IBM Corporation <dmorriso@cse.buffalo.edu> 10 */ 11 12 #include <linux/module.h> 13 #include <linux/types.h> 14 #include <linux/kdev_t.h> 15 #include <linux/tty.h> 16 #include <linux/tty_flip.h> 17 #include <linux/vt_kern.h> 18 #include <linux/init.h> 19 #include <linux/console.h> 20 #include <linux/interrupt.h> 21 #include <linux/err.h> 22 #include <linux/reboot.h> 23 #include <linux/slab.h> 24 #include <asm/ccwdev.h> 25 #include <asm/cio.h> 26 #include <asm/io.h> 27 #include <asm/ebcdic.h> 28 #include <asm/uaccess.h> 29 #include <asm/delay.h> 30 #include <asm/cpcmd.h> 31 #include <asm/setup.h> 32 33 #include "ctrlchar.h" 34 35 #define NR_3215 1 36 #define NR_3215_REQ (4*NR_3215) 37 #define RAW3215_BUFFER_SIZE 65536 /* output buffer size */ 38 #define RAW3215_INBUF_SIZE 256 /* input buffer size */ 39 #define RAW3215_MIN_SPACE 128 /* minimum free space for wakeup */ 40 #define RAW3215_MIN_WRITE 1024 /* min. length for immediate output */ 41 #define RAW3215_MAX_BYTES 3968 /* max. bytes to write with one ssch */ 42 #define RAW3215_MAX_NEWLINE 50 /* max. lines to write with one ssch */ 43 #define RAW3215_NR_CCWS 3 44 #define RAW3215_TIMEOUT HZ/10 /* time for delayed output */ 45 46 #define RAW3215_FIXED 1 /* 3215 console device is not be freed */ 47 #define RAW3215_ACTIVE 2 /* set if the device is in use */ 48 #define RAW3215_WORKING 4 /* set if a request is being worked on */ 49 #define RAW3215_THROTTLED 8 /* set if reading is disabled */ 50 #define RAW3215_STOPPED 16 /* set if writing is disabled */ 51 #define RAW3215_CLOSING 32 /* set while in close process */ 52 #define RAW3215_TIMER_RUNS 64 /* set if the output delay timer is on */ 53 #define RAW3215_FLUSHING 128 /* set to flush buffer (no delay) */ 54 #define RAW3215_FROZEN 256 /* set if 3215 is frozen for suspend */ 55 56 #define TAB_STOP_SIZE 8 /* tab stop size */ 57 58 /* 59 * Request types for a 3215 device 60 */ 61 enum raw3215_type { 62 RAW3215_FREE, RAW3215_READ, RAW3215_WRITE 63 }; 64 65 /* 66 * Request structure for a 3215 device 67 */ 68 struct raw3215_req { 69 enum raw3215_type type; /* type of the request */ 70 int start, len; /* start index & len in output buffer */ 71 int delayable; /* indication to wait for more data */ 72 int residual; /* residual count for read request */ 73 struct ccw1 ccws[RAW3215_NR_CCWS]; /* space for the channel program */ 74 struct raw3215_info *info; /* pointer to main structure */ 75 struct raw3215_req *next; /* pointer to next request */ 76 } __attribute__ ((aligned(8))); 77 78 struct raw3215_info { 79 struct ccw_device *cdev; /* device for tty driver */ 80 spinlock_t *lock; /* pointer to irq lock */ 81 int flags; /* state flags */ 82 char *buffer; /* pointer to output buffer */ 83 char *inbuf; /* pointer to input buffer */ 84 int head; /* first free byte in output buffer */ 85 int count; /* number of bytes in output buffer */ 86 int written; /* number of bytes in write requests */ 87 struct tty_struct *tty; /* pointer to tty structure if present */ 88 struct raw3215_req *queued_read; /* pointer to queued read requests */ 89 struct raw3215_req *queued_write;/* pointer to queued write requests */ 90 struct tasklet_struct tlet; /* tasklet to invoke tty_wakeup */ 91 wait_queue_head_t empty_wait; /* wait queue for flushing */ 92 struct timer_list timer; /* timer for delayed output */ 93 int line_pos; /* position on the line (for tabs) */ 94 char ubuffer[80]; /* copy_from_user buffer */ 95 }; 96 97 /* array of 3215 devices structures */ 98 static struct raw3215_info *raw3215[NR_3215]; 99 /* spinlock to protect the raw3215 array */ 100 static DEFINE_SPINLOCK(raw3215_device_lock); 101 /* list of free request structures */ 102 static struct raw3215_req *raw3215_freelist; 103 /* spinlock to protect free list */ 104 static spinlock_t raw3215_freelist_lock; 105 106 static struct tty_driver *tty3215_driver; 107 108 /* 109 * Get a request structure from the free list 110 */ 111 static inline struct raw3215_req *raw3215_alloc_req(void) 112 { 113 struct raw3215_req *req; 114 unsigned long flags; 115 116 spin_lock_irqsave(&raw3215_freelist_lock, flags); 117 req = raw3215_freelist; 118 raw3215_freelist = req->next; 119 spin_unlock_irqrestore(&raw3215_freelist_lock, flags); 120 return req; 121 } 122 123 /* 124 * Put a request structure back to the free list 125 */ 126 static inline void raw3215_free_req(struct raw3215_req *req) 127 { 128 unsigned long flags; 129 130 if (req->type == RAW3215_FREE) 131 return; /* don't free a free request */ 132 req->type = RAW3215_FREE; 133 spin_lock_irqsave(&raw3215_freelist_lock, flags); 134 req->next = raw3215_freelist; 135 raw3215_freelist = req; 136 spin_unlock_irqrestore(&raw3215_freelist_lock, flags); 137 } 138 139 /* 140 * Set up a read request that reads up to 160 byte from the 3215 device. 141 * If there is a queued read request it is used, but that shouldn't happen 142 * because a 3215 terminal won't accept a new read before the old one is 143 * completed. 144 */ 145 static void raw3215_mk_read_req(struct raw3215_info *raw) 146 { 147 struct raw3215_req *req; 148 struct ccw1 *ccw; 149 150 /* there can only be ONE read request at a time */ 151 req = raw->queued_read; 152 if (req == NULL) { 153 /* no queued read request, use new req structure */ 154 req = raw3215_alloc_req(); 155 req->type = RAW3215_READ; 156 req->info = raw; 157 raw->queued_read = req; 158 } 159 160 ccw = req->ccws; 161 ccw->cmd_code = 0x0A; /* read inquiry */ 162 ccw->flags = 0x20; /* ignore incorrect length */ 163 ccw->count = 160; 164 ccw->cda = (__u32) __pa(raw->inbuf); 165 } 166 167 /* 168 * Set up a write request with the information from the main structure. 169 * A ccw chain is created that writes as much as possible from the output 170 * buffer to the 3215 device. If a queued write exists it is replaced by 171 * the new, probably lengthened request. 172 */ 173 static void raw3215_mk_write_req(struct raw3215_info *raw) 174 { 175 struct raw3215_req *req; 176 struct ccw1 *ccw; 177 int len, count, ix, lines; 178 179 if (raw->count <= raw->written) 180 return; 181 /* check if there is a queued write request */ 182 req = raw->queued_write; 183 if (req == NULL) { 184 /* no queued write request, use new req structure */ 185 req = raw3215_alloc_req(); 186 req->type = RAW3215_WRITE; 187 req->info = raw; 188 raw->queued_write = req; 189 } else { 190 raw->written -= req->len; 191 } 192 193 ccw = req->ccws; 194 req->start = (raw->head - raw->count + raw->written) & 195 (RAW3215_BUFFER_SIZE - 1); 196 /* 197 * now we have to count newlines. We can at max accept 198 * RAW3215_MAX_NEWLINE newlines in a single ssch due to 199 * a restriction in VM 200 */ 201 lines = 0; 202 ix = req->start; 203 while (lines < RAW3215_MAX_NEWLINE && ix != raw->head) { 204 if (raw->buffer[ix] == 0x15) 205 lines++; 206 ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1); 207 } 208 len = ((ix - 1 - req->start) & (RAW3215_BUFFER_SIZE - 1)) + 1; 209 if (len > RAW3215_MAX_BYTES) 210 len = RAW3215_MAX_BYTES; 211 req->len = len; 212 raw->written += len; 213 214 /* set the indication if we should try to enlarge this request */ 215 req->delayable = (ix == raw->head) && (len < RAW3215_MIN_WRITE); 216 217 ix = req->start; 218 while (len > 0) { 219 if (ccw > req->ccws) 220 ccw[-1].flags |= 0x40; /* use command chaining */ 221 ccw->cmd_code = 0x01; /* write, auto carrier return */ 222 ccw->flags = 0x20; /* ignore incorrect length ind. */ 223 ccw->cda = 224 (__u32) __pa(raw->buffer + ix); 225 count = len; 226 if (ix + count > RAW3215_BUFFER_SIZE) 227 count = RAW3215_BUFFER_SIZE - ix; 228 ccw->count = count; 229 len -= count; 230 ix = (ix + count) & (RAW3215_BUFFER_SIZE - 1); 231 ccw++; 232 } 233 /* 234 * Add a NOP to the channel program. 3215 devices are purely 235 * emulated and its much better to avoid the channel end 236 * interrupt in this case. 237 */ 238 if (ccw > req->ccws) 239 ccw[-1].flags |= 0x40; /* use command chaining */ 240 ccw->cmd_code = 0x03; /* NOP */ 241 ccw->flags = 0; 242 ccw->cda = 0; 243 ccw->count = 1; 244 } 245 246 /* 247 * Start a read or a write request 248 */ 249 static void raw3215_start_io(struct raw3215_info *raw) 250 { 251 struct raw3215_req *req; 252 int res; 253 254 req = raw->queued_read; 255 if (req != NULL && 256 !(raw->flags & (RAW3215_WORKING | RAW3215_THROTTLED))) { 257 /* dequeue request */ 258 raw->queued_read = NULL; 259 res = ccw_device_start(raw->cdev, req->ccws, 260 (unsigned long) req, 0, 0); 261 if (res != 0) { 262 /* do_IO failed, put request back to queue */ 263 raw->queued_read = req; 264 } else { 265 raw->flags |= RAW3215_WORKING; 266 } 267 } 268 req = raw->queued_write; 269 if (req != NULL && 270 !(raw->flags & (RAW3215_WORKING | RAW3215_STOPPED))) { 271 /* dequeue request */ 272 raw->queued_write = NULL; 273 res = ccw_device_start(raw->cdev, req->ccws, 274 (unsigned long) req, 0, 0); 275 if (res != 0) { 276 /* do_IO failed, put request back to queue */ 277 raw->queued_write = req; 278 } else { 279 raw->flags |= RAW3215_WORKING; 280 } 281 } 282 } 283 284 /* 285 * Function to start a delayed output after RAW3215_TIMEOUT seconds 286 */ 287 static void raw3215_timeout(unsigned long __data) 288 { 289 struct raw3215_info *raw = (struct raw3215_info *) __data; 290 unsigned long flags; 291 292 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 293 if (raw->flags & RAW3215_TIMER_RUNS) { 294 del_timer(&raw->timer); 295 raw->flags &= ~RAW3215_TIMER_RUNS; 296 if (!(raw->flags & RAW3215_FROZEN)) { 297 raw3215_mk_write_req(raw); 298 raw3215_start_io(raw); 299 } 300 } 301 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 302 } 303 304 /* 305 * Function to conditionally start an IO. A read is started immediately, 306 * a write is only started immediately if the flush flag is on or the 307 * amount of data is bigger than RAW3215_MIN_WRITE. If a write is not 308 * done immediately a timer is started with a delay of RAW3215_TIMEOUT. 309 */ 310 static inline void raw3215_try_io(struct raw3215_info *raw) 311 { 312 if (!(raw->flags & RAW3215_ACTIVE) || (raw->flags & RAW3215_FROZEN)) 313 return; 314 if (raw->queued_read != NULL) 315 raw3215_start_io(raw); 316 else if (raw->queued_write != NULL) { 317 if ((raw->queued_write->delayable == 0) || 318 (raw->flags & RAW3215_FLUSHING)) { 319 /* execute write requests bigger than minimum size */ 320 raw3215_start_io(raw); 321 if (raw->flags & RAW3215_TIMER_RUNS) { 322 del_timer(&raw->timer); 323 raw->flags &= ~RAW3215_TIMER_RUNS; 324 } 325 } else if (!(raw->flags & RAW3215_TIMER_RUNS)) { 326 /* delay small writes */ 327 init_timer(&raw->timer); 328 raw->timer.expires = RAW3215_TIMEOUT + jiffies; 329 raw->timer.data = (unsigned long) raw; 330 raw->timer.function = raw3215_timeout; 331 add_timer(&raw->timer); 332 raw->flags |= RAW3215_TIMER_RUNS; 333 } 334 } 335 } 336 337 /* 338 * Call tty_wakeup from tasklet context 339 */ 340 static void raw3215_wakeup(unsigned long data) 341 { 342 struct raw3215_info *raw = (struct raw3215_info *) data; 343 tty_wakeup(raw->tty); 344 } 345 346 /* 347 * Try to start the next IO and wake up processes waiting on the tty. 348 */ 349 static void raw3215_next_io(struct raw3215_info *raw) 350 { 351 raw3215_mk_write_req(raw); 352 raw3215_try_io(raw); 353 if (raw->tty && RAW3215_BUFFER_SIZE - raw->count >= RAW3215_MIN_SPACE) 354 tasklet_schedule(&raw->tlet); 355 } 356 357 /* 358 * Interrupt routine, called from common io layer 359 */ 360 static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm, 361 struct irb *irb) 362 { 363 struct raw3215_info *raw; 364 struct raw3215_req *req; 365 struct tty_struct *tty; 366 int cstat, dstat; 367 int count; 368 369 raw = dev_get_drvdata(&cdev->dev); 370 req = (struct raw3215_req *) intparm; 371 cstat = irb->scsw.cmd.cstat; 372 dstat = irb->scsw.cmd.dstat; 373 if (cstat != 0) 374 raw3215_next_io(raw); 375 if (dstat & 0x01) { /* we got a unit exception */ 376 dstat &= ~0x01; /* we can ignore it */ 377 } 378 switch (dstat) { 379 case 0x80: 380 if (cstat != 0) 381 break; 382 /* Attention interrupt, someone hit the enter key */ 383 raw3215_mk_read_req(raw); 384 raw3215_next_io(raw); 385 break; 386 case 0x08: 387 case 0x0C: 388 /* Channel end interrupt. */ 389 if ((raw = req->info) == NULL) 390 return; /* That shouldn't happen ... */ 391 if (req->type == RAW3215_READ) { 392 /* store residual count, then wait for device end */ 393 req->residual = irb->scsw.cmd.count; 394 } 395 if (dstat == 0x08) 396 break; 397 case 0x04: 398 /* Device end interrupt. */ 399 if ((raw = req->info) == NULL) 400 return; /* That shouldn't happen ... */ 401 if (req->type == RAW3215_READ && raw->tty != NULL) { 402 unsigned int cchar; 403 404 tty = raw->tty; 405 count = 160 - req->residual; 406 EBCASC(raw->inbuf, count); 407 cchar = ctrlchar_handle(raw->inbuf, count, tty); 408 switch (cchar & CTRLCHAR_MASK) { 409 case CTRLCHAR_SYSRQ: 410 break; 411 412 case CTRLCHAR_CTRL: 413 tty_insert_flip_char(tty, cchar, TTY_NORMAL); 414 tty_flip_buffer_push(raw->tty); 415 break; 416 417 case CTRLCHAR_NONE: 418 if (count < 2 || 419 (strncmp(raw->inbuf+count-2, "\252n", 2) && 420 strncmp(raw->inbuf+count-2, "^n", 2)) ) { 421 /* add the auto \n */ 422 raw->inbuf[count] = '\n'; 423 count++; 424 } else 425 count -= 2; 426 tty_insert_flip_string(tty, raw->inbuf, count); 427 tty_flip_buffer_push(raw->tty); 428 break; 429 } 430 } else if (req->type == RAW3215_WRITE) { 431 raw->count -= req->len; 432 raw->written -= req->len; 433 } 434 raw->flags &= ~RAW3215_WORKING; 435 raw3215_free_req(req); 436 /* check for empty wait */ 437 if (waitqueue_active(&raw->empty_wait) && 438 raw->queued_write == NULL && 439 raw->queued_read == NULL) { 440 wake_up_interruptible(&raw->empty_wait); 441 } 442 raw3215_next_io(raw); 443 break; 444 default: 445 /* Strange interrupt, I'll do my best to clean up */ 446 if (req != NULL && req->type != RAW3215_FREE) { 447 if (req->type == RAW3215_WRITE) { 448 raw->count -= req->len; 449 raw->written -= req->len; 450 } 451 raw->flags &= ~RAW3215_WORKING; 452 raw3215_free_req(req); 453 } 454 raw3215_next_io(raw); 455 } 456 return; 457 } 458 459 /* 460 * Drop the oldest line from the output buffer. 461 */ 462 static void raw3215_drop_line(struct raw3215_info *raw) 463 { 464 int ix; 465 char ch; 466 467 BUG_ON(raw->written != 0); 468 ix = (raw->head - raw->count) & (RAW3215_BUFFER_SIZE - 1); 469 while (raw->count > 0) { 470 ch = raw->buffer[ix]; 471 ix = (ix + 1) & (RAW3215_BUFFER_SIZE - 1); 472 raw->count--; 473 if (ch == 0x15) 474 break; 475 } 476 raw->head = ix; 477 } 478 479 /* 480 * Wait until length bytes are available int the output buffer. 481 * Has to be called with the s390irq lock held. Can be called 482 * disabled. 483 */ 484 static void raw3215_make_room(struct raw3215_info *raw, unsigned int length) 485 { 486 while (RAW3215_BUFFER_SIZE - raw->count < length) { 487 /* While console is frozen for suspend we have no other 488 * choice but to drop message from the buffer to make 489 * room for even more messages. */ 490 if (raw->flags & RAW3215_FROZEN) { 491 raw3215_drop_line(raw); 492 continue; 493 } 494 /* there might be a request pending */ 495 raw->flags |= RAW3215_FLUSHING; 496 raw3215_mk_write_req(raw); 497 raw3215_try_io(raw); 498 raw->flags &= ~RAW3215_FLUSHING; 499 #ifdef CONFIG_TN3215_CONSOLE 500 wait_cons_dev(); 501 #endif 502 /* Enough room freed up ? */ 503 if (RAW3215_BUFFER_SIZE - raw->count >= length) 504 break; 505 /* there might be another cpu waiting for the lock */ 506 spin_unlock(get_ccwdev_lock(raw->cdev)); 507 udelay(100); 508 spin_lock(get_ccwdev_lock(raw->cdev)); 509 } 510 } 511 512 /* 513 * String write routine for 3215 devices 514 */ 515 static void raw3215_write(struct raw3215_info *raw, const char *str, 516 unsigned int length) 517 { 518 unsigned long flags; 519 int c, count; 520 521 while (length > 0) { 522 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 523 count = (length > RAW3215_BUFFER_SIZE) ? 524 RAW3215_BUFFER_SIZE : length; 525 length -= count; 526 527 raw3215_make_room(raw, count); 528 529 /* copy string to output buffer and convert it to EBCDIC */ 530 while (1) { 531 c = min_t(int, count, 532 min(RAW3215_BUFFER_SIZE - raw->count, 533 RAW3215_BUFFER_SIZE - raw->head)); 534 if (c <= 0) 535 break; 536 memcpy(raw->buffer + raw->head, str, c); 537 ASCEBC(raw->buffer + raw->head, c); 538 raw->head = (raw->head + c) & (RAW3215_BUFFER_SIZE - 1); 539 raw->count += c; 540 raw->line_pos += c; 541 str += c; 542 count -= c; 543 } 544 if (!(raw->flags & RAW3215_WORKING)) { 545 raw3215_mk_write_req(raw); 546 /* start or queue request */ 547 raw3215_try_io(raw); 548 } 549 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 550 } 551 } 552 553 /* 554 * Put character routine for 3215 devices 555 */ 556 static void raw3215_putchar(struct raw3215_info *raw, unsigned char ch) 557 { 558 unsigned long flags; 559 unsigned int length, i; 560 561 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 562 if (ch == '\t') { 563 length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE); 564 raw->line_pos += length; 565 ch = ' '; 566 } else if (ch == '\n') { 567 length = 1; 568 raw->line_pos = 0; 569 } else { 570 length = 1; 571 raw->line_pos++; 572 } 573 raw3215_make_room(raw, length); 574 575 for (i = 0; i < length; i++) { 576 raw->buffer[raw->head] = (char) _ascebc[(int) ch]; 577 raw->head = (raw->head + 1) & (RAW3215_BUFFER_SIZE - 1); 578 raw->count++; 579 } 580 if (!(raw->flags & RAW3215_WORKING)) { 581 raw3215_mk_write_req(raw); 582 /* start or queue request */ 583 raw3215_try_io(raw); 584 } 585 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 586 } 587 588 /* 589 * Flush routine, it simply sets the flush flag and tries to start 590 * pending IO. 591 */ 592 static void raw3215_flush_buffer(struct raw3215_info *raw) 593 { 594 unsigned long flags; 595 596 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 597 if (raw->count > 0) { 598 raw->flags |= RAW3215_FLUSHING; 599 raw3215_try_io(raw); 600 raw->flags &= ~RAW3215_FLUSHING; 601 } 602 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 603 } 604 605 /* 606 * Fire up a 3215 device. 607 */ 608 static int raw3215_startup(struct raw3215_info *raw) 609 { 610 unsigned long flags; 611 612 if (raw->flags & RAW3215_ACTIVE) 613 return 0; 614 raw->line_pos = 0; 615 raw->flags |= RAW3215_ACTIVE; 616 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 617 raw3215_try_io(raw); 618 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 619 620 return 0; 621 } 622 623 /* 624 * Shutdown a 3215 device. 625 */ 626 static void raw3215_shutdown(struct raw3215_info *raw) 627 { 628 DECLARE_WAITQUEUE(wait, current); 629 unsigned long flags; 630 631 if (!(raw->flags & RAW3215_ACTIVE) || (raw->flags & RAW3215_FIXED)) 632 return; 633 /* Wait for outstanding requests, then free irq */ 634 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 635 if ((raw->flags & RAW3215_WORKING) || 636 raw->queued_write != NULL || 637 raw->queued_read != NULL) { 638 raw->flags |= RAW3215_CLOSING; 639 add_wait_queue(&raw->empty_wait, &wait); 640 set_current_state(TASK_INTERRUPTIBLE); 641 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 642 schedule(); 643 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 644 remove_wait_queue(&raw->empty_wait, &wait); 645 set_current_state(TASK_RUNNING); 646 raw->flags &= ~(RAW3215_ACTIVE | RAW3215_CLOSING); 647 } 648 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 649 } 650 651 static int raw3215_probe (struct ccw_device *cdev) 652 { 653 struct raw3215_info *raw; 654 int line; 655 656 /* Console is special. */ 657 if (raw3215[0] && (raw3215[0] == dev_get_drvdata(&cdev->dev))) 658 return 0; 659 raw = kmalloc(sizeof(struct raw3215_info) + 660 RAW3215_INBUF_SIZE, GFP_KERNEL|GFP_DMA); 661 if (raw == NULL) 662 return -ENOMEM; 663 664 spin_lock(&raw3215_device_lock); 665 for (line = 0; line < NR_3215; line++) { 666 if (!raw3215[line]) { 667 raw3215[line] = raw; 668 break; 669 } 670 } 671 spin_unlock(&raw3215_device_lock); 672 if (line == NR_3215) { 673 kfree(raw); 674 return -ENODEV; 675 } 676 677 raw->cdev = cdev; 678 raw->inbuf = (char *) raw + sizeof(struct raw3215_info); 679 memset(raw, 0, sizeof(struct raw3215_info)); 680 raw->buffer = kmalloc(RAW3215_BUFFER_SIZE, 681 GFP_KERNEL|GFP_DMA); 682 if (raw->buffer == NULL) { 683 spin_lock(&raw3215_device_lock); 684 raw3215[line] = NULL; 685 spin_unlock(&raw3215_device_lock); 686 kfree(raw); 687 return -ENOMEM; 688 } 689 init_waitqueue_head(&raw->empty_wait); 690 tasklet_init(&raw->tlet, raw3215_wakeup, (unsigned long) raw); 691 692 dev_set_drvdata(&cdev->dev, raw); 693 cdev->handler = raw3215_irq; 694 695 return 0; 696 } 697 698 static void raw3215_remove (struct ccw_device *cdev) 699 { 700 struct raw3215_info *raw; 701 702 ccw_device_set_offline(cdev); 703 raw = dev_get_drvdata(&cdev->dev); 704 if (raw) { 705 dev_set_drvdata(&cdev->dev, NULL); 706 kfree(raw->buffer); 707 kfree(raw); 708 } 709 } 710 711 static int raw3215_set_online (struct ccw_device *cdev) 712 { 713 struct raw3215_info *raw; 714 715 raw = dev_get_drvdata(&cdev->dev); 716 if (!raw) 717 return -ENODEV; 718 719 return raw3215_startup(raw); 720 } 721 722 static int raw3215_set_offline (struct ccw_device *cdev) 723 { 724 struct raw3215_info *raw; 725 726 raw = dev_get_drvdata(&cdev->dev); 727 if (!raw) 728 return -ENODEV; 729 730 raw3215_shutdown(raw); 731 732 return 0; 733 } 734 735 static int raw3215_pm_stop(struct ccw_device *cdev) 736 { 737 struct raw3215_info *raw; 738 unsigned long flags; 739 740 /* Empty the output buffer, then prevent new I/O. */ 741 raw = dev_get_drvdata(&cdev->dev); 742 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 743 raw3215_make_room(raw, RAW3215_BUFFER_SIZE); 744 raw->flags |= RAW3215_FROZEN; 745 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 746 return 0; 747 } 748 749 static int raw3215_pm_start(struct ccw_device *cdev) 750 { 751 struct raw3215_info *raw; 752 unsigned long flags; 753 754 /* Allow I/O again and flush output buffer. */ 755 raw = dev_get_drvdata(&cdev->dev); 756 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 757 raw->flags &= ~RAW3215_FROZEN; 758 raw->flags |= RAW3215_FLUSHING; 759 raw3215_try_io(raw); 760 raw->flags &= ~RAW3215_FLUSHING; 761 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 762 return 0; 763 } 764 765 static struct ccw_device_id raw3215_id[] = { 766 { CCW_DEVICE(0x3215, 0) }, 767 { /* end of list */ }, 768 }; 769 770 static struct ccw_driver raw3215_ccw_driver = { 771 .driver = { 772 .name = "3215", 773 .owner = THIS_MODULE, 774 }, 775 .ids = raw3215_id, 776 .probe = &raw3215_probe, 777 .remove = &raw3215_remove, 778 .set_online = &raw3215_set_online, 779 .set_offline = &raw3215_set_offline, 780 .freeze = &raw3215_pm_stop, 781 .thaw = &raw3215_pm_start, 782 .restore = &raw3215_pm_start, 783 .int_class = IOINT_C15, 784 }; 785 786 #ifdef CONFIG_TN3215_CONSOLE 787 /* 788 * Write a string to the 3215 console 789 */ 790 static void con3215_write(struct console *co, const char *str, 791 unsigned int count) 792 { 793 struct raw3215_info *raw; 794 int i; 795 796 if (count <= 0) 797 return; 798 raw = raw3215[0]; /* console 3215 is the first one */ 799 while (count > 0) { 800 for (i = 0; i < count; i++) 801 if (str[i] == '\t' || str[i] == '\n') 802 break; 803 raw3215_write(raw, str, i); 804 count -= i; 805 str += i; 806 if (count > 0) { 807 raw3215_putchar(raw, *str); 808 count--; 809 str++; 810 } 811 } 812 } 813 814 static struct tty_driver *con3215_device(struct console *c, int *index) 815 { 816 *index = c->index; 817 return tty3215_driver; 818 } 819 820 /* 821 * panic() calls con3215_flush through a panic_notifier 822 * before the system enters a disabled, endless loop. 823 */ 824 static void con3215_flush(void) 825 { 826 struct raw3215_info *raw; 827 unsigned long flags; 828 829 raw = raw3215[0]; /* console 3215 is the first one */ 830 if (raw->flags & RAW3215_FROZEN) 831 /* The console is still frozen for suspend. */ 832 if (ccw_device_force_console()) 833 /* Forcing didn't work, no panic message .. */ 834 return; 835 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 836 raw3215_make_room(raw, RAW3215_BUFFER_SIZE); 837 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 838 } 839 840 static int con3215_notify(struct notifier_block *self, 841 unsigned long event, void *data) 842 { 843 con3215_flush(); 844 return NOTIFY_OK; 845 } 846 847 static struct notifier_block on_panic_nb = { 848 .notifier_call = con3215_notify, 849 .priority = 0, 850 }; 851 852 static struct notifier_block on_reboot_nb = { 853 .notifier_call = con3215_notify, 854 .priority = 0, 855 }; 856 857 /* 858 * The console structure for the 3215 console 859 */ 860 static struct console con3215 = { 861 .name = "ttyS", 862 .write = con3215_write, 863 .device = con3215_device, 864 .flags = CON_PRINTBUFFER, 865 }; 866 867 /* 868 * 3215 console initialization code called from console_init(). 869 */ 870 static int __init con3215_init(void) 871 { 872 struct ccw_device *cdev; 873 struct raw3215_info *raw; 874 struct raw3215_req *req; 875 int i; 876 877 /* Check if 3215 is to be the console */ 878 if (!CONSOLE_IS_3215) 879 return -ENODEV; 880 881 /* Set the console mode for VM */ 882 if (MACHINE_IS_VM) { 883 cpcmd("TERM CONMODE 3215", NULL, 0, NULL); 884 cpcmd("TERM AUTOCR OFF", NULL, 0, NULL); 885 } 886 887 /* allocate 3215 request structures */ 888 raw3215_freelist = NULL; 889 spin_lock_init(&raw3215_freelist_lock); 890 for (i = 0; i < NR_3215_REQ; i++) { 891 req = kzalloc(sizeof(struct raw3215_req), GFP_KERNEL | GFP_DMA); 892 req->next = raw3215_freelist; 893 raw3215_freelist = req; 894 } 895 896 cdev = ccw_device_probe_console(); 897 if (IS_ERR(cdev)) 898 return -ENODEV; 899 900 raw3215[0] = raw = (struct raw3215_info *) 901 kzalloc(sizeof(struct raw3215_info), GFP_KERNEL | GFP_DMA); 902 raw->buffer = kzalloc(RAW3215_BUFFER_SIZE, GFP_KERNEL | GFP_DMA); 903 raw->inbuf = kzalloc(RAW3215_INBUF_SIZE, GFP_KERNEL | GFP_DMA); 904 raw->cdev = cdev; 905 dev_set_drvdata(&cdev->dev, raw); 906 cdev->handler = raw3215_irq; 907 908 raw->flags |= RAW3215_FIXED; 909 init_waitqueue_head(&raw->empty_wait); 910 tasklet_init(&raw->tlet, raw3215_wakeup, (unsigned long) raw); 911 912 /* Request the console irq */ 913 if (raw3215_startup(raw) != 0) { 914 kfree(raw->inbuf); 915 kfree(raw->buffer); 916 kfree(raw); 917 raw3215[0] = NULL; 918 return -ENODEV; 919 } 920 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb); 921 register_reboot_notifier(&on_reboot_nb); 922 register_console(&con3215); 923 return 0; 924 } 925 console_initcall(con3215_init); 926 #endif 927 928 /* 929 * tty3215_open 930 * 931 * This routine is called whenever a 3215 tty is opened. 932 */ 933 static int tty3215_open(struct tty_struct *tty, struct file * filp) 934 { 935 struct raw3215_info *raw; 936 int retval; 937 938 raw = raw3215[tty->index]; 939 if (raw == NULL) 940 return -ENODEV; 941 942 tty->driver_data = raw; 943 raw->tty = tty; 944 945 tty->low_latency = 0; /* don't use bottom half for pushing chars */ 946 /* 947 * Start up 3215 device 948 */ 949 retval = raw3215_startup(raw); 950 if (retval) 951 return retval; 952 953 return 0; 954 } 955 956 /* 957 * tty3215_close() 958 * 959 * This routine is called when the 3215 tty is closed. We wait 960 * for the remaining request to be completed. Then we clean up. 961 */ 962 static void tty3215_close(struct tty_struct *tty, struct file * filp) 963 { 964 struct raw3215_info *raw; 965 966 raw = (struct raw3215_info *) tty->driver_data; 967 if (raw == NULL || tty->count > 1) 968 return; 969 tty->closing = 1; 970 /* Shutdown the terminal */ 971 raw3215_shutdown(raw); 972 tasklet_kill(&raw->tlet); 973 tty->closing = 0; 974 raw->tty = NULL; 975 } 976 977 /* 978 * Returns the amount of free space in the output buffer. 979 */ 980 static int tty3215_write_room(struct tty_struct *tty) 981 { 982 struct raw3215_info *raw; 983 984 raw = (struct raw3215_info *) tty->driver_data; 985 986 /* Subtract TAB_STOP_SIZE to allow for a tab, 8 <<< 64K */ 987 if ((RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE) >= 0) 988 return RAW3215_BUFFER_SIZE - raw->count - TAB_STOP_SIZE; 989 else 990 return 0; 991 } 992 993 /* 994 * String write routine for 3215 ttys 995 */ 996 static int tty3215_write(struct tty_struct * tty, 997 const unsigned char *buf, int count) 998 { 999 struct raw3215_info *raw; 1000 1001 if (!tty) 1002 return 0; 1003 raw = (struct raw3215_info *) tty->driver_data; 1004 raw3215_write(raw, buf, count); 1005 return count; 1006 } 1007 1008 /* 1009 * Put character routine for 3215 ttys 1010 */ 1011 static int tty3215_put_char(struct tty_struct *tty, unsigned char ch) 1012 { 1013 struct raw3215_info *raw; 1014 1015 if (!tty) 1016 return 0; 1017 raw = (struct raw3215_info *) tty->driver_data; 1018 raw3215_putchar(raw, ch); 1019 return 1; 1020 } 1021 1022 static void tty3215_flush_chars(struct tty_struct *tty) 1023 { 1024 } 1025 1026 /* 1027 * Returns the number of characters in the output buffer 1028 */ 1029 static int tty3215_chars_in_buffer(struct tty_struct *tty) 1030 { 1031 struct raw3215_info *raw; 1032 1033 raw = (struct raw3215_info *) tty->driver_data; 1034 return raw->count; 1035 } 1036 1037 static void tty3215_flush_buffer(struct tty_struct *tty) 1038 { 1039 struct raw3215_info *raw; 1040 1041 raw = (struct raw3215_info *) tty->driver_data; 1042 raw3215_flush_buffer(raw); 1043 tty_wakeup(tty); 1044 } 1045 1046 /* 1047 * Disable reading from a 3215 tty 1048 */ 1049 static void tty3215_throttle(struct tty_struct * tty) 1050 { 1051 struct raw3215_info *raw; 1052 1053 raw = (struct raw3215_info *) tty->driver_data; 1054 raw->flags |= RAW3215_THROTTLED; 1055 } 1056 1057 /* 1058 * Enable reading from a 3215 tty 1059 */ 1060 static void tty3215_unthrottle(struct tty_struct * tty) 1061 { 1062 struct raw3215_info *raw; 1063 unsigned long flags; 1064 1065 raw = (struct raw3215_info *) tty->driver_data; 1066 if (raw->flags & RAW3215_THROTTLED) { 1067 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 1068 raw->flags &= ~RAW3215_THROTTLED; 1069 raw3215_try_io(raw); 1070 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 1071 } 1072 } 1073 1074 /* 1075 * Disable writing to a 3215 tty 1076 */ 1077 static void tty3215_stop(struct tty_struct *tty) 1078 { 1079 struct raw3215_info *raw; 1080 1081 raw = (struct raw3215_info *) tty->driver_data; 1082 raw->flags |= RAW3215_STOPPED; 1083 } 1084 1085 /* 1086 * Enable writing to a 3215 tty 1087 */ 1088 static void tty3215_start(struct tty_struct *tty) 1089 { 1090 struct raw3215_info *raw; 1091 unsigned long flags; 1092 1093 raw = (struct raw3215_info *) tty->driver_data; 1094 if (raw->flags & RAW3215_STOPPED) { 1095 spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags); 1096 raw->flags &= ~RAW3215_STOPPED; 1097 raw3215_try_io(raw); 1098 spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags); 1099 } 1100 } 1101 1102 static const struct tty_operations tty3215_ops = { 1103 .open = tty3215_open, 1104 .close = tty3215_close, 1105 .write = tty3215_write, 1106 .put_char = tty3215_put_char, 1107 .flush_chars = tty3215_flush_chars, 1108 .write_room = tty3215_write_room, 1109 .chars_in_buffer = tty3215_chars_in_buffer, 1110 .flush_buffer = tty3215_flush_buffer, 1111 .throttle = tty3215_throttle, 1112 .unthrottle = tty3215_unthrottle, 1113 .stop = tty3215_stop, 1114 .start = tty3215_start, 1115 }; 1116 1117 /* 1118 * 3215 tty registration code called from tty_init(). 1119 * Most kernel services (incl. kmalloc) are available at this poimt. 1120 */ 1121 static int __init tty3215_init(void) 1122 { 1123 struct tty_driver *driver; 1124 int ret; 1125 1126 if (!CONSOLE_IS_3215) 1127 return 0; 1128 1129 driver = alloc_tty_driver(NR_3215); 1130 if (!driver) 1131 return -ENOMEM; 1132 1133 ret = ccw_driver_register(&raw3215_ccw_driver); 1134 if (ret) { 1135 put_tty_driver(driver); 1136 return ret; 1137 } 1138 /* 1139 * Initialize the tty_driver structure 1140 * Entries in tty3215_driver that are NOT initialized: 1141 * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc 1142 */ 1143 1144 driver->driver_name = "tty3215"; 1145 driver->name = "ttyS"; 1146 driver->major = TTY_MAJOR; 1147 driver->minor_start = 64; 1148 driver->type = TTY_DRIVER_TYPE_SYSTEM; 1149 driver->subtype = SYSTEM_TYPE_TTY; 1150 driver->init_termios = tty_std_termios; 1151 driver->init_termios.c_iflag = IGNBRK | IGNPAR; 1152 driver->init_termios.c_oflag = ONLCR | XTABS; 1153 driver->init_termios.c_lflag = ISIG; 1154 driver->flags = TTY_DRIVER_REAL_RAW; 1155 tty_set_operations(driver, &tty3215_ops); 1156 ret = tty_register_driver(driver); 1157 if (ret) { 1158 put_tty_driver(driver); 1159 return ret; 1160 } 1161 tty3215_driver = driver; 1162 return 0; 1163 } 1164 1165 static void __exit tty3215_exit(void) 1166 { 1167 tty_unregister_driver(tty3215_driver); 1168 put_tty_driver(tty3215_driver); 1169 ccw_driver_unregister(&raw3215_ccw_driver); 1170 } 1171 1172 module_init(tty3215_init); 1173 module_exit(tty3215_exit); 1174