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_view_active(struct raw3270_view *view)
 280 {
 281         struct raw3270 *rp = view->dev;
 282
 283         return rp && rp->view == view &&
 284                 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
 285 }
 286
 287 int
 288 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
 289 {
 290         unsigned long flags;
 291         struct raw3270 *rp;
 292         int rc;
 293
 294         spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
 295         rp = view->dev;
 296         if (!rp || rp->view != view ||
 297             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 298                 rc = -EACCES;
 299         else if (!raw3270_state_ready(rp))
 300                 rc = -EBUSY;
 301         else
 302                 rc =  __raw3270_start(rp, view, rq);
 303         spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
 304         return rc;
 305 }
 306
 307 int
 308 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
 309 {
 310         struct raw3270 *rp;
 311         int rc;
 312
 313         rp = view->dev;
 314         if (!rp || rp->view != view ||
 315             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 316                 rc = -EACCES;
 317         else if (!raw3270_state_ready(rp))
 318                 rc = -EBUSY;
 319         else
 320                 rc =  __raw3270_start(rp, view, rq);
 321         return rc;
 322 }
 323
 324 int
 325 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
 326 {
 327         struct raw3270 *rp;
 328
 329         rp = view->dev;
 330         rq->view = view;
 331         raw3270_get_view(view);
 332         list_add_tail(&rq->list, &rp->req_queue);
 333         return 0;
 334 }
 335
 336 /*
 337  * 3270 interrupt routine, called from the ccw_device layer
 338  */
 339 static void
 340 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
 341 {
 342         struct raw3270 *rp;
 343         struct raw3270_view *view;
 344         struct raw3270_request *rq;
 345         int rc;
 346
 347         rp = dev_get_drvdata(&cdev->dev);
 348         if (!rp)
 349                 return;
 350         rq = (struct raw3270_request *) intparm;
 351         view = rq ? rq->view : rp->view;
 352
 353         if (IS_ERR(irb))
 354                 rc = RAW3270_IO_RETRY;
 355         else if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
 356                 rq->rc = -EIO;
 357                 rc = RAW3270_IO_DONE;
 358         } else if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END |
 359                                            DEV_STAT_UNIT_EXCEP)) {
 360                 /* Handle CE-DE-UE and subsequent UDE */
 361                 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
 362                 rc = RAW3270_IO_BUSY;
 363         } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
 364                 /* Wait for UDE if busy flag is set. */
 365                 if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
 366                         clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
 367                         /* Got it, now retry. */
 368                         rc = RAW3270_IO_RETRY;
 369                 } else
 370                         rc = RAW3270_IO_BUSY;
 371         } else if (view)
 372                 rc = view->fn->intv(view, rq, irb);
 373         else
 374                 rc = RAW3270_IO_DONE;
 375
 376         switch (rc) {
 377         case RAW3270_IO_DONE:
 378                 break;
 379         case RAW3270_IO_BUSY:
 380                 /*
 381                  * Intervention required by the operator. We have to wait
 382                  * for unsolicited device end.
 383                  */
 384                 return;
 385         case RAW3270_IO_RETRY:
 386                 if (!rq)
 387                         break;
 388                 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
 389                                           (unsigned long) rq, 0, 0);
 390                 if (rq->rc == 0)
 391                         return; /* Successfully restarted. */
 392                 break;
 393         case RAW3270_IO_STOP:
 394                 if (!rq)
 395                         break;
 396                 __raw3270_halt_io(rp, rq);
 397                 rq->rc = -EIO;
 398                 break;
 399         default:
 400                 BUG();
 401         }
 402         if (rq) {
 403                 BUG_ON(list_empty(&rq->list));
 404                 /* The request completed, remove from queue and do callback. */
 405                 list_del_init(&rq->list);
 406                 if (rq->callback)
 407                         rq->callback(rq, rq->callback_data);
 408                 /* Do put_device for get_device in raw3270_start. */
 409                 raw3270_put_view(view);
 410         }
 411         /*
 412          * Try to start each request on request queue until one is
 413          * started successful.
 414          */
 415         while (!list_empty(&rp->req_queue)) {
 416                 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
 417                 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
 418                                           (unsigned long) rq, 0, 0);
 419                 if (rq->rc == 0)
 420                         break;
 421                 /* Start failed. Remove request and do callback. */
 422                 list_del_init(&rq->list);
 423                 if (rq->callback)
 424                         rq->callback(rq, rq->callback_data);
 425                 /* Do put_device for get_device in raw3270_start. */
 426                 raw3270_put_view(view);
 427         }
 428 }
 429
 430 /*
 431  * To determine the size of the 3270 device we need to do:
 432  * 1) send a 'read partition' data stream to the device
 433  * 2) wait for the attn interrupt that precedes the query reply
 434  * 3) do a read modified to get the query reply
 435  * To make things worse we have to cope with intervention
 436  * required (3270 device switched to 'stand-by') and command
 437  * rejects (old devices that can't do 'read partition').
 438  */
 439 struct raw3270_ua {     /* Query Reply structure for Usable Area */
 440         struct {        /* Usable Area Query Reply Base */
 441                 short l;        /* Length of this structured field */
 442                 char  sfid;     /* 0x81 if Query Reply */
 443                 char  qcode;    /* 0x81 if Usable Area */
 444                 char  flags0;
 445                 char  flags1;
 446                 short w;        /* Width of usable area */
 447                 short h;        /* Heigth of usavle area */
 448                 char  units;    /* 0x00:in; 0x01:mm */
 449                 int   xr;
 450                 int   yr;
 451                 char  aw;
 452                 char  ah;
 453                 short buffsz;   /* Character buffer size, bytes */
 454                 char  xmin;
 455                 char  ymin;
 456                 char  xmax;
 457                 char  ymax;
 458         } __attribute__ ((packed)) uab;
 459         struct {        /* Alternate Usable Area Self-Defining Parameter */
 460                 char  l;        /* Length of this Self-Defining Parm */
 461                 char  sdpid;    /* 0x02 if Alternate Usable Area */
 462                 char  res;
 463                 char  auaid;    /* 0x01 is Id for the A U A */
 464                 short wauai;    /* Width of AUAi */
 465                 short hauai;    /* Height of AUAi */
 466                 char  auaunits; /* 0x00:in, 0x01:mm */
 467                 int   auaxr;
 468                 int   auayr;
 469                 char  awauai;
 470                 char  ahauai;
 471         } __attribute__ ((packed)) aua;
 472 } __attribute__ ((packed));
 473
 474 static void
 475 raw3270_size_device_vm(struct raw3270 *rp)
 476 {
 477         int rc, model;
 478         struct ccw_dev_id dev_id;
 479         struct diag210 diag_data;
 480
 481         ccw_device_get_id(rp->cdev, &dev_id);
 482         diag_data.vrdcdvno = dev_id.devno;
 483         diag_data.vrdclen = sizeof(struct diag210);
 484         rc = diag210(&diag_data);
 485         model = diag_data.vrdccrmd;
 486         /* Use default model 2 if the size could not be detected */
 487         if (rc || model < 2 || model > 5)
 488                 model = 2;
 489         switch (model) {
 490         case 2:
 491                 rp->model = model;
 492                 rp->rows = 24;
 493                 rp->cols = 80;
 494                 break;
 495         case 3:
 496                 rp->model = model;
 497                 rp->rows = 32;
 498                 rp->cols = 80;
 499                 break;
 500         case 4:
 501                 rp->model = model;
 502                 rp->rows = 43;
 503                 rp->cols = 80;
 504                 break;
 505         case 5:
 506                 rp->model = model;
 507                 rp->rows = 27;
 508                 rp->cols = 132;
 509                 break;
 510         }
 511 }
 512
 513 static void
 514 raw3270_size_device(struct raw3270 *rp)
 515 {
 516         struct raw3270_ua *uap;
 517
 518         /* Got a Query Reply */
 519         uap = (struct raw3270_ua *) (rp->init_data + 1);
 520         /* Paranoia check. */
 521         if (rp->init_readmod.rc || rp->init_data[0] != 0x88 ||
 522             uap->uab.qcode != 0x81) {
 523                 /* Couldn't detect size. Use default model 2. */
 524                 rp->model = 2;
 525                 rp->rows = 24;
 526                 rp->cols = 80;
 527                 return;
 528         }
 529         /* Copy rows/columns of default Usable Area */
 530         rp->rows = uap->uab.h;
 531         rp->cols = uap->uab.w;
 532         /* Check for 14 bit addressing */
 533         if ((uap->uab.flags0 & 0x0d) == 0x01)
 534                 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
 535         /* Check for Alternate Usable Area */
 536         if (uap->uab.l == sizeof(struct raw3270_ua) &&
 537             uap->aua.sdpid == 0x02) {
 538                 rp->rows = uap->aua.hauai;
 539                 rp->cols = uap->aua.wauai;
 540         }
 541         /* Try to find a model. */
 542         rp->model = 0;
 543         if (rp->rows == 24 && rp->cols == 80)
 544                 rp->model = 2;
 545         if (rp->rows == 32 && rp->cols == 80)
 546                 rp->model = 3;
 547         if (rp->rows == 43 && rp->cols == 80)
 548                 rp->model = 4;
 549         if (rp->rows == 27 && rp->cols == 132)
 550                 rp->model = 5;
 551 }
 552
 553 static void
 554 raw3270_size_device_done(struct raw3270 *rp)
 555 {
 556         struct raw3270_view *view;
 557
 558         rp->view = NULL;
 559         rp->state = RAW3270_STATE_READY;
 560         /* Notify views about new size */
 561         list_for_each_entry(view, &rp->view_list, list)
 562                 if (view->fn->resize)
 563                         view->fn->resize(view, rp->model, rp->rows, rp->cols);
 564         /* Setup processing done, now activate a view */
 565         list_for_each_entry(view, &rp->view_list, list) {
 566                 rp->view = view;
 567                 if (view->fn->activate(view) == 0)
 568                         break;
 569                 rp->view = NULL;
 570         }
 571 }
 572
 573 static void
 574 raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
 575 {
 576         struct raw3270 *rp = rq->view->dev;
 577
 578         raw3270_size_device(rp);
 579         raw3270_size_device_done(rp);
 580 }
 581
 582 static void
 583 raw3270_read_modified(struct raw3270 *rp)
 584 {
 585         if (rp->state != RAW3270_STATE_W4ATTN)
 586                 return;
 587         /* Use 'read modified' to get the result of a read partition. */
 588         memset(&rp->init_readmod, 0, sizeof(rp->init_readmod));
 589         memset(&rp->init_data, 0, sizeof(rp->init_data));
 590         rp->init_readmod.ccw.cmd_code = TC_READMOD;
 591         rp->init_readmod.ccw.flags = CCW_FLAG_SLI;
 592         rp->init_readmod.ccw.count = sizeof(rp->init_data);
 593         rp->init_readmod.ccw.cda = (__u32) __pa(rp->init_data);
 594         rp->init_readmod.callback = raw3270_read_modified_cb;
 595         rp->state = RAW3270_STATE_READMOD;
 596         raw3270_start_irq(&rp->init_view, &rp->init_readmod);
 597 }
 598
 599 static void
 600 raw3270_writesf_readpart(struct raw3270 *rp)
 601 {
 602         static const unsigned char wbuf[] =
 603                 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
 604
 605         /* Store 'read partition' data stream to init_data */
 606         memset(&rp->init_readpart, 0, sizeof(rp->init_readpart));
 607         memset(&rp->init_data, 0, sizeof(rp->init_data));
 608         memcpy(&rp->init_data, wbuf, sizeof(wbuf));
 609         rp->init_readpart.ccw.cmd_code = TC_WRITESF;
 610         rp->init_readpart.ccw.flags = CCW_FLAG_SLI;
 611         rp->init_readpart.ccw.count = sizeof(wbuf);
 612         rp->init_readpart.ccw.cda = (__u32) __pa(&rp->init_data);
 613         rp->state = RAW3270_STATE_W4ATTN;
 614         raw3270_start_irq(&rp->init_view, &rp->init_readpart);
 615 }
 616
 617 /*
 618  * Device reset
 619  */
 620 static void
 621 raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
 622 {
 623         struct raw3270 *rp = rq->view->dev;
 624
 625         if (rp->state != RAW3270_STATE_RESET)
 626                 return;
 627         if (rq->rc) {
 628                 /* Reset command failed. */
 629                 rp->state = RAW3270_STATE_INIT;
 630         } else if (MACHINE_IS_VM) {
 631                 raw3270_size_device_vm(rp);
 632                 raw3270_size_device_done(rp);
 633         } else
 634                 raw3270_writesf_readpart(rp);
 635         memset(&rp->init_reset, 0, sizeof(rp->init_reset));
 636         memset(&rp->init_data, 0, sizeof(rp->init_data));
 637 }
 638
 639 static int
 640 __raw3270_reset_device(struct raw3270 *rp)
 641 {
 642         int rc;
 643
 644         /* Check if reset is already pending */
 645         if (rp->init_reset.view)
 646                 return -EBUSY;
 647         /* Store reset data stream to init_data/init_reset */
 648         rp->init_data[0] = TW_KR;
 649         rp->init_reset.ccw.cmd_code = TC_EWRITEA;
 650         rp->init_reset.ccw.flags = CCW_FLAG_SLI;
 651         rp->init_reset.ccw.count = 1;
 652         rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
 653         rp->init_reset.callback = raw3270_reset_device_cb;
 654         rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
 655         if (rc == 0 && rp->state == RAW3270_STATE_INIT)
 656                 rp->state = RAW3270_STATE_RESET;
 657         return rc;
 658 }
 659
 660 static int
 661 raw3270_reset_device(struct raw3270 *rp)
 662 {
 663         unsigned long flags;
 664         int rc;
 665
 666         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 667         rc = __raw3270_reset_device(rp);
 668         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 669         return rc;
 670 }
 671
 672 int
 673 raw3270_reset(struct raw3270_view *view)
 674 {
 675         struct raw3270 *rp;
 676         int rc;
 677
 678         rp = view->dev;
 679         if (!rp || rp->view != view ||
 680             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 681                 rc = -EACCES;
 682         else if (!raw3270_state_ready(rp))
 683                 rc = -EBUSY;
 684         else
 685                 rc = raw3270_reset_device(view->dev);
 686         return rc;
 687 }
 688
 689 static int
 690 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
 691                  struct irb *irb)
 692 {
 693         struct raw3270 *rp;
 694
 695         /*
 696          * Unit-Check Processing:
 697          * Expect Command Reject or Intervention Required.
 698          */
 699         if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
 700                 /* Request finished abnormally. */
 701                 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
 702                         set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
 703                         return RAW3270_IO_BUSY;
 704                 }
 705         }
 706         if (rq) {
 707                 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
 708                         if (irb->ecw[0] & SNS0_CMD_REJECT)
 709                                 rq->rc = -EOPNOTSUPP;
 710                         else
 711                                 rq->rc = -EIO;
 712                 }
 713         }
 714         if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
 715                 /* Queue read modified after attention interrupt */
 716                 rp = view->dev;
 717                 raw3270_read_modified(rp);
 718         }
 719         return RAW3270_IO_DONE;
 720 }
 721
 722 static struct raw3270_fn raw3270_init_fn = {
 723         .intv = raw3270_init_irq
 724 };
 725
 726 /*
 727  * Setup new 3270 device.
 728  */
 729 static int
 730 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
 731 {
 732         struct list_head *l;
 733         struct raw3270 *tmp;
 734         int minor;
 735
 736         memset(rp, 0, sizeof(struct raw3270));
 737         /* Copy ebcdic -> ascii translation table. */
 738         memcpy(ascebc, _ascebc, 256);
 739         if (tubxcorrect) {
 740                 /* correct brackets and circumflex */
 741                 ascebc['['] = 0xad;
 742                 ascebc[']'] = 0xbd;
 743                 ascebc['^'] = 0xb0;
 744         }
 745         rp->ascebc = ascebc;
 746
 747         /* Set defaults. */
 748         rp->rows = 24;
 749         rp->cols = 80;
 750
 751         INIT_LIST_HEAD(&rp->req_queue);
 752         INIT_LIST_HEAD(&rp->view_list);
 753
 754         rp->init_view.dev = rp;
 755         rp->init_view.fn = &raw3270_init_fn;
 756         rp->view = &rp->init_view;
 757
 758         /*
 759          * Add device to list and find the smallest unused minor
 760          * number for it. Note: there is no device with minor 0,
 761          * see special case for fs3270.c:fs3270_open().
 762          */
 763         mutex_lock(&raw3270_mutex);
 764         /* Keep the list sorted. */
 765         minor = RAW3270_FIRSTMINOR;
 766         rp->minor = -1;
 767         list_for_each(l, &raw3270_devices) {
 768                 tmp = list_entry(l, struct raw3270, list);
 769                 if (tmp->minor > minor) {
 770                         rp->minor = minor;
 771                         __list_add(&rp->list, l->prev, l);
 772                         break;
 773                 }
 774                 minor++;
 775         }
 776         if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
 777                 rp->minor = minor;
 778                 list_add_tail(&rp->list, &raw3270_devices);
 779         }
 780         mutex_unlock(&raw3270_mutex);
 781         /* No free minor number? Then give up. */
 782         if (rp->minor == -1)
 783                 return -EUSERS;
 784         rp->cdev = cdev;
 785         dev_set_drvdata(&cdev->dev, rp);
 786         cdev->handler = raw3270_irq;
 787         return 0;
 788 }
 789
 790 #ifdef CONFIG_TN3270_CONSOLE
 791 /* Tentative definition - see below for actual definition. */
 792 static struct ccw_driver raw3270_ccw_driver;
 793
 794 /*
 795  * Setup 3270 device configured as console.
 796  */
 797 struct raw3270 __init *raw3270_setup_console(void)
 798 {
 799         struct ccw_device *cdev;
 800         unsigned long flags;
 801         struct raw3270 *rp;
 802         char *ascebc;
 803         int rc;
 804
 805         cdev = ccw_device_create_console(&raw3270_ccw_driver);
 806         if (IS_ERR(cdev))
 807                 return ERR_CAST(cdev);
 808
 809         rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 810         ascebc = kzalloc(256, GFP_KERNEL);
 811         rc = raw3270_setup_device(cdev, rp, ascebc);
 812         if (rc)
 813                 return ERR_PTR(rc);
 814         set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
 815
 816         rc = ccw_device_enable_console(cdev);
 817         if (rc) {
 818                 ccw_device_destroy_console(cdev);
 819                 return ERR_PTR(rc);
 820         }
 821
 822         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 823         do {
 824                 __raw3270_reset_device(rp);
 825                 while (!raw3270_state_final(rp)) {
 826                         ccw_device_wait_idle(rp->cdev);
 827                         barrier();
 828                 }
 829         } while (rp->state != RAW3270_STATE_READY);
 830         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 831         return rp;
 832 }
 833
 834 void
 835 raw3270_wait_cons_dev(struct raw3270 *rp)
 836 {
 837         unsigned long flags;
 838
 839         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 840         ccw_device_wait_idle(rp->cdev);
 841         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 842 }
 843
 844 #endif
 845
 846 /*
 847  * Create a 3270 device structure.
 848  */
 849 static struct raw3270 *
 850 raw3270_create_device(struct ccw_device *cdev)
 851 {
 852         struct raw3270 *rp;
 853         char *ascebc;
 854         int rc;
 855
 856         rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 857         if (!rp)
 858                 return ERR_PTR(-ENOMEM);
 859         ascebc = kmalloc(256, GFP_KERNEL);
 860         if (!ascebc) {
 861                 kfree(rp);
 862                 return ERR_PTR(-ENOMEM);
 863         }
 864         rc = raw3270_setup_device(cdev, rp, ascebc);
 865         if (rc) {
 866                 kfree(rp->ascebc);
 867                 kfree(rp);
 868                 rp = ERR_PTR(rc);
 869         }
 870         /* Get reference to ccw_device structure. */
 871         get_device(&cdev->dev);
 872         return rp;
 873 }
 874
 875 /*
 876  * Activate a view.
 877  */
 878 int
 879 raw3270_activate_view(struct raw3270_view *view)
 880 {
 881         struct raw3270 *rp;
 882         struct raw3270_view *oldview, *nv;
 883         unsigned long flags;
 884         int rc;
 885
 886         rp = view->dev;
 887         if (!rp)
 888                 return -ENODEV;
 889         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 890         if (rp->view == view)
 891                 rc = 0;
 892         else if (!raw3270_state_ready(rp))
 893                 rc = -EBUSY;
 894         else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 895                 rc = -EACCES;
 896         else {
 897                 oldview = NULL;
 898                 if (rp->view && rp->view->fn->deactivate) {
 899                         oldview = rp->view;
 900                         oldview->fn->deactivate(oldview);
 901                 }
 902                 rp->view = view;
 903                 rc = view->fn->activate(view);
 904                 if (rc) {
 905                         /* Didn't work. Try to reactivate the old view. */
 906                         rp->view = oldview;
 907                         if (!oldview || oldview->fn->activate(oldview) != 0) {
 908                                 /* Didn't work as well. Try any other view. */
 909                                 list_for_each_entry(nv, &rp->view_list, list)
 910                                         if (nv != view && nv != oldview) {
 911                                                 rp->view = nv;
 912                                                 if (nv->fn->activate(nv) == 0)
 913                                                         break;
 914                                                 rp->view = NULL;
 915                                         }
 916                         }
 917                 }
 918         }
 919         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 920         return rc;
 921 }
 922
 923 /*
 924  * Deactivate current view.
 925  */
 926 void
 927 raw3270_deactivate_view(struct raw3270_view *view)
 928 {
 929         unsigned long flags;
 930         struct raw3270 *rp;
 931
 932         rp = view->dev;
 933         if (!rp)
 934                 return;
 935         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 936         if (rp->view == view) {
 937                 view->fn->deactivate(view);
 938                 rp->view = NULL;
 939                 /* Move deactivated view to end of list. */
 940                 list_del_init(&view->list);
 941                 list_add_tail(&view->list, &rp->view_list);
 942                 /* Try to activate another view. */
 943                 if (raw3270_state_ready(rp) &&
 944                     !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
 945                         list_for_each_entry(view, &rp->view_list, list) {
 946                                 rp->view = view;
 947                                 if (view->fn->activate(view) == 0)
 948                                         break;
 949                                 rp->view = NULL;
 950                         }
 951                 }
 952         }
 953         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 954 }
 955
 956 /*
 957  * Add view to device with minor "minor".
 958  */
 959 int
 960 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
 961 {
 962         unsigned long flags;
 963         struct raw3270 *rp;
 964         int rc;
 965
 966         if (minor <= 0)
 967                 return -ENODEV;
 968         mutex_lock(&raw3270_mutex);
 969         rc = -ENODEV;
 970         list_for_each_entry(rp, &raw3270_devices, list) {
 971                 if (rp->minor != minor)
 972                         continue;
 973                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 974                 atomic_set(&view->ref_count, 2);
 975                 view->dev = rp;
 976                 view->fn = fn;
 977                 view->model = rp->model;
 978                 view->rows = rp->rows;
 979                 view->cols = rp->cols;
 980                 view->ascebc = rp->ascebc;
 981                 spin_lock_init(&view->lock);
 982                 list_add(&view->list, &rp->view_list);
 983                 rc = 0;
 984                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 985                 break;
 986         }
 987         mutex_unlock(&raw3270_mutex);
 988         return rc;
 989 }
 990
 991 /*
 992  * Find specific view of device with minor "minor".
 993  */
 994 struct raw3270_view *
 995 raw3270_find_view(struct raw3270_fn *fn, int minor)
 996 {
 997         struct raw3270 *rp;
 998         struct raw3270_view *view, *tmp;
 999         unsigned long flags;
1000
1001         mutex_lock(&raw3270_mutex);
1002         view = ERR_PTR(-ENODEV);
1003         list_for_each_entry(rp, &raw3270_devices, list) {
1004                 if (rp->minor != minor)
1005                         continue;
1006                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1007                 list_for_each_entry(tmp, &rp->view_list, list) {
1008                         if (tmp->fn == fn) {
1009                                 raw3270_get_view(tmp);
1010                                 view = tmp;
1011                                 break;
1012                         }
1013                 }
1014                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1015                 break;
1016         }
1017         mutex_unlock(&raw3270_mutex);
1018         return view;
1019 }
1020
1021 /*
1022  * Remove view from device and free view structure via call to view->fn->free.
1023  */
1024 void
1025 raw3270_del_view(struct raw3270_view *view)
1026 {
1027         unsigned long flags;
1028         struct raw3270 *rp;
1029         struct raw3270_view *nv;
1030
1031         rp = view->dev;
1032         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1033         if (rp->view == view) {
1034                 view->fn->deactivate(view);
1035                 rp->view = NULL;
1036         }
1037         list_del_init(&view->list);
1038         if (!rp->view && raw3270_state_ready(rp) &&
1039             !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
1040                 /* Try to activate another view. */
1041                 list_for_each_entry(nv, &rp->view_list, list) {
1042                         if (nv->fn->activate(nv) == 0) {
1043                                 rp->view = nv;
1044                                 break;
1045                         }
1046                 }
1047         }
1048         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1049         /* Wait for reference counter to drop to zero. */
1050         atomic_dec(&view->ref_count);
1051         wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1052         if (view->fn->free)
1053                 view->fn->free(view);
1054 }
1055
1056 /*
1057  * Remove a 3270 device structure.
1058  */
1059 static void
1060 raw3270_delete_device(struct raw3270 *rp)
1061 {
1062         struct ccw_device *cdev;
1063
1064         /* Remove from device chain. */
1065         mutex_lock(&raw3270_mutex);
1066         list_del_init(&rp->list);
1067         mutex_unlock(&raw3270_mutex);
1068
1069         /* Disconnect from ccw_device. */
1070         cdev = rp->cdev;
1071         rp->cdev = NULL;
1072         dev_set_drvdata(&cdev->dev, NULL);
1073         cdev->handler = NULL;
1074
1075         /* Put ccw_device structure. */
1076         put_device(&cdev->dev);
1077
1078         /* Now free raw3270 structure. */
1079         kfree(rp->ascebc);
1080         kfree(rp);
1081 }
1082
1083 static int
1084 raw3270_probe (struct ccw_device *cdev)
1085 {
1086         return 0;
1087 }
1088
1089 /*
1090  * Additional attributes for a 3270 device
1091  */
1092 static ssize_t
1093 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1094 {
1095         return snprintf(buf, PAGE_SIZE, "%i\n",
1096                         ((struct raw3270 *) dev_get_drvdata(dev))->model);
1097 }
1098 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1099
1100 static ssize_t
1101 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1102 {
1103         return snprintf(buf, PAGE_SIZE, "%i\n",
1104                         ((struct raw3270 *) dev_get_drvdata(dev))->rows);
1105 }
1106 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1107
1108 static ssize_t
1109 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1110 {
1111         return snprintf(buf, PAGE_SIZE, "%i\n",
1112                         ((struct raw3270 *) dev_get_drvdata(dev))->cols);
1113 }
1114 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1115
1116 static struct attribute * raw3270_attrs[] = {
1117         &dev_attr_model.attr,
1118         &dev_attr_rows.attr,
1119         &dev_attr_columns.attr,
1120         NULL,
1121 };
1122
1123 static struct attribute_group raw3270_attr_group = {
1124         .attrs = raw3270_attrs,
1125 };
1126
1127 static int raw3270_create_attributes(struct raw3270 *rp)
1128 {
1129         return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1130 }
1131
1132 /*
1133  * Notifier for device addition/removal
1134  */
1135 static LIST_HEAD(raw3270_notifier);
1136
1137 int raw3270_register_notifier(struct raw3270_notifier *notifier)
1138 {
1139         struct raw3270 *rp;
1140
1141         mutex_lock(&raw3270_mutex);
1142         list_add_tail(&notifier->list, &raw3270_notifier);
1143         list_for_each_entry(rp, &raw3270_devices, list)
1144                 notifier->create(rp->minor);
1145         mutex_unlock(&raw3270_mutex);
1146         return 0;
1147 }
1148
1149 void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
1150 {
1151         struct raw3270 *rp;
1152
1153         mutex_lock(&raw3270_mutex);
1154         list_for_each_entry(rp, &raw3270_devices, list)
1155                 notifier->destroy(rp->minor);
1156         list_del(&notifier->list);
1157         mutex_unlock(&raw3270_mutex);
1158 }
1159
1160 /*
1161  * Set 3270 device online.
1162  */
1163 static int
1164 raw3270_set_online (struct ccw_device *cdev)
1165 {
1166         struct raw3270_notifier *np;
1167         struct raw3270 *rp;
1168         int rc;
1169
1170         rp = raw3270_create_device(cdev);
1171         if (IS_ERR(rp))
1172                 return PTR_ERR(rp);
1173         rc = raw3270_create_attributes(rp);
1174         if (rc)
1175                 goto failure;
1176         raw3270_reset_device(rp);
1177         mutex_lock(&raw3270_mutex);
1178         list_for_each_entry(np, &raw3270_notifier, list)
1179                 np->create(rp->minor);
1180         mutex_unlock(&raw3270_mutex);
1181         return 0;
1182
1183 failure:
1184         raw3270_delete_device(rp);
1185         return rc;
1186 }
1187
1188 /*
1189  * Remove 3270 device structure.
1190  */
1191 static void
1192 raw3270_remove (struct ccw_device *cdev)
1193 {
1194         unsigned long flags;
1195         struct raw3270 *rp;
1196         struct raw3270_view *v;
1197         struct raw3270_notifier *np;
1198
1199         rp = dev_get_drvdata(&cdev->dev);
1200         /*
1201          * _remove is the opposite of _probe; it's probe that
1202          * should set up rp.  raw3270_remove gets entered for
1203          * devices even if they haven't been varied online.
1204          * Thus, rp may validly be NULL here.
1205          */
1206         if (rp == NULL)
1207                 return;
1208
1209         sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1210
1211         /* Deactivate current view and remove all views. */
1212         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1213         if (rp->view) {
1214                 if (rp->view->fn->deactivate)
1215                         rp->view->fn->deactivate(rp->view);
1216                 rp->view = NULL;
1217         }
1218         while (!list_empty(&rp->view_list)) {
1219                 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1220                 if (v->fn->release)
1221                         v->fn->release(v);
1222                 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1223                 raw3270_del_view(v);
1224                 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1225         }
1226         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1227
1228         mutex_lock(&raw3270_mutex);
1229         list_for_each_entry(np, &raw3270_notifier, list)
1230                 np->destroy(rp->minor);
1231         mutex_unlock(&raw3270_mutex);
1232
1233         /* Reset 3270 device. */
1234         raw3270_reset_device(rp);
1235         /* And finally remove it. */
1236         raw3270_delete_device(rp);
1237 }
1238
1239 /*
1240  * Set 3270 device offline.
1241  */
1242 static int
1243 raw3270_set_offline (struct ccw_device *cdev)
1244 {
1245         struct raw3270 *rp;
1246
1247         rp = dev_get_drvdata(&cdev->dev);
1248         if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1249                 return -EBUSY;
1250         raw3270_remove(cdev);
1251         return 0;
1252 }
1253
1254 static int raw3270_pm_stop(struct ccw_device *cdev)
1255 {
1256         struct raw3270 *rp;
1257         struct raw3270_view *view;
1258         unsigned long flags;
1259
1260         rp = dev_get_drvdata(&cdev->dev);
1261         if (!rp)
1262                 return 0;
1263         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1264         if (rp->view && rp->view->fn->deactivate)
1265                 rp->view->fn->deactivate(rp->view);
1266         if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1267                 /*
1268                  * Release tty and fullscreen for all non-console
1269                  * devices.
1270                  */
1271                 list_for_each_entry(view, &rp->view_list, list) {
1272                         if (view->fn->release)
1273                                 view->fn->release(view);
1274                 }
1275         }
1276         set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1277         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1278         return 0;
1279 }
1280
1281 static int raw3270_pm_start(struct ccw_device *cdev)
1282 {
1283         struct raw3270 *rp;
1284         unsigned long flags;
1285
1286         rp = dev_get_drvdata(&cdev->dev);
1287         if (!rp)
1288                 return 0;
1289         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1290         clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1291         if (rp->view && rp->view->fn->activate)
1292                 rp->view->fn->activate(rp->view);
1293         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1294         return 0;
1295 }
1296
1297 void raw3270_pm_unfreeze(struct raw3270_view *view)
1298 {
1299 #ifdef CONFIG_TN3270_CONSOLE
1300         struct raw3270 *rp;
1301
1302         rp = view->dev;
1303         if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1304                 ccw_device_force_console(rp->cdev);
1305 #endif
1306 }
1307
1308 static struct ccw_device_id raw3270_id[] = {
1309         { CCW_DEVICE(0x3270, 0) },
1310         { CCW_DEVICE(0x3271, 0) },
1311         { CCW_DEVICE(0x3272, 0) },
1312         { CCW_DEVICE(0x3273, 0) },
1313         { CCW_DEVICE(0x3274, 0) },
1314         { CCW_DEVICE(0x3275, 0) },
1315         { CCW_DEVICE(0x3276, 0) },
1316         { CCW_DEVICE(0x3277, 0) },
1317         { CCW_DEVICE(0x3278, 0) },
1318         { CCW_DEVICE(0x3279, 0) },
1319         { CCW_DEVICE(0x3174, 0) },
1320         { /* end of list */ },
1321 };
1322
1323 static struct ccw_driver raw3270_ccw_driver = {
1324         .driver = {
1325                 .name   = "3270",
1326                 .owner  = THIS_MODULE,
1327         },
1328         .ids            = raw3270_id,
1329         .probe          = &raw3270_probe,
1330         .remove         = &raw3270_remove,
1331         .set_online     = &raw3270_set_online,
1332         .set_offline    = &raw3270_set_offline,
1333         .freeze         = &raw3270_pm_stop,
1334         .thaw           = &raw3270_pm_start,
1335         .restore        = &raw3270_pm_start,
1336         .int_class      = IRQIO_C70,
1337 };
1338
1339 static int
1340 raw3270_init(void)
1341 {
1342         struct raw3270 *rp;
1343         int rc;
1344
1345         if (raw3270_registered)
1346                 return 0;
1347         raw3270_registered = 1;
1348         rc = ccw_driver_register(&raw3270_ccw_driver);
1349         if (rc == 0) {
1350                 /* Create attributes for early (= console) device. */
1351                 mutex_lock(&raw3270_mutex);
1352                 class3270 = class_create(THIS_MODULE, "3270");
1353                 list_for_each_entry(rp, &raw3270_devices, list) {
1354                         get_device(&rp->cdev->dev);
1355                         raw3270_create_attributes(rp);
1356                 }
1357                 mutex_unlock(&raw3270_mutex);
1358         }
1359         return rc;
1360 }
1361
1362 static void
1363 raw3270_exit(void)
1364 {
1365         ccw_driver_unregister(&raw3270_ccw_driver);
1366         class_destroy(class3270);
1367 }
1368
1369 MODULE_LICENSE("GPL");
1370
1371 module_init(raw3270_init);
1372 module_exit(raw3270_exit);
1373
1374 EXPORT_SYMBOL(class3270);
1375 EXPORT_SYMBOL(raw3270_request_alloc);
1376 EXPORT_SYMBOL(raw3270_request_free);
1377 EXPORT_SYMBOL(raw3270_request_reset);
1378 EXPORT_SYMBOL(raw3270_request_set_cmd);
1379 EXPORT_SYMBOL(raw3270_request_add_data);
1380 EXPORT_SYMBOL(raw3270_request_set_data);
1381 EXPORT_SYMBOL(raw3270_request_set_idal);
1382 EXPORT_SYMBOL(raw3270_buffer_address);
1383 EXPORT_SYMBOL(raw3270_add_view);
1384 EXPORT_SYMBOL(raw3270_del_view);
1385 EXPORT_SYMBOL(raw3270_find_view);
1386 EXPORT_SYMBOL(raw3270_activate_view);
1387 EXPORT_SYMBOL(raw3270_deactivate_view);
1388 EXPORT_SYMBOL(raw3270_start);
1389 EXPORT_SYMBOL(raw3270_start_locked);
1390 EXPORT_SYMBOL(raw3270_start_irq);
1391 EXPORT_SYMBOL(raw3270_reset);
1392 EXPORT_SYMBOL(raw3270_register_notifier);
1393 EXPORT_SYMBOL(raw3270_unregister_notifier);
1394 EXPORT_SYMBOL(raw3270_wait_queue);