drivers/s390/char/raw3270.c

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