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