SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/s390/char/raw3270.c

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