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 }
 636
 637 static int
 638 __raw3270_reset_device(struct raw3270 *rp)
 639 {
 640         int rc;
 641
 642         /* Store reset data stream to init_data/init_reset */
 643         memset(&rp->init_reset, 0, sizeof(rp->init_reset));
 644         memset(&rp->init_data, 0, sizeof(rp->init_data));
 645         rp->init_data[0] = TW_KR;
 646         rp->init_reset.ccw.cmd_code = TC_EWRITEA;
 647         rp->init_reset.ccw.flags = CCW_FLAG_SLI;
 648         rp->init_reset.ccw.count = 1;
 649         rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
 650         rp->init_reset.callback = raw3270_reset_device_cb;
 651         rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
 652         if (rc == 0 && rp->state == RAW3270_STATE_INIT)
 653                 rp->state = RAW3270_STATE_RESET;
 654         return rc;
 655 }
 656
 657 static int
 658 raw3270_reset_device(struct raw3270 *rp)
 659 {
 660         unsigned long flags;
 661         int rc;
 662
 663         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 664         rc = __raw3270_reset_device(rp);
 665         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 666         return rc;
 667 }
 668
 669 int
 670 raw3270_reset(struct raw3270_view *view)
 671 {
 672         struct raw3270 *rp;
 673         int rc;
 674
 675         rp = view->dev;
 676         if (!rp || rp->view != view ||
 677             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 678                 rc = -EACCES;
 679         else if (!raw3270_state_ready(rp))
 680                 rc = -EBUSY;
 681         else
 682                 rc = raw3270_reset_device(view->dev);
 683         return rc;
 684 }
 685
 686 static int
 687 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
 688                  struct irb *irb)
 689 {
 690         struct raw3270 *rp;
 691
 692         /*
 693          * Unit-Check Processing:
 694          * Expect Command Reject or Intervention Required.
 695          */
 696         if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
 697                 /* Request finished abnormally. */
 698                 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
 699                         set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
 700                         return RAW3270_IO_BUSY;
 701                 }
 702         }
 703         if (rq) {
 704                 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
 705                         if (irb->ecw[0] & SNS0_CMD_REJECT)
 706                                 rq->rc = -EOPNOTSUPP;
 707                         else
 708                                 rq->rc = -EIO;
 709                 }
 710         }
 711         if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
 712                 /* Queue read modified after attention interrupt */
 713                 rp = view->dev;
 714                 raw3270_read_modified(rp);
 715         }
 716         return RAW3270_IO_DONE;
 717 }
 718
 719 static struct raw3270_fn raw3270_init_fn = {
 720         .intv = raw3270_init_irq
 721 };
 722
 723 /*
 724  * Setup new 3270 device.
 725  */
 726 static int
 727 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
 728 {
 729         struct list_head *l;
 730         struct raw3270 *tmp;
 731         int minor;
 732
 733         memset(rp, 0, sizeof(struct raw3270));
 734         /* Copy ebcdic -> ascii translation table. */
 735         memcpy(ascebc, _ascebc, 256);
 736         if (tubxcorrect) {
 737                 /* correct brackets and circumflex */
 738                 ascebc['['] = 0xad;
 739                 ascebc[']'] = 0xbd;
 740                 ascebc['^'] = 0xb0;
 741         }
 742         rp->ascebc = ascebc;
 743
 744         /* Set defaults. */
 745         rp->rows = 24;
 746         rp->cols = 80;
 747
 748         INIT_LIST_HEAD(&rp->req_queue);
 749         INIT_LIST_HEAD(&rp->view_list);
 750
 751         rp->init_view.dev = rp;
 752         rp->init_view.fn = &raw3270_init_fn;
 753         rp->view = &rp->init_view;
 754
 755         /*
 756          * Add device to list and find the smallest unused minor
 757          * number for it. Note: there is no device with minor 0,
 758          * see special case for fs3270.c:fs3270_open().
 759          */
 760         mutex_lock(&raw3270_mutex);
 761         /* Keep the list sorted. */
 762         minor = RAW3270_FIRSTMINOR;
 763         rp->minor = -1;
 764         list_for_each(l, &raw3270_devices) {
 765                 tmp = list_entry(l, struct raw3270, list);
 766                 if (tmp->minor > minor) {
 767                         rp->minor = minor;
 768                         __list_add(&rp->list, l->prev, l);
 769                         break;
 770                 }
 771                 minor++;
 772         }
 773         if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
 774                 rp->minor = minor;
 775                 list_add_tail(&rp->list, &raw3270_devices);
 776         }
 777         mutex_unlock(&raw3270_mutex);
 778         /* No free minor number? Then give up. */
 779         if (rp->minor == -1)
 780                 return -EUSERS;
 781         rp->cdev = cdev;
 782         dev_set_drvdata(&cdev->dev, rp);
 783         cdev->handler = raw3270_irq;
 784         return 0;
 785 }
 786
 787 #ifdef CONFIG_TN3270_CONSOLE
 788 /* Tentative definition - see below for actual definition. */
 789 static struct ccw_driver raw3270_ccw_driver;
 790
 791 /*
 792  * Setup 3270 device configured as console.
 793  */
 794 struct raw3270 __init *raw3270_setup_console(void)
 795 {
 796         struct ccw_device *cdev;
 797         unsigned long flags;
 798         struct raw3270 *rp;
 799         char *ascebc;
 800         int rc;
 801
 802         cdev = ccw_device_create_console(&raw3270_ccw_driver);
 803         if (IS_ERR(cdev))
 804                 return ERR_CAST(cdev);
 805
 806         rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 807         ascebc = kzalloc(256, GFP_KERNEL);
 808         rc = raw3270_setup_device(cdev, rp, ascebc);
 809         if (rc)
 810                 return ERR_PTR(rc);
 811         set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
 812
 813         rc = ccw_device_enable_console(cdev);
 814         if (rc) {
 815                 ccw_device_destroy_console(cdev);
 816                 return ERR_PTR(rc);
 817         }
 818
 819         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 820         do {
 821                 __raw3270_reset_device(rp);
 822                 while (!raw3270_state_final(rp)) {
 823                         ccw_device_wait_idle(rp->cdev);
 824                         barrier();
 825                 }
 826         } while (rp->state != RAW3270_STATE_READY);
 827         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 828         return rp;
 829 }
 830
 831 void
 832 raw3270_wait_cons_dev(struct raw3270 *rp)
 833 {
 834         unsigned long flags;
 835
 836         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 837         ccw_device_wait_idle(rp->cdev);
 838         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 839 }
 840
 841 #endif
 842
 843 /*
 844  * Create a 3270 device structure.
 845  */
 846 static struct raw3270 *
 847 raw3270_create_device(struct ccw_device *cdev)
 848 {
 849         struct raw3270 *rp;
 850         char *ascebc;
 851         int rc;
 852
 853         rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 854         if (!rp)
 855                 return ERR_PTR(-ENOMEM);
 856         ascebc = kmalloc(256, GFP_KERNEL);
 857         if (!ascebc) {
 858                 kfree(rp);
 859                 return ERR_PTR(-ENOMEM);
 860         }
 861         rc = raw3270_setup_device(cdev, rp, ascebc);
 862         if (rc) {
 863                 kfree(rp->ascebc);
 864                 kfree(rp);
 865                 rp = ERR_PTR(rc);
 866         }
 867         /* Get reference to ccw_device structure. */
 868         get_device(&cdev->dev);
 869         return rp;
 870 }
 871
 872 /*
 873  * Activate a view.
 874  */
 875 int
 876 raw3270_activate_view(struct raw3270_view *view)
 877 {
 878         struct raw3270 *rp;
 879         struct raw3270_view *oldview, *nv;
 880         unsigned long flags;
 881         int rc;
 882
 883         rp = view->dev;
 884         if (!rp)
 885                 return -ENODEV;
 886         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 887         if (rp->view == view)
 888                 rc = 0;
 889         else if (!raw3270_state_ready(rp))
 890                 rc = -EBUSY;
 891         else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 892                 rc = -EACCES;
 893         else {
 894                 oldview = NULL;
 895                 if (rp->view && rp->view->fn->deactivate) {
 896                         oldview = rp->view;
 897                         oldview->fn->deactivate(oldview);
 898                 }
 899                 rp->view = view;
 900                 rc = view->fn->activate(view);
 901                 if (rc) {
 902                         /* Didn't work. Try to reactivate the old view. */
 903                         rp->view = oldview;
 904                         if (!oldview || oldview->fn->activate(oldview) != 0) {
 905                                 /* Didn't work as well. Try any other view. */
 906                                 list_for_each_entry(nv, &rp->view_list, list)
 907                                         if (nv != view && nv != oldview) {
 908                                                 rp->view = nv;
 909                                                 if (nv->fn->activate(nv) == 0)
 910                                                         break;
 911                                                 rp->view = NULL;
 912                                         }
 913                         }
 914                 }
 915         }
 916         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 917         return rc;
 918 }
 919
 920 /*
 921  * Deactivate current view.
 922  */
 923 void
 924 raw3270_deactivate_view(struct raw3270_view *view)
 925 {
 926         unsigned long flags;
 927         struct raw3270 *rp;
 928
 929         rp = view->dev;
 930         if (!rp)
 931                 return;
 932         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 933         if (rp->view == view) {
 934                 view->fn->deactivate(view);
 935                 rp->view = NULL;
 936                 /* Move deactivated view to end of list. */
 937                 list_del_init(&view->list);
 938                 list_add_tail(&view->list, &rp->view_list);
 939                 /* Try to activate another view. */
 940                 if (raw3270_state_ready(rp) &&
 941                     !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
 942                         list_for_each_entry(view, &rp->view_list, list) {
 943                                 rp->view = view;
 944                                 if (view->fn->activate(view) == 0)
 945                                         break;
 946                                 rp->view = NULL;
 947                         }
 948                 }
 949         }
 950         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 951 }
 952
 953 /*
 954  * Add view to device with minor "minor".
 955  */
 956 int
 957 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
 958 {
 959         unsigned long flags;
 960         struct raw3270 *rp;
 961         int rc;
 962
 963         if (minor <= 0)
 964                 return -ENODEV;
 965         mutex_lock(&raw3270_mutex);
 966         rc = -ENODEV;
 967         list_for_each_entry(rp, &raw3270_devices, list) {
 968                 if (rp->minor != minor)
 969                         continue;
 970                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 971                 atomic_set(&view->ref_count, 2);
 972                 view->dev = rp;
 973                 view->fn = fn;
 974                 view->model = rp->model;
 975                 view->rows = rp->rows;
 976                 view->cols = rp->cols;
 977                 view->ascebc = rp->ascebc;
 978                 spin_lock_init(&view->lock);
 979                 list_add(&view->list, &rp->view_list);
 980                 rc = 0;
 981                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 982                 break;
 983         }
 984         mutex_unlock(&raw3270_mutex);
 985         return rc;
 986 }
 987
 988 /*
 989  * Find specific view of device with minor "minor".
 990  */
 991 struct raw3270_view *
 992 raw3270_find_view(struct raw3270_fn *fn, int minor)
 993 {
 994         struct raw3270 *rp;
 995         struct raw3270_view *view, *tmp;
 996         unsigned long flags;
 997
 998         mutex_lock(&raw3270_mutex);
 999         view = ERR_PTR(-ENODEV);
1000         list_for_each_entry(rp, &raw3270_devices, list) {
1001                 if (rp->minor != minor)
1002                         continue;
1003                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1004                 list_for_each_entry(tmp, &rp->view_list, list) {
1005                         if (tmp->fn == fn) {
1006                                 raw3270_get_view(tmp);
1007                                 view = tmp;
1008                                 break;
1009                         }
1010                 }
1011                 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1012                 break;
1013         }
1014         mutex_unlock(&raw3270_mutex);
1015         return view;
1016 }
1017
1018 /*
1019  * Remove view from device and free view structure via call to view->fn->free.
1020  */
1021 void
1022 raw3270_del_view(struct raw3270_view *view)
1023 {
1024         unsigned long flags;
1025         struct raw3270 *rp;
1026         struct raw3270_view *nv;
1027
1028         rp = view->dev;
1029         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1030         if (rp->view == view) {
1031                 view->fn->deactivate(view);
1032                 rp->view = NULL;
1033         }
1034         list_del_init(&view->list);
1035         if (!rp->view && raw3270_state_ready(rp) &&
1036             !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
1037                 /* Try to activate another view. */
1038                 list_for_each_entry(nv, &rp->view_list, list) {
1039                         if (nv->fn->activate(nv) == 0) {
1040                                 rp->view = nv;
1041                                 break;
1042                         }
1043                 }
1044         }
1045         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1046         /* Wait for reference counter to drop to zero. */
1047         atomic_dec(&view->ref_count);
1048         wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1049         if (view->fn->free)
1050                 view->fn->free(view);
1051 }
1052
1053 /*
1054  * Remove a 3270 device structure.
1055  */
1056 static void
1057 raw3270_delete_device(struct raw3270 *rp)
1058 {
1059         struct ccw_device *cdev;
1060
1061         /* Remove from device chain. */
1062         mutex_lock(&raw3270_mutex);
1063         list_del_init(&rp->list);
1064         mutex_unlock(&raw3270_mutex);
1065
1066         /* Disconnect from ccw_device. */
1067         cdev = rp->cdev;
1068         rp->cdev = NULL;
1069         dev_set_drvdata(&cdev->dev, NULL);
1070         cdev->handler = NULL;
1071
1072         /* Put ccw_device structure. */
1073         put_device(&cdev->dev);
1074
1075         /* Now free raw3270 structure. */
1076         kfree(rp->ascebc);
1077         kfree(rp);
1078 }
1079
1080 static int
1081 raw3270_probe (struct ccw_device *cdev)
1082 {
1083         return 0;
1084 }
1085
1086 /*
1087  * Additional attributes for a 3270 device
1088  */
1089 static ssize_t
1090 raw3270_model_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))->model);
1094 }
1095 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1096
1097 static ssize_t
1098 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1099 {
1100         return snprintf(buf, PAGE_SIZE, "%i\n",
1101                         ((struct raw3270 *) dev_get_drvdata(dev))->rows);
1102 }
1103 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1104
1105 static ssize_t
1106 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1107 {
1108         return snprintf(buf, PAGE_SIZE, "%i\n",
1109                         ((struct raw3270 *) dev_get_drvdata(dev))->cols);
1110 }
1111 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1112
1113 static struct attribute * raw3270_attrs[] = {
1114         &dev_attr_model.attr,
1115         &dev_attr_rows.attr,
1116         &dev_attr_columns.attr,
1117         NULL,
1118 };
1119
1120 static struct attribute_group raw3270_attr_group = {
1121         .attrs = raw3270_attrs,
1122 };
1123
1124 static int raw3270_create_attributes(struct raw3270 *rp)
1125 {
1126         return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1127 }
1128
1129 /*
1130  * Notifier for device addition/removal
1131  */
1132 static LIST_HEAD(raw3270_notifier);
1133
1134 int raw3270_register_notifier(struct raw3270_notifier *notifier)
1135 {
1136         struct raw3270 *rp;
1137
1138         mutex_lock(&raw3270_mutex);
1139         list_add_tail(&notifier->list, &raw3270_notifier);
1140         list_for_each_entry(rp, &raw3270_devices, list)
1141                 notifier->create(rp->minor);
1142         mutex_unlock(&raw3270_mutex);
1143         return 0;
1144 }
1145
1146 void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
1147 {
1148         struct raw3270 *rp;
1149
1150         mutex_lock(&raw3270_mutex);
1151         list_for_each_entry(rp, &raw3270_devices, list)
1152                 notifier->destroy(rp->minor);
1153         list_del(&notifier->list);
1154         mutex_unlock(&raw3270_mutex);
1155 }
1156
1157 /*
1158  * Set 3270 device online.
1159  */
1160 static int
1161 raw3270_set_online (struct ccw_device *cdev)
1162 {
1163         struct raw3270_notifier *np;
1164         struct raw3270 *rp;
1165         int rc;
1166
1167         rp = raw3270_create_device(cdev);
1168         if (IS_ERR(rp))
1169                 return PTR_ERR(rp);
1170         rc = raw3270_create_attributes(rp);
1171         if (rc)
1172                 goto failure;
1173         raw3270_reset_device(rp);
1174         mutex_lock(&raw3270_mutex);
1175         list_for_each_entry(np, &raw3270_notifier, list)
1176                 np->create(rp->minor);
1177         mutex_unlock(&raw3270_mutex);
1178         return 0;
1179
1180 failure:
1181         raw3270_delete_device(rp);
1182         return rc;
1183 }
1184
1185 /*
1186  * Remove 3270 device structure.
1187  */
1188 static void
1189 raw3270_remove (struct ccw_device *cdev)
1190 {
1191         unsigned long flags;
1192         struct raw3270 *rp;
1193         struct raw3270_view *v;
1194         struct raw3270_notifier *np;
1195
1196         rp = dev_get_drvdata(&cdev->dev);
1197         /*
1198          * _remove is the opposite of _probe; it's probe that
1199          * should set up rp.  raw3270_remove gets entered for
1200          * devices even if they haven't been varied online.
1201          * Thus, rp may validly be NULL here.
1202          */
1203         if (rp == NULL)
1204                 return;
1205
1206         sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1207
1208         /* Deactivate current view and remove all views. */
1209         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1210         if (rp->view) {
1211                 if (rp->view->fn->deactivate)
1212                         rp->view->fn->deactivate(rp->view);
1213                 rp->view = NULL;
1214         }
1215         while (!list_empty(&rp->view_list)) {
1216                 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1217                 if (v->fn->release)
1218                         v->fn->release(v);
1219                 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1220                 raw3270_del_view(v);
1221                 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1222         }
1223         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1224
1225         mutex_lock(&raw3270_mutex);
1226         list_for_each_entry(np, &raw3270_notifier, list)
1227                 np->destroy(rp->minor);
1228         mutex_unlock(&raw3270_mutex);
1229
1230         /* Reset 3270 device. */
1231         raw3270_reset_device(rp);
1232         /* And finally remove it. */
1233         raw3270_delete_device(rp);
1234 }
1235
1236 /*
1237  * Set 3270 device offline.
1238  */
1239 static int
1240 raw3270_set_offline (struct ccw_device *cdev)
1241 {
1242         struct raw3270 *rp;
1243
1244         rp = dev_get_drvdata(&cdev->dev);
1245         if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1246                 return -EBUSY;
1247         raw3270_remove(cdev);
1248         return 0;
1249 }
1250
1251 static int raw3270_pm_stop(struct ccw_device *cdev)
1252 {
1253         struct raw3270 *rp;
1254         struct raw3270_view *view;
1255         unsigned long flags;
1256
1257         rp = dev_get_drvdata(&cdev->dev);
1258         if (!rp)
1259                 return 0;
1260         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1261         if (rp->view && rp->view->fn->deactivate)
1262                 rp->view->fn->deactivate(rp->view);
1263         if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1264                 /*
1265                  * Release tty and fullscreen for all non-console
1266                  * devices.
1267                  */
1268                 list_for_each_entry(view, &rp->view_list, list) {
1269                         if (view->fn->release)
1270                                 view->fn->release(view);
1271                 }
1272         }
1273         set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1274         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1275         return 0;
1276 }
1277
1278 static int raw3270_pm_start(struct ccw_device *cdev)
1279 {
1280         struct raw3270 *rp;
1281         unsigned long flags;
1282
1283         rp = dev_get_drvdata(&cdev->dev);
1284         if (!rp)
1285                 return 0;
1286         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1287         clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1288         if (rp->view && rp->view->fn->activate)
1289                 rp->view->fn->activate(rp->view);
1290         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1291         return 0;
1292 }
1293
1294 void raw3270_pm_unfreeze(struct raw3270_view *view)
1295 {
1296 #ifdef CONFIG_TN3270_CONSOLE
1297         struct raw3270 *rp;
1298
1299         rp = view->dev;
1300         if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1301                 ccw_device_force_console(rp->cdev);
1302 #endif
1303 }
1304
1305 static struct ccw_device_id raw3270_id[] = {
1306         { CCW_DEVICE(0x3270, 0) },
1307         { CCW_DEVICE(0x3271, 0) },
1308         { CCW_DEVICE(0x3272, 0) },
1309         { CCW_DEVICE(0x3273, 0) },
1310         { CCW_DEVICE(0x3274, 0) },
1311         { CCW_DEVICE(0x3275, 0) },
1312         { CCW_DEVICE(0x3276, 0) },
1313         { CCW_DEVICE(0x3277, 0) },
1314         { CCW_DEVICE(0x3278, 0) },
1315         { CCW_DEVICE(0x3279, 0) },
1316         { CCW_DEVICE(0x3174, 0) },
1317         { /* end of list */ },
1318 };
1319
1320 static struct ccw_driver raw3270_ccw_driver = {
1321         .driver = {
1322                 .name   = "3270",
1323                 .owner  = THIS_MODULE,
1324         },
1325         .ids            = raw3270_id,
1326         .probe          = &raw3270_probe,
1327         .remove         = &raw3270_remove,
1328         .set_online     = &raw3270_set_online,
1329         .set_offline    = &raw3270_set_offline,
1330         .freeze         = &raw3270_pm_stop,
1331         .thaw           = &raw3270_pm_start,
1332         .restore        = &raw3270_pm_start,
1333         .int_class      = IRQIO_C70,
1334 };
1335
1336 static int
1337 raw3270_init(void)
1338 {
1339         struct raw3270 *rp;
1340         int rc;
1341
1342         if (raw3270_registered)
1343                 return 0;
1344         raw3270_registered = 1;
1345         rc = ccw_driver_register(&raw3270_ccw_driver);
1346         if (rc == 0) {
1347                 /* Create attributes for early (= console) device. */
1348                 mutex_lock(&raw3270_mutex);
1349                 class3270 = class_create(THIS_MODULE, "3270");
1350                 list_for_each_entry(rp, &raw3270_devices, list) {
1351                         get_device(&rp->cdev->dev);
1352                         raw3270_create_attributes(rp);
1353                 }
1354                 mutex_unlock(&raw3270_mutex);
1355         }
1356         return rc;
1357 }
1358
1359 static void
1360 raw3270_exit(void)
1361 {
1362         ccw_driver_unregister(&raw3270_ccw_driver);
1363         class_destroy(class3270);
1364 }
1365
1366 MODULE_LICENSE("GPL");
1367
1368 module_init(raw3270_init);
1369 module_exit(raw3270_exit);
1370
1371 EXPORT_SYMBOL(class3270);
1372 EXPORT_SYMBOL(raw3270_request_alloc);
1373 EXPORT_SYMBOL(raw3270_request_free);
1374 EXPORT_SYMBOL(raw3270_request_reset);
1375 EXPORT_SYMBOL(raw3270_request_set_cmd);
1376 EXPORT_SYMBOL(raw3270_request_add_data);
1377 EXPORT_SYMBOL(raw3270_request_set_data);
1378 EXPORT_SYMBOL(raw3270_request_set_idal);
1379 EXPORT_SYMBOL(raw3270_buffer_address);
1380 EXPORT_SYMBOL(raw3270_add_view);
1381 EXPORT_SYMBOL(raw3270_del_view);
1382 EXPORT_SYMBOL(raw3270_find_view);
1383 EXPORT_SYMBOL(raw3270_activate_view);
1384 EXPORT_SYMBOL(raw3270_deactivate_view);
1385 EXPORT_SYMBOL(raw3270_start);
1386 EXPORT_SYMBOL(raw3270_start_locked);
1387 EXPORT_SYMBOL(raw3270_start_irq);
1388 EXPORT_SYMBOL(raw3270_reset);
1389 EXPORT_SYMBOL(raw3270_register_notifier);
1390 EXPORT_SYMBOL(raw3270_unregister_notifier);
1391 EXPORT_SYMBOL(raw3270_wait_queue);