1 /* 2 * drivers/s390/char/raw3270.c 3 * IBM/3270 Driver - core functions. 4 * 5 * Author(s): 6 * Original 3270 Code for 2.4 written by Richard Hitt (UTS Global) 7 * Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com> 8 * -- Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation 9 */ 10 11 #include <linux/config.h> 12 #include <linux/bootmem.h> 13 #include <linux/module.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/interrupt.h> 17 #include <linux/list.h> 18 #include <linux/slab.h> 19 #include <linux/types.h> 20 #include <linux/wait.h> 21 22 #include <asm/ccwdev.h> 23 #include <asm/cio.h> 24 #include <asm/ebcdic.h> 25 26 #include "raw3270.h" 27 28 #include <linux/major.h> 29 #include <linux/kdev_t.h> 30 #include <linux/device.h> 31 32 struct class *class3270; 33 34 /* The main 3270 data structure. */ 35 struct raw3270 { 36 struct list_head list; 37 struct ccw_device *cdev; 38 int minor; 39 40 short model, rows, cols; 41 unsigned long flags; 42 43 struct list_head req_queue; /* Request queue. */ 44 struct list_head view_list; /* List of available views. */ 45 struct raw3270_view *view; /* Active view. */ 46 47 struct timer_list timer; /* Device timer. */ 48 49 unsigned char *ascebc; /* ascii -> ebcdic table */ 50 struct class_device *clttydev; /* 3270-class tty device ptr */ 51 struct class_device *cltubdev; /* 3270-class tub device ptr */ 52 }; 53 54 /* raw3270->flags */ 55 #define RAW3270_FLAGS_14BITADDR 0 /* 14-bit buffer addresses */ 56 #define RAW3270_FLAGS_BUSY 1 /* Device busy, leave it alone */ 57 #define RAW3270_FLAGS_ATTN 2 /* Device sent an ATTN interrupt */ 58 #define RAW3270_FLAGS_READY 4 /* Device is useable by views */ 59 #define RAW3270_FLAGS_CONSOLE 8 /* Device is the console. */ 60 61 /* Semaphore to protect global data of raw3270 (devices, views, etc). */ 62 static DECLARE_MUTEX(raw3270_sem); 63 64 /* List of 3270 devices. */ 65 static struct list_head raw3270_devices = LIST_HEAD_INIT(raw3270_devices); 66 67 /* 68 * Flag to indicate if the driver has been registered. Some operations 69 * like waiting for the end of i/o need to be done differently as long 70 * as the kernel is still starting up (console support). 71 */ 72 static int raw3270_registered; 73 74 /* Module parameters */ 75 static int tubxcorrect = 0; 76 module_param(tubxcorrect, bool, 0); 77 78 /* 79 * Wait queue for device init/delete, view delete. 80 */ 81 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue); 82 83 /* 84 * Encode array for 12 bit 3270 addresses. 85 */ 86 unsigned char raw3270_ebcgraf[64] = { 87 0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 88 0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 89 0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 90 0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 91 0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 92 0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 93 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 94 0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f 95 }; 96 97 void 98 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr) 99 { 100 if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) { 101 cp[0] = (addr >> 8) & 0x3f; 102 cp[1] = addr & 0xff; 103 } else { 104 cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f]; 105 cp[1] = raw3270_ebcgraf[addr & 0x3f]; 106 } 107 } 108 109 /* 110 * Allocate a new 3270 ccw request 111 */ 112 struct raw3270_request * 113 raw3270_request_alloc(size_t size) 114 { 115 struct raw3270_request *rq; 116 117 /* Allocate request structure */ 118 rq = kmalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA); 119 if (!rq) 120 return ERR_PTR(-ENOMEM); 121 memset(rq, 0, sizeof(struct raw3270_request)); 122 123 /* alloc output buffer. */ 124 if (size > 0) { 125 rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA); 126 if (!rq->buffer) { 127 kfree(rq); 128 return ERR_PTR(-ENOMEM); 129 } 130 } 131 rq->size = size; 132 INIT_LIST_HEAD(&rq->list); 133 134 /* 135 * Setup ccw. 136 */ 137 rq->ccw.cda = __pa(rq->buffer); 138 rq->ccw.flags = CCW_FLAG_SLI; 139 140 return rq; 141 } 142 143 #ifdef CONFIG_TN3270_CONSOLE 144 /* 145 * Allocate a new 3270 ccw request from bootmem. Only works very 146 * early in the boot process. Only con3270.c should be using this. 147 */ 148 struct raw3270_request * 149 raw3270_request_alloc_bootmem(size_t size) 150 { 151 struct raw3270_request *rq; 152 153 rq = alloc_bootmem_low(sizeof(struct raw3270)); 154 if (!rq) 155 return ERR_PTR(-ENOMEM); 156 memset(rq, 0, sizeof(struct raw3270_request)); 157 158 /* alloc output buffer. */ 159 if (size > 0) { 160 rq->buffer = alloc_bootmem_low(size); 161 if (!rq->buffer) { 162 free_bootmem((unsigned long) rq, 163 sizeof(struct raw3270)); 164 return ERR_PTR(-ENOMEM); 165 } 166 } 167 rq->size = size; 168 INIT_LIST_HEAD(&rq->list); 169 170 /* 171 * Setup ccw. 172 */ 173 rq->ccw.cda = __pa(rq->buffer); 174 rq->ccw.flags = CCW_FLAG_SLI; 175 176 return rq; 177 } 178 #endif 179 180 /* 181 * Free 3270 ccw request 182 */ 183 void 184 raw3270_request_free (struct raw3270_request *rq) 185 { 186 if (rq->buffer) 187 kfree(rq->buffer); 188 kfree(rq); 189 } 190 191 /* 192 * Reset request to initial state. 193 */ 194 void 195 raw3270_request_reset(struct raw3270_request *rq) 196 { 197 BUG_ON(!list_empty(&rq->list)); 198 rq->ccw.cmd_code = 0; 199 rq->ccw.count = 0; 200 rq->ccw.cda = __pa(rq->buffer); 201 rq->ccw.flags = CCW_FLAG_SLI; 202 rq->rescnt = 0; 203 rq->rc = 0; 204 } 205 206 /* 207 * Set command code to ccw of a request. 208 */ 209 void 210 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd) 211 { 212 rq->ccw.cmd_code = cmd; 213 } 214 215 /* 216 * Add data fragment to output buffer. 217 */ 218 int 219 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size) 220 { 221 if (size + rq->ccw.count > rq->size) 222 return -E2BIG; 223 memcpy(rq->buffer + rq->ccw.count, data, size); 224 rq->ccw.count += size; 225 return 0; 226 } 227 228 /* 229 * Set address/length pair to ccw of a request. 230 */ 231 void 232 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size) 233 { 234 rq->ccw.cda = __pa(data); 235 rq->ccw.count = size; 236 } 237 238 /* 239 * Set idal buffer to ccw of a request. 240 */ 241 void 242 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib) 243 { 244 rq->ccw.cda = __pa(ib->data); 245 rq->ccw.count = ib->size; 246 rq->ccw.flags |= CCW_FLAG_IDA; 247 } 248 249 /* 250 * Stop running ccw. 251 */ 252 static int 253 raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq) 254 { 255 int retries; 256 int rc; 257 258 if (raw3270_request_final(rq)) 259 return 0; 260 /* Check if interrupt has already been processed */ 261 for (retries = 0; retries < 5; retries++) { 262 if (retries < 2) 263 rc = ccw_device_halt(rp->cdev, (long) rq); 264 else 265 rc = ccw_device_clear(rp->cdev, (long) rq); 266 if (rc == 0) 267 break; /* termination successful */ 268 } 269 return rc; 270 } 271 272 static int 273 raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq) 274 { 275 unsigned long flags; 276 int rc; 277 278 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 279 rc = raw3270_halt_io_nolock(rp, rq); 280 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 281 return rc; 282 } 283 284 /* 285 * Add the request to the request queue, try to start it if the 286 * 3270 device is idle. Return without waiting for end of i/o. 287 */ 288 static int 289 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view, 290 struct raw3270_request *rq) 291 { 292 rq->view = view; 293 raw3270_get_view(view); 294 if (list_empty(&rp->req_queue) && 295 !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) { 296 /* No other requests are on the queue. Start this one. */ 297 rq->rc = ccw_device_start(rp->cdev, &rq->ccw, 298 (unsigned long) rq, 0, 0); 299 if (rq->rc) { 300 raw3270_put_view(view); 301 return rq->rc; 302 } 303 } 304 list_add_tail(&rq->list, &rp->req_queue); 305 return 0; 306 } 307 308 int 309 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq) 310 { 311 unsigned long flags; 312 struct raw3270 *rp; 313 int rc; 314 315 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags); 316 rp = view->dev; 317 if (!rp || rp->view != view) 318 rc = -EACCES; 319 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags)) 320 rc = -ENODEV; 321 else 322 rc = __raw3270_start(rp, view, rq); 323 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags); 324 return rc; 325 } 326 327 int 328 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq) 329 { 330 struct raw3270 *rp; 331 int rc; 332 333 rp = view->dev; 334 if (!rp || rp->view != view) 335 rc = -EACCES; 336 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags)) 337 rc = -ENODEV; 338 else 339 rc = __raw3270_start(rp, view, rq); 340 return rc; 341 } 342 343 int 344 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq) 345 { 346 struct raw3270 *rp; 347 348 rp = view->dev; 349 rq->view = view; 350 raw3270_get_view(view); 351 list_add_tail(&rq->list, &rp->req_queue); 352 return 0; 353 } 354 355 /* 356 * 3270 interrupt routine, called from the ccw_device layer 357 */ 358 static void 359 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb) 360 { 361 struct raw3270 *rp; 362 struct raw3270_view *view; 363 struct raw3270_request *rq; 364 int rc; 365 366 rp = (struct raw3270 *) cdev->dev.driver_data; 367 if (!rp) 368 return; 369 rq = (struct raw3270_request *) intparm; 370 view = rq ? rq->view : rp->view; 371 372 if (IS_ERR(irb)) 373 rc = RAW3270_IO_RETRY; 374 else if (irb->scsw.fctl & SCSW_FCTL_HALT_FUNC) { 375 rq->rc = -EIO; 376 rc = RAW3270_IO_DONE; 377 } else if (irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END | 378 DEV_STAT_UNIT_EXCEP)) { 379 /* Handle CE-DE-UE and subsequent UDE */ 380 set_bit(RAW3270_FLAGS_BUSY, &rp->flags); 381 rc = RAW3270_IO_BUSY; 382 } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) { 383 /* Wait for UDE if busy flag is set. */ 384 if (irb->scsw.dstat & DEV_STAT_DEV_END) { 385 clear_bit(RAW3270_FLAGS_BUSY, &rp->flags); 386 /* Got it, now retry. */ 387 rc = RAW3270_IO_RETRY; 388 } else 389 rc = RAW3270_IO_BUSY; 390 } else if (view) 391 rc = view->fn->intv(view, rq, irb); 392 else 393 rc = RAW3270_IO_DONE; 394 395 switch (rc) { 396 case RAW3270_IO_DONE: 397 break; 398 case RAW3270_IO_BUSY: 399 /* 400 * Intervention required by the operator. We have to wait 401 * for unsolicited device end. 402 */ 403 return; 404 case RAW3270_IO_RETRY: 405 if (!rq) 406 break; 407 rq->rc = ccw_device_start(rp->cdev, &rq->ccw, 408 (unsigned long) rq, 0, 0); 409 if (rq->rc == 0) 410 return; /* Sucessfully restarted. */ 411 break; 412 case RAW3270_IO_STOP: 413 if (!rq) 414 break; 415 raw3270_halt_io_nolock(rp, rq); 416 rq->rc = -EIO; 417 break; 418 default: 419 BUG(); 420 } 421 if (rq) { 422 BUG_ON(list_empty(&rq->list)); 423 /* The request completed, remove from queue and do callback. */ 424 list_del_init(&rq->list); 425 if (rq->callback) 426 rq->callback(rq, rq->callback_data); 427 /* Do put_device for get_device in raw3270_start. */ 428 raw3270_put_view(view); 429 } 430 /* 431 * Try to start each request on request queue until one is 432 * started successful. 433 */ 434 while (!list_empty(&rp->req_queue)) { 435 rq = list_entry(rp->req_queue.next,struct raw3270_request,list); 436 rq->rc = ccw_device_start(rp->cdev, &rq->ccw, 437 (unsigned long) rq, 0, 0); 438 if (rq->rc == 0) 439 break; 440 /* Start failed. Remove request and do callback. */ 441 list_del_init(&rq->list); 442 if (rq->callback) 443 rq->callback(rq, rq->callback_data); 444 /* Do put_device for get_device in raw3270_start. */ 445 raw3270_put_view(view); 446 } 447 } 448 449 /* 450 * Size sensing. 451 */ 452 453 struct raw3270_ua { /* Query Reply structure for Usable Area */ 454 struct { /* Usable Area Query Reply Base */ 455 short l; /* Length of this structured field */ 456 char sfid; /* 0x81 if Query Reply */ 457 char qcode; /* 0x81 if Usable Area */ 458 char flags0; 459 char flags1; 460 short w; /* Width of usable area */ 461 short h; /* Heigth of usavle area */ 462 char units; /* 0x00:in; 0x01:mm */ 463 int xr; 464 int yr; 465 char aw; 466 char ah; 467 short buffsz; /* Character buffer size, bytes */ 468 char xmin; 469 char ymin; 470 char xmax; 471 char ymax; 472 } __attribute__ ((packed)) uab; 473 struct { /* Alternate Usable Area Self-Defining Parameter */ 474 char l; /* Length of this Self-Defining Parm */ 475 char sdpid; /* 0x02 if Alternate Usable Area */ 476 char res; 477 char auaid; /* 0x01 is Id for the A U A */ 478 short wauai; /* Width of AUAi */ 479 short hauai; /* Height of AUAi */ 480 char auaunits; /* 0x00:in, 0x01:mm */ 481 int auaxr; 482 int auayr; 483 char awauai; 484 char ahauai; 485 } __attribute__ ((packed)) aua; 486 } __attribute__ ((packed)); 487 488 static unsigned char raw3270_init_data[256]; 489 static struct raw3270_request raw3270_init_request; 490 static struct diag210 raw3270_init_diag210; 491 static DECLARE_MUTEX(raw3270_init_sem); 492 493 static int 494 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq, 495 struct irb *irb) 496 { 497 /* 498 * Unit-Check Processing: 499 * Expect Command Reject or Intervention Required. 500 */ 501 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) { 502 /* Request finished abnormally. */ 503 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) { 504 set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags); 505 return RAW3270_IO_BUSY; 506 } 507 } 508 if (rq) { 509 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) { 510 if (irb->ecw[0] & SNS0_CMD_REJECT) 511 rq->rc = -EOPNOTSUPP; 512 else 513 rq->rc = -EIO; 514 } else 515 /* Request finished normally. Copy residual count. */ 516 rq->rescnt = irb->scsw.count; 517 } 518 if (irb->scsw.dstat & DEV_STAT_ATTENTION) { 519 set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags); 520 wake_up(&raw3270_wait_queue); 521 } 522 return RAW3270_IO_DONE; 523 } 524 525 static struct raw3270_fn raw3270_init_fn = { 526 .intv = raw3270_init_irq 527 }; 528 529 static struct raw3270_view raw3270_init_view = { 530 .fn = &raw3270_init_fn 531 }; 532 533 /* 534 * raw3270_wait/raw3270_wait_interruptible/__raw3270_wakeup 535 * Wait for end of request. The request must have been started 536 * with raw3270_start, rc = 0. The device lock may NOT have been 537 * released between calling raw3270_start and raw3270_wait. 538 */ 539 static void 540 raw3270_wake_init(struct raw3270_request *rq, void *data) 541 { 542 wake_up((wait_queue_head_t *) data); 543 } 544 545 /* 546 * Special wait function that can cope with console initialization. 547 */ 548 static int 549 raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view, 550 struct raw3270_request *rq) 551 { 552 unsigned long flags; 553 wait_queue_head_t wq; 554 int rc; 555 556 #ifdef CONFIG_TN3270_CONSOLE 557 if (raw3270_registered == 0) { 558 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags); 559 rq->callback = 0; 560 rc = __raw3270_start(rp, view, rq); 561 if (rc == 0) 562 while (!raw3270_request_final(rq)) { 563 wait_cons_dev(); 564 barrier(); 565 } 566 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags); 567 return rq->rc; 568 } 569 #endif 570 init_waitqueue_head(&wq); 571 rq->callback = raw3270_wake_init; 572 rq->callback_data = &wq; 573 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags); 574 rc = __raw3270_start(rp, view, rq); 575 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags); 576 if (rc) 577 return rc; 578 /* Now wait for the completion. */ 579 rc = wait_event_interruptible(wq, raw3270_request_final(rq)); 580 if (rc == -ERESTARTSYS) { /* Interrupted by a signal. */ 581 raw3270_halt_io(view->dev, rq); 582 /* No wait for the halt to complete. */ 583 wait_event(wq, raw3270_request_final(rq)); 584 return -ERESTARTSYS; 585 } 586 return rq->rc; 587 } 588 589 static int 590 __raw3270_size_device_vm(struct raw3270 *rp) 591 { 592 int rc, model; 593 594 raw3270_init_diag210.vrdcdvno = 595 _ccw_device_get_device_number(rp->cdev); 596 raw3270_init_diag210.vrdclen = sizeof(struct diag210); 597 rc = diag210(&raw3270_init_diag210); 598 if (rc) 599 return rc; 600 model = raw3270_init_diag210.vrdccrmd; 601 switch (model) { 602 case 2: 603 rp->model = model; 604 rp->rows = 24; 605 rp->cols = 80; 606 break; 607 case 3: 608 rp->model = model; 609 rp->rows = 32; 610 rp->cols = 80; 611 break; 612 case 4: 613 rp->model = model; 614 rp->rows = 43; 615 rp->cols = 80; 616 break; 617 case 5: 618 rp->model = model; 619 rp->rows = 27; 620 rp->cols = 132; 621 break; 622 default: 623 printk(KERN_WARNING "vrdccrmd is 0x%.8x\n", model); 624 rc = -EOPNOTSUPP; 625 break; 626 } 627 return rc; 628 } 629 630 static int 631 __raw3270_size_device(struct raw3270 *rp) 632 { 633 static const unsigned char wbuf[] = 634 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 }; 635 struct raw3270_ua *uap; 636 unsigned short count; 637 int rc; 638 639 /* 640 * To determine the size of the 3270 device we need to do: 641 * 1) send a 'read partition' data stream to the device 642 * 2) wait for the attn interrupt that preceeds the query reply 643 * 3) do a read modified to get the query reply 644 * To make things worse we have to cope with intervention 645 * required (3270 device switched to 'stand-by') and command 646 * rejects (old devices that can't do 'read partition'). 647 */ 648 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request)); 649 memset(raw3270_init_data, 0, sizeof(raw3270_init_data)); 650 /* Store 'read partition' data stream to raw3270_init_data */ 651 memcpy(raw3270_init_data, wbuf, sizeof(wbuf)); 652 INIT_LIST_HEAD(&raw3270_init_request.list); 653 raw3270_init_request.ccw.cmd_code = TC_WRITESF; 654 raw3270_init_request.ccw.flags = CCW_FLAG_SLI; 655 raw3270_init_request.ccw.count = sizeof(wbuf); 656 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data); 657 658 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request); 659 if (rc) 660 /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */ 661 return rc; 662 663 /* Wait for attention interrupt. */ 664 #ifdef CONFIG_TN3270_CONSOLE 665 if (raw3270_registered == 0) { 666 unsigned long flags; 667 668 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 669 while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags)) 670 wait_cons_dev(); 671 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 672 } else 673 #endif 674 rc = wait_event_interruptible(raw3270_wait_queue, 675 test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags)); 676 if (rc) 677 return rc; 678 679 /* 680 * The device accepted the 'read partition' command. Now 681 * set up a read ccw and issue it. 682 */ 683 raw3270_init_request.ccw.cmd_code = TC_READMOD; 684 raw3270_init_request.ccw.flags = CCW_FLAG_SLI; 685 raw3270_init_request.ccw.count = sizeof(raw3270_init_data); 686 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data); 687 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request); 688 if (rc) 689 return rc; 690 /* Got a Query Reply */ 691 count = sizeof(raw3270_init_data) - raw3270_init_request.rescnt; 692 uap = (struct raw3270_ua *) (raw3270_init_data + 1); 693 /* Paranoia check. */ 694 if (raw3270_init_data[0] != 0x88 || uap->uab.qcode != 0x81) 695 return -EOPNOTSUPP; 696 /* Copy rows/columns of default Usable Area */ 697 rp->rows = uap->uab.h; 698 rp->cols = uap->uab.w; 699 /* Check for 14 bit addressing */ 700 if ((uap->uab.flags0 & 0x0d) == 0x01) 701 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags); 702 /* Check for Alternate Usable Area */ 703 if (uap->uab.l == sizeof(struct raw3270_ua) && 704 uap->aua.sdpid == 0x02) { 705 rp->rows = uap->aua.hauai; 706 rp->cols = uap->aua.wauai; 707 } 708 return 0; 709 } 710 711 static int 712 raw3270_size_device(struct raw3270 *rp) 713 { 714 int rc; 715 716 down(&raw3270_init_sem); 717 rp->view = &raw3270_init_view; 718 raw3270_init_view.dev = rp; 719 if (MACHINE_IS_VM) 720 rc = __raw3270_size_device_vm(rp); 721 else 722 rc = __raw3270_size_device(rp); 723 raw3270_init_view.dev = 0; 724 rp->view = 0; 725 up(&raw3270_init_sem); 726 if (rc == 0) { /* Found something. */ 727 /* Try to find a model. */ 728 rp->model = 0; 729 if (rp->rows == 24 && rp->cols == 80) 730 rp->model = 2; 731 if (rp->rows == 32 && rp->cols == 80) 732 rp->model = 3; 733 if (rp->rows == 43 && rp->cols == 80) 734 rp->model = 4; 735 if (rp->rows == 27 && rp->cols == 132) 736 rp->model = 5; 737 } else { 738 /* Couldn't detect size. Use default model 2. */ 739 rp->model = 2; 740 rp->rows = 24; 741 rp->cols = 80; 742 return 0; 743 } 744 return rc; 745 } 746 747 static int 748 raw3270_reset_device(struct raw3270 *rp) 749 { 750 int rc; 751 752 down(&raw3270_init_sem); 753 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request)); 754 memset(raw3270_init_data, 0, sizeof(raw3270_init_data)); 755 /* Store reset data stream to raw3270_init_data/raw3270_init_request */ 756 raw3270_init_data[0] = TW_KR; 757 INIT_LIST_HEAD(&raw3270_init_request.list); 758 raw3270_init_request.ccw.cmd_code = TC_EWRITEA; 759 raw3270_init_request.ccw.flags = CCW_FLAG_SLI; 760 raw3270_init_request.ccw.count = 1; 761 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data); 762 rp->view = &raw3270_init_view; 763 raw3270_init_view.dev = rp; 764 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request); 765 raw3270_init_view.dev = 0; 766 rp->view = 0; 767 up(&raw3270_init_sem); 768 return rc; 769 } 770 771 int 772 raw3270_reset(struct raw3270_view *view) 773 { 774 struct raw3270 *rp; 775 int rc; 776 777 rp = view->dev; 778 if (!rp || rp->view != view) 779 rc = -EACCES; 780 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags)) 781 rc = -ENODEV; 782 else 783 rc = raw3270_reset_device(view->dev); 784 return rc; 785 } 786 787 /* 788 * Setup new 3270 device. 789 */ 790 static int 791 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc) 792 { 793 struct list_head *l; 794 struct raw3270 *tmp; 795 int minor; 796 797 memset(rp, 0, sizeof(struct raw3270)); 798 /* Copy ebcdic -> ascii translation table. */ 799 memcpy(ascebc, _ascebc, 256); 800 if (tubxcorrect) { 801 /* correct brackets and circumflex */ 802 ascebc['['] = 0xad; 803 ascebc[']'] = 0xbd; 804 ascebc['^'] = 0xb0; 805 } 806 rp->ascebc = ascebc; 807 808 /* Set defaults. */ 809 rp->rows = 24; 810 rp->cols = 80; 811 812 INIT_LIST_HEAD(&rp->req_queue); 813 INIT_LIST_HEAD(&rp->view_list); 814 815 /* 816 * Add device to list and find the smallest unused minor 817 * number for it. Note: there is no device with minor 0, 818 * see special case for fs3270.c:fs3270_open(). 819 */ 820 down(&raw3270_sem); 821 /* Keep the list sorted. */ 822 minor = RAW3270_FIRSTMINOR; 823 rp->minor = -1; 824 list_for_each(l, &raw3270_devices) { 825 tmp = list_entry(l, struct raw3270, list); 826 if (tmp->minor > minor) { 827 rp->minor = minor; 828 __list_add(&rp->list, l->prev, l); 829 break; 830 } 831 minor++; 832 } 833 if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) { 834 rp->minor = minor; 835 list_add_tail(&rp->list, &raw3270_devices); 836 } 837 up(&raw3270_sem); 838 /* No free minor number? Then give up. */ 839 if (rp->minor == -1) 840 return -EUSERS; 841 rp->cdev = cdev; 842 cdev->dev.driver_data = rp; 843 cdev->handler = raw3270_irq; 844 return 0; 845 } 846 847 #ifdef CONFIG_TN3270_CONSOLE 848 /* 849 * Setup 3270 device configured as console. 850 */ 851 struct raw3270 * 852 raw3270_setup_console(struct ccw_device *cdev) 853 { 854 struct raw3270 *rp; 855 char *ascebc; 856 int rc; 857 858 rp = (struct raw3270 *) alloc_bootmem(sizeof(struct raw3270)); 859 ascebc = (char *) alloc_bootmem(256); 860 rc = raw3270_setup_device(cdev, rp, ascebc); 861 if (rc) 862 return ERR_PTR(rc); 863 set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags); 864 rc = raw3270_reset_device(rp); 865 if (rc) 866 return ERR_PTR(rc); 867 rc = raw3270_size_device(rp); 868 if (rc) 869 return ERR_PTR(rc); 870 rc = raw3270_reset_device(rp); 871 if (rc) 872 return ERR_PTR(rc); 873 set_bit(RAW3270_FLAGS_READY, &rp->flags); 874 return rp; 875 } 876 877 void 878 raw3270_wait_cons_dev(struct raw3270 *rp) 879 { 880 unsigned long flags; 881 882 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 883 wait_cons_dev(); 884 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 885 } 886 887 #endif 888 889 /* 890 * Create a 3270 device structure. 891 */ 892 static struct raw3270 * 893 raw3270_create_device(struct ccw_device *cdev) 894 { 895 struct raw3270 *rp; 896 char *ascebc; 897 int rc; 898 899 rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL); 900 if (!rp) 901 return ERR_PTR(-ENOMEM); 902 ascebc = kmalloc(256, GFP_KERNEL); 903 if (!ascebc) { 904 kfree(rp); 905 return ERR_PTR(-ENOMEM); 906 } 907 rc = raw3270_setup_device(cdev, rp, ascebc); 908 if (rc) { 909 kfree(rp->ascebc); 910 kfree(rp); 911 rp = ERR_PTR(rc); 912 } 913 /* Get reference to ccw_device structure. */ 914 get_device(&cdev->dev); 915 return rp; 916 } 917 918 /* 919 * Activate a view. 920 */ 921 int 922 raw3270_activate_view(struct raw3270_view *view) 923 { 924 struct raw3270 *rp; 925 struct raw3270_view *oldview, *nv; 926 unsigned long flags; 927 int rc; 928 929 rp = view->dev; 930 if (!rp) 931 return -ENODEV; 932 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 933 if (rp->view == view) 934 rc = 0; 935 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags)) 936 rc = -ENODEV; 937 else { 938 oldview = 0; 939 if (rp->view) { 940 oldview = rp->view; 941 oldview->fn->deactivate(oldview); 942 } 943 rp->view = view; 944 rc = view->fn->activate(view); 945 if (rc) { 946 /* Didn't work. Try to reactivate the old view. */ 947 rp->view = oldview; 948 if (!oldview || oldview->fn->activate(oldview) != 0) { 949 /* Didn't work as well. Try any other view. */ 950 list_for_each_entry(nv, &rp->view_list, list) 951 if (nv != view && nv != oldview) { 952 rp->view = nv; 953 if (nv->fn->activate(nv) == 0) 954 break; 955 rp->view = 0; 956 } 957 } 958 } 959 } 960 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 961 return rc; 962 } 963 964 /* 965 * Deactivate current view. 966 */ 967 void 968 raw3270_deactivate_view(struct raw3270_view *view) 969 { 970 unsigned long flags; 971 struct raw3270 *rp; 972 973 rp = view->dev; 974 if (!rp) 975 return; 976 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 977 if (rp->view == view) { 978 view->fn->deactivate(view); 979 rp->view = 0; 980 /* Move deactivated view to end of list. */ 981 list_del_init(&view->list); 982 list_add_tail(&view->list, &rp->view_list); 983 /* Try to activate another view. */ 984 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) { 985 list_for_each_entry(view, &rp->view_list, list) { 986 rp->view = view; 987 if (view->fn->activate(view) == 0) 988 break; 989 rp->view = 0; 990 } 991 } 992 } 993 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 994 } 995 996 /* 997 * Add view to device with minor "minor". 998 */ 999 int 1000 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor) 1001 { 1002 unsigned long flags; 1003 struct raw3270 *rp; 1004 int rc; 1005 1006 if (minor <= 0) 1007 return -ENODEV; 1008 down(&raw3270_sem); 1009 rc = -ENODEV; 1010 list_for_each_entry(rp, &raw3270_devices, list) { 1011 if (rp->minor != minor) 1012 continue; 1013 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 1014 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) { 1015 atomic_set(&view->ref_count, 2); 1016 view->dev = rp; 1017 view->fn = fn; 1018 view->model = rp->model; 1019 view->rows = rp->rows; 1020 view->cols = rp->cols; 1021 view->ascebc = rp->ascebc; 1022 spin_lock_init(&view->lock); 1023 list_add(&view->list, &rp->view_list); 1024 rc = 0; 1025 } 1026 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 1027 break; 1028 } 1029 up(&raw3270_sem); 1030 return rc; 1031 } 1032 1033 /* 1034 * Find specific view of device with minor "minor". 1035 */ 1036 struct raw3270_view * 1037 raw3270_find_view(struct raw3270_fn *fn, int minor) 1038 { 1039 struct raw3270 *rp; 1040 struct raw3270_view *view, *tmp; 1041 unsigned long flags; 1042 1043 down(&raw3270_sem); 1044 view = ERR_PTR(-ENODEV); 1045 list_for_each_entry(rp, &raw3270_devices, list) { 1046 if (rp->minor != minor) 1047 continue; 1048 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 1049 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) { 1050 view = ERR_PTR(-ENOENT); 1051 list_for_each_entry(tmp, &rp->view_list, list) { 1052 if (tmp->fn == fn) { 1053 raw3270_get_view(tmp); 1054 view = tmp; 1055 break; 1056 } 1057 } 1058 } 1059 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 1060 break; 1061 } 1062 up(&raw3270_sem); 1063 return view; 1064 } 1065 1066 /* 1067 * Remove view from device and free view structure via call to view->fn->free. 1068 */ 1069 void 1070 raw3270_del_view(struct raw3270_view *view) 1071 { 1072 unsigned long flags; 1073 struct raw3270 *rp; 1074 struct raw3270_view *nv; 1075 1076 rp = view->dev; 1077 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags); 1078 if (rp->view == view) { 1079 view->fn->deactivate(view); 1080 rp->view = 0; 1081 } 1082 list_del_init(&view->list); 1083 if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags)) { 1084 /* Try to activate another view. */ 1085 list_for_each_entry(nv, &rp->view_list, list) { 1086 if (nv->fn->activate(nv) == 0) { 1087 rp->view = nv; 1088 break; 1089 } 1090 } 1091 } 1092 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags); 1093 /* Wait for reference counter to drop to zero. */ 1094 atomic_dec(&view->ref_count); 1095 wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0); 1096 if (view->fn->free) 1097 view->fn->free(view); 1098 } 1099 1100 /* 1101 * Remove a 3270 device structure. 1102 */ 1103 static void 1104 raw3270_delete_device(struct raw3270 *rp) 1105 { 1106 struct ccw_device *cdev; 1107 1108 /* Remove from device chain. */ 1109 down(&raw3270_sem); 1110 if (rp->clttydev) 1111 class_device_destroy(class3270, 1112 MKDEV(IBM_TTY3270_MAJOR, rp->minor)); 1113 if (rp->cltubdev) 1114 class_device_destroy(class3270, 1115 MKDEV(IBM_FS3270_MAJOR, rp->minor)); 1116 list_del_init(&rp->list); 1117 up(&raw3270_sem); 1118 1119 /* Disconnect from ccw_device. */ 1120 cdev = rp->cdev; 1121 rp->cdev = 0; 1122 cdev->dev.driver_data = 0; 1123 cdev->handler = 0; 1124 1125 /* Put ccw_device structure. */ 1126 put_device(&cdev->dev); 1127 1128 /* Now free raw3270 structure. */ 1129 kfree(rp->ascebc); 1130 kfree(rp); 1131 } 1132 1133 static int 1134 raw3270_probe (struct ccw_device *cdev) 1135 { 1136 return 0; 1137 } 1138 1139 /* 1140 * Additional attributes for a 3270 device 1141 */ 1142 static ssize_t 1143 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf) 1144 { 1145 return snprintf(buf, PAGE_SIZE, "%i\n", 1146 ((struct raw3270 *) dev->driver_data)->model); 1147 } 1148 static DEVICE_ATTR(model, 0444, raw3270_model_show, 0); 1149 1150 static ssize_t 1151 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf) 1152 { 1153 return snprintf(buf, PAGE_SIZE, "%i\n", 1154 ((struct raw3270 *) dev->driver_data)->rows); 1155 } 1156 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, 0); 1157 1158 static ssize_t 1159 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf) 1160 { 1161 return snprintf(buf, PAGE_SIZE, "%i\n", 1162 ((struct raw3270 *) dev->driver_data)->cols); 1163 } 1164 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, 0); 1165 1166 static struct attribute * raw3270_attrs[] = { 1167 &dev_attr_model.attr, 1168 &dev_attr_rows.attr, 1169 &dev_attr_columns.attr, 1170 NULL, 1171 }; 1172 1173 static struct attribute_group raw3270_attr_group = { 1174 .attrs = raw3270_attrs, 1175 }; 1176 1177 static void 1178 raw3270_create_attributes(struct raw3270 *rp) 1179 { 1180 //FIXME: check return code 1181 sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group); 1182 rp->clttydev = 1183 class_device_create(class3270, 1184 MKDEV(IBM_TTY3270_MAJOR, rp->minor), 1185 &rp->cdev->dev, "tty%s", 1186 rp->cdev->dev.bus_id); 1187 rp->cltubdev = 1188 class_device_create(class3270, 1189 MKDEV(IBM_FS3270_MAJOR, rp->minor), 1190 &rp->cdev->dev, "tub%s", 1191 rp->cdev->dev.bus_id); 1192 } 1193 1194 /* 1195 * Notifier for device addition/removal 1196 */ 1197 struct raw3270_notifier { 1198 struct list_head list; 1199 void (*notifier)(int, int); 1200 }; 1201 1202 static struct list_head raw3270_notifier = LIST_HEAD_INIT(raw3270_notifier); 1203 1204 int raw3270_register_notifier(void (*notifier)(int, int)) 1205 { 1206 struct raw3270_notifier *np; 1207 struct raw3270 *rp; 1208 1209 np = kmalloc(sizeof(struct raw3270_notifier), GFP_KERNEL); 1210 if (!np) 1211 return -ENOMEM; 1212 np->notifier = notifier; 1213 down(&raw3270_sem); 1214 list_add_tail(&np->list, &raw3270_notifier); 1215 list_for_each_entry(rp, &raw3270_devices, list) { 1216 get_device(&rp->cdev->dev); 1217 notifier(rp->minor, 1); 1218 } 1219 up(&raw3270_sem); 1220 return 0; 1221 } 1222 1223 void raw3270_unregister_notifier(void (*notifier)(int, int)) 1224 { 1225 struct raw3270_notifier *np; 1226 1227 down(&raw3270_sem); 1228 list_for_each_entry(np, &raw3270_notifier, list) 1229 if (np->notifier == notifier) { 1230 list_del(&np->list); 1231 kfree(np); 1232 break; 1233 } 1234 up(&raw3270_sem); 1235 } 1236 1237 /* 1238 * Set 3270 device online. 1239 */ 1240 static int 1241 raw3270_set_online (struct ccw_device *cdev) 1242 { 1243 struct raw3270 *rp; 1244 struct raw3270_notifier *np; 1245 int rc; 1246 1247 rp = raw3270_create_device(cdev); 1248 if (IS_ERR(rp)) 1249 return PTR_ERR(rp); 1250 rc = raw3270_reset_device(rp); 1251 if (rc) 1252 goto failure; 1253 rc = raw3270_size_device(rp); 1254 if (rc) 1255 goto failure; 1256 rc = raw3270_reset_device(rp); 1257 if (rc) 1258 goto failure; 1259 raw3270_create_attributes(rp); 1260 set_bit(RAW3270_FLAGS_READY, &rp->flags); 1261 down(&raw3270_sem); 1262 list_for_each_entry(np, &raw3270_notifier, list) 1263 np->notifier(rp->minor, 1); 1264 up(&raw3270_sem); 1265 return 0; 1266 1267 failure: 1268 raw3270_delete_device(rp); 1269 return rc; 1270 } 1271 1272 /* 1273 * Remove 3270 device structure. 1274 */ 1275 static void 1276 raw3270_remove (struct ccw_device *cdev) 1277 { 1278 unsigned long flags; 1279 struct raw3270 *rp; 1280 struct raw3270_view *v; 1281 struct raw3270_notifier *np; 1282 1283 rp = cdev->dev.driver_data; 1284 /* 1285 * _remove is the opposite of _probe; it's probe that 1286 * should set up rp. raw3270_remove gets entered for 1287 * devices even if they haven't been varied online. 1288 * Thus, rp may validly be NULL here. 1289 */ 1290 if (rp == NULL) 1291 return; 1292 clear_bit(RAW3270_FLAGS_READY, &rp->flags); 1293 1294 sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group); 1295 1296 /* Deactivate current view and remove all views. */ 1297 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 1298 if (rp->view) { 1299 rp->view->fn->deactivate(rp->view); 1300 rp->view = 0; 1301 } 1302 while (!list_empty(&rp->view_list)) { 1303 v = list_entry(rp->view_list.next, struct raw3270_view, list); 1304 if (v->fn->release) 1305 v->fn->release(v); 1306 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 1307 raw3270_del_view(v); 1308 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 1309 } 1310 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 1311 1312 down(&raw3270_sem); 1313 list_for_each_entry(np, &raw3270_notifier, list) 1314 np->notifier(rp->minor, 0); 1315 up(&raw3270_sem); 1316 1317 /* Reset 3270 device. */ 1318 raw3270_reset_device(rp); 1319 /* And finally remove it. */ 1320 raw3270_delete_device(rp); 1321 } 1322 1323 /* 1324 * Set 3270 device offline. 1325 */ 1326 static int 1327 raw3270_set_offline (struct ccw_device *cdev) 1328 { 1329 struct raw3270 *rp; 1330 1331 rp = cdev->dev.driver_data; 1332 if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) 1333 return -EBUSY; 1334 raw3270_remove(cdev); 1335 return 0; 1336 } 1337 1338 static struct ccw_device_id raw3270_id[] = { 1339 { CCW_DEVICE(0x3270, 0) }, 1340 { CCW_DEVICE(0x3271, 0) }, 1341 { CCW_DEVICE(0x3272, 0) }, 1342 { CCW_DEVICE(0x3273, 0) }, 1343 { CCW_DEVICE(0x3274, 0) }, 1344 { CCW_DEVICE(0x3275, 0) }, 1345 { CCW_DEVICE(0x3276, 0) }, 1346 { CCW_DEVICE(0x3277, 0) }, 1347 { CCW_DEVICE(0x3278, 0) }, 1348 { CCW_DEVICE(0x3279, 0) }, 1349 { CCW_DEVICE(0x3174, 0) }, 1350 { /* end of list */ }, 1351 }; 1352 1353 static struct ccw_driver raw3270_ccw_driver = { 1354 .name = "3270", 1355 .owner = THIS_MODULE, 1356 .ids = raw3270_id, 1357 .probe = &raw3270_probe, 1358 .remove = &raw3270_remove, 1359 .set_online = &raw3270_set_online, 1360 .set_offline = &raw3270_set_offline, 1361 }; 1362 1363 static int 1364 raw3270_init(void) 1365 { 1366 struct raw3270 *rp; 1367 int rc; 1368 1369 if (raw3270_registered) 1370 return 0; 1371 raw3270_registered = 1; 1372 rc = ccw_driver_register(&raw3270_ccw_driver); 1373 if (rc == 0) { 1374 /* Create attributes for early (= console) device. */ 1375 down(&raw3270_sem); 1376 class3270 = class_create(THIS_MODULE, "3270"); 1377 list_for_each_entry(rp, &raw3270_devices, list) { 1378 get_device(&rp->cdev->dev); 1379 raw3270_create_attributes(rp); 1380 } 1381 up(&raw3270_sem); 1382 } 1383 return rc; 1384 } 1385 1386 static void 1387 raw3270_exit(void) 1388 { 1389 ccw_driver_unregister(&raw3270_ccw_driver); 1390 class_destroy(class3270); 1391 } 1392 1393 MODULE_LICENSE("GPL"); 1394 1395 module_init(raw3270_init); 1396 module_exit(raw3270_exit); 1397 1398 EXPORT_SYMBOL(raw3270_request_alloc); 1399 EXPORT_SYMBOL(raw3270_request_free); 1400 EXPORT_SYMBOL(raw3270_request_reset); 1401 EXPORT_SYMBOL(raw3270_request_set_cmd); 1402 EXPORT_SYMBOL(raw3270_request_add_data); 1403 EXPORT_SYMBOL(raw3270_request_set_data); 1404 EXPORT_SYMBOL(raw3270_request_set_idal); 1405 EXPORT_SYMBOL(raw3270_buffer_address); 1406 EXPORT_SYMBOL(raw3270_add_view); 1407 EXPORT_SYMBOL(raw3270_del_view); 1408 EXPORT_SYMBOL(raw3270_find_view); 1409 EXPORT_SYMBOL(raw3270_activate_view); 1410 EXPORT_SYMBOL(raw3270_deactivate_view); 1411 EXPORT_SYMBOL(raw3270_start); 1412 EXPORT_SYMBOL(raw3270_start_locked); 1413 EXPORT_SYMBOL(raw3270_start_irq); 1414 EXPORT_SYMBOL(raw3270_reset); 1415 EXPORT_SYMBOL(raw3270_register_notifier); 1416 EXPORT_SYMBOL(raw3270_unregister_notifier); 1417 EXPORT_SYMBOL(raw3270_wait_queue); 1418