drivers/s390/char/raw3270.c

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