drivers/s390/char/raw3270.c

   1 /*
   2  * IBM/3270 Driver - core functions.
   3  *
   4  * Author(s):
   5  *   Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
   6  *   Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  *     Copyright IBM Corp. 2003, 2009
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/err.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/list.h>
  15 #include <linux/slab.h>
  16 #include <linux/types.h>
  17 #include <linux/wait.h>
  18
  19 #include <asm/ccwdev.h>
  20 #include <asm/cio.h>
  21 #include <asm/ebcdic.h>
  22 #include <asm/diag.h>
  23
  24 #include "raw3270.h"
  25
  26 #include <linux/major.h>
  27 #include <linux/kdev_t.h>
  28 #include <linux/device.h>
  29 #include <linux/mutex.h>
  30
  31 struct class *class3270;
  32
  33 /* The main 3270 data structure. */
  34 struct raw3270 {
  35         struct list_head list;
  36         struct ccw_device *cdev;
  37         int minor;
  38
  39         short model, rows, cols;
  40         unsigned int state;
  41         unsigned long flags;
  42
  43         struct list_head req_queue;     /* Request queue. */
  44         struct list_head view_list;     /* List of available views. */
  45         struct raw3270_view *view;      /* Active view. */
  46
  47         struct timer_list timer;        /* Device timer. */
  48
  49         unsigned char *ascebc;          /* ascii -> ebcdic table */
  50
  51         struct raw3270_view init_view;
  52         struct raw3270_request init_reset;
  53         struct raw3270_request init_readpart;
  54         struct raw3270_request init_readmod;
  55         unsigned char init_data[256];
  56 };
  57
  58 /* raw3270->state */
  59 #define RAW3270_STATE_INIT      0       /* Initial state */
  60 #define RAW3270_STATE_RESET     1       /* Reset command is pending */
  61 #define RAW3270_STATE_W4ATTN    2       /* Wait for attention interrupt */
  62 #define RAW3270_STATE_READMOD   3       /* Read partition is pending */
  63 #define RAW3270_STATE_READY     4       /* Device is usable by views */
  64
  65 /* raw3270->flags */
  66 #define RAW3270_FLAGS_14BITADDR 0       /* 14-bit buffer addresses */
  67 #define RAW3270_FLAGS_BUSY      1       /* Device busy, leave it alone */
  68 #define RAW3270_FLAGS_CONSOLE   2       /* Device is the console. */
  69 #define RAW3270_FLAGS_FROZEN    3       /* set if 3270 is frozen for suspend */
  70
  71 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
  72 static DEFINE_MUTEX(raw3270_mutex);
  73
  74 /* List of 3270 devices. */
  75 static LIST_HEAD(raw3270_devices);
  76
  77 /*
  78  * Flag to indicate if the driver has been registered. Some operations
  79  * like waiting for the end of i/o need to be done differently as long
  80  * as the kernel is still starting up (console support).
  81  */
  82 static int raw3270_registered;
  83
  84 /* Module parameters */
  85 static bool tubxcorrect = 0;
  86 module_param(tubxcorrect, bool, 0);
  87
  88 /*
  89  * Wait queue for device init/delete, view delete.
  90  */
  91 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
  92
  93 static void __raw3270_disconnect(struct raw3270 *rp);
  94
  95 /*
  96  * Encode array for 12 bit 3270 addresses.
  97  */
  98 static unsigned char raw3270_ebcgraf[64] =      {
  99         0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 100         0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 101         0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 102         0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 103         0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 104         0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 105         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 106         0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
 107 };
 108
 109 static inline int raw3270_state_ready(struct raw3270 *rp)
 110 {
 111         return rp->state == RAW3270_STATE_READY;
 112 }
 113
 114 static inline int raw3270_state_final(struct raw3270 *rp)
 115 {
 116         return rp->state == RAW3270_STATE_INIT ||
 117                 rp->state == RAW3270_STATE_READY;
 118 }
 119
 120 void
 121 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
 122 {
 123         if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
 124                 cp[0] = (addr >> 8) & 0x3f;
 125                 cp[1] = addr & 0xff;
 126         } else {
 127                 cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
 128                 cp[1] = raw3270_ebcgraf[addr & 0x3f];
 129         }
 130 }
 131
 132 /*
 133  * Allocate a new 3270 ccw request
 134  */
 135 struct raw3270_request *
 136 raw3270_request_alloc(size_t size)
 137 {
 138         struct raw3270_request *rq;
 139
 140         /* Allocate request structure */
 141         rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
 142         if (!rq)
 143                 return ERR_PTR(-ENOMEM);
 144
 145         /* alloc output buffer. */
 146         if (size > 0) {
 147                 rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
 148                 if (!rq->buffer) {
 149                         kfree(rq);
 150                         return ERR_PTR(-ENOMEM);
 151                 }
 152         }
 153         rq->size = size;
 154         INIT_LIST_HEAD(&rq->list);
 155
 156         /*
 157          * Setup ccw.
 158          */
 159         rq->ccw.cda = __pa(rq->buffer);
 160         rq->ccw.flags = CCW_FLAG_SLI;
 161
 162         return rq;
 163 }
 164
 165 /*
 166  * Free 3270 ccw request
 167  */
 168 void
 169 raw3270_request_free (struct raw3270_request *rq)
 170 {
 171         kfree(rq->buffer);
 172         kfree(rq);
 173 }
 174
 175 /*
 176  * Reset request to initial state.
 177  */
 178 void
 179 raw3270_request_reset(struct raw3270_request *rq)
 180 {
 181         BUG_ON(!list_empty(&rq->list));
 182         rq->ccw.cmd_code = 0;
 183         rq->ccw.count = 0;
 184         rq->ccw.cda = __pa(rq->buffer);
 185         rq->ccw.flags = CCW_FLAG_SLI;
 186         rq->rescnt = 0;
 187         rq->rc = 0;
 188 }
 189
 190 /*
 191  * Set command code to ccw of a request.
 192  */
 193 void
 194 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
 195 {
 196         rq->ccw.cmd_code = cmd;
 197 }
 198
 199 /*
 200  * Add data fragment to output buffer.
 201  */
 202 int
 203 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
 204 {
 205         if (size + rq->ccw.count > rq->size)
 206                 return -E2BIG;
 207         memcpy(rq->buffer + rq->ccw.count, data, size);
 208         rq->ccw.count += size;
 209         return 0;
 210 }
 211
 212 /*
 213  * Set address/length pair to ccw of a request.
 214  */
 215 void
 216 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
 217 {
 218         rq->ccw.cda = __pa(data);
 219         rq->ccw.count = size;
 220 }
 221
 222 /*
 223  * Set idal buffer to ccw of a request.
 224  */
 225 void
 226 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
 227 {
 228         rq->ccw.cda = __pa(ib->data);
 229         rq->ccw.count = ib->size;
 230         rq->ccw.flags |= CCW_FLAG_IDA;
 231 }
 232
 233 /*
 234  * Add the request to the request queue, try to start it if the
 235  * 3270 device is idle. Return without waiting for end of i/o.
 236  */
 237 static int
 238 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
 239                 struct raw3270_request *rq)
 240 {
 241         rq->view = view;
 242         raw3270_get_view(view);
 243         if (list_empty(&rp->req_queue) &&
 244             !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
 245                 /* No other requests are on the queue. Start this one. */
 246                 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
 247                                                (unsigned long) rq, 0, 0);
 248                 if (rq->rc) {
 249                         raw3270_put_view(view);
 250                         return rq->rc;
 251                 }
 252         }
 253         list_add_tail(&rq->list, &rp->req_queue);
 254         return 0;
 255 }
 256
 257 int
 258 raw3270_view_active(struct raw3270_view *view)
 259 {
 260         struct raw3270 *rp = view->dev;
 261
 262         return rp && rp->view == view &&
 263                 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
 264 }
 265
 266 int
 267 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
 268 {
 269         unsigned long flags;
 270         struct raw3270 *rp;
 271         int rc;
 272
 273         spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
 274         rp = view->dev;
 275         if (!rp || rp->view != view ||
 276             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 277                 rc = -EACCES;
 278         else if (!raw3270_state_ready(rp))
 279                 rc = -EBUSY;
 280         else
 281                 rc =  __raw3270_start(rp, view, rq);
 282         spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
 283         return rc;
 284 }
 285
 286 int
 287 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
 288 {
 289         struct raw3270 *rp;
 290         int rc;
 291
 292         rp = view->dev;
 293         if (!rp || rp->view != view ||
 294             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 295                 rc = -EACCES;
 296         else if (!raw3270_state_ready(rp))
 297                 rc = -EBUSY;
 298         else
 299                 rc =  __raw3270_start(rp, view, rq);
 300         return rc;
 301 }
 302
 303 int
 304 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
 305 {
 306         struct raw3270 *rp;
 307
 308         rp = view->dev;
 309         rq->view = view;
 310         raw3270_get_view(view);
 311         list_add_tail(&rq->list, &rp->req_queue);
 312         return 0;
 313 }
 314
 315 /*
 316  * 3270 interrupt routine, called from the ccw_device layer
 317  */
 318 static void
 319 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
 320 {
 321         struct raw3270 *rp;
 322         struct raw3270_view *view;
 323         struct raw3270_request *rq;
 324
 325         rp = dev_get_drvdata(&cdev->dev);
 326         if (!rp)
 327                 return;
 328         rq = (struct raw3270_request *) intparm;
 329         view = rq ? rq->view : rp->view;
 330
 331         if (!IS_ERR(irb)) {
 332                 /* Handle CE-DE-UE and subsequent UDE */
 333                 if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END)
 334                         clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
 335                 if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END |
 336                                             DEV_STAT_DEV_END |
 337                                             DEV_STAT_UNIT_EXCEP))
 338                         set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
 339                 /* Handle disconnected devices */
 340                 if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
 341                     (irb->ecw[0] & SNS0_INTERVENTION_REQ)) {
 342                         set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
 343                         if (rp->state > RAW3270_STATE_RESET)
 344                                 __raw3270_disconnect(rp);
 345                 }
 346                 /* Call interrupt handler of the view */
 347                 if (view)
 348                         view->fn->intv(view, rq, irb);
 349         }
 350
 351         if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags))
 352                 /* Device busy, do not start I/O */
 353                 return;
 354
 355         if (rq && !list_empty(&rq->list)) {
 356                 /* The request completed, remove from queue and do callback. */
 357                 list_del_init(&rq->list);
 358                 if (rq->callback)
 359                         rq->callback(rq, rq->callback_data);
 360                 /* Do put_device for get_device in raw3270_start. */
 361                 raw3270_put_view(view);
 362         }
 363
 364         /*
 365          * Try to start each request on request queue until one is
 366          * started successful.
 367          */
 368         while (!list_empty(&rp->req_queue)) {
 369                 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
 370                 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
 371                                           (unsigned long) rq, 0, 0);
 372                 if (rq->rc == 0)
 373                         break;
 374                 /* Start failed. Remove request and do callback. */
 375                 list_del_init(&rq->list);
 376                 if (rq->callback)
 377                         rq->callback(rq, rq->callback_data);
 378                 /* Do put_device for get_device in raw3270_start. */
 379                 raw3270_put_view(view);
 380         }
 381 }
 382
 383 /*
 384  * To determine the size of the 3270 device we need to do:
 385  * 1) send a 'read partition' data stream to the device
 386  * 2) wait for the attn interrupt that precedes the query reply
 387  * 3) do a read modified to get the query reply
 388  * To make things worse we have to cope with intervention
 389  * required (3270 device switched to 'stand-by') and command
 390  * rejects (old devices that can't do 'read partition').
 391  */
 392 struct raw3270_ua {     /* Query Reply structure for Usable Area */
 393         struct {        /* Usable Area Query Reply Base */
 394                 short l;        /* Length of this structured field */
 395                 char  sfid;     /* 0x81 if Query Reply */
 396                 char  qcode;    /* 0x81 if Usable Area */
 397                 char  flags0;
 398                 char  flags1;
 399                 short w;        /* Width of usable area */
 400                 short h;        /* Heigth of usavle area */
 401                 char  units;    /* 0x00:in; 0x01:mm */
 402                 int   xr;
 403                 int   yr;
 404                 char  aw;
 405                 char  ah;
 406                 short buffsz;   /* Character buffer size, bytes */
 407                 char  xmin;
 408                 char  ymin;
 409                 char  xmax;
 410                 char  ymax;
 411         } __attribute__ ((packed)) uab;
 412         struct {        /* Alternate Usable Area Self-Defining Parameter */
 413                 char  l;        /* Length of this Self-Defining Parm */
 414                 char  sdpid;    /* 0x02 if Alternate Usable Area */
 415                 char  res;
 416                 char  auaid;    /* 0x01 is Id for the A U A */
 417                 short wauai;    /* Width of AUAi */
 418                 short hauai;    /* Height of AUAi */
 419                 char  auaunits; /* 0x00:in, 0x01:mm */
 420                 int   auaxr;
 421                 int   auayr;
 422                 char  awauai;
 423                 char  ahauai;
 424         } __attribute__ ((packed)) aua;
 425 } __attribute__ ((packed));
 426
 427 static void
 428 raw3270_size_device_vm(struct raw3270 *rp)
 429 {
 430         int rc, model;
 431         struct ccw_dev_id dev_id;
 432         struct diag210 diag_data;
 433
 434         ccw_device_get_id(rp->cdev, &dev_id);
 435         diag_data.vrdcdvno = dev_id.devno;
 436         diag_data.vrdclen = sizeof(struct diag210);
 437         rc = diag210(&diag_data);
 438         model = diag_data.vrdccrmd;
 439         /* Use default model 2 if the size could not be detected */
 440         if (rc || model < 2 || model > 5)
 441                 model = 2;
 442         switch (model) {
 443         case 2:
 444                 rp->model = model;
 445                 rp->rows = 24;
 446                 rp->cols = 80;
 447                 break;
 448         case 3:
 449                 rp->model = model;
 450                 rp->rows = 32;
 451                 rp->cols = 80;
 452                 break;
 453         case 4:
 454                 rp->model = model;
 455                 rp->rows = 43;
 456                 rp->cols = 80;
 457                 break;
 458         case 5:
 459                 rp->model = model;
 460                 rp->rows = 27;
 461                 rp->cols = 132;
 462                 break;
 463         }
 464 }
 465
 466 static void
 467 raw3270_size_device(struct raw3270 *rp)
 468 {
 469         struct raw3270_ua *uap;
 470
 471         /* Got a Query Reply */
 472         uap = (struct raw3270_ua *) (rp->init_data + 1);
 473         /* Paranoia check. */
 474         if (rp->init_readmod.rc || rp->init_data[0] != 0x88 ||
 475             uap->uab.qcode != 0x81) {
 476                 /* Couldn't detect size. Use default model 2. */
 477                 rp->model = 2;
 478                 rp->rows = 24;
 479                 rp->cols = 80;
 480                 return;
 481         }
 482         /* Copy rows/columns of default Usable Area */
 483         rp->rows = uap->uab.h;
 484         rp->cols = uap->uab.w;
 485         /* Check for 14 bit addressing */
 486         if ((uap->uab.flags0 & 0x0d) == 0x01)
 487                 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
 488         /* Check for Alternate Usable Area */
 489         if (uap->uab.l == sizeof(struct raw3270_ua) &&
 490             uap->aua.sdpid == 0x02) {
 491                 rp->rows = uap->aua.hauai;
 492                 rp->cols = uap->aua.wauai;
 493         }
 494         /* Try to find a model. */
 495         rp->model = 0;
 496         if (rp->rows == 24 && rp->cols == 80)
 497                 rp->model = 2;
 498         if (rp->rows == 32 && rp->cols == 80)
 499                 rp->model = 3;
 500         if (rp->rows == 43 && rp->cols == 80)
 501                 rp->model = 4;
 502         if (rp->rows == 27 && rp->cols == 132)
 503                 rp->model = 5;
 504 }
 505
 506 static void
 507 raw3270_size_device_done(struct raw3270 *rp)
 508 {
 509         struct raw3270_view *view;
 510
 511         rp->view = NULL;
 512         rp->state = RAW3270_STATE_READY;
 513         /* Notify views about new size */
 514         list_for_each_entry(view, &rp->view_list, list)
 515                 if (view->fn->resize)
 516                         view->fn->resize(view, rp->model, rp->rows, rp->cols);
 517         /* Setup processing done, now activate a view */
 518         list_for_each_entry(view, &rp->view_list, list) {
 519                 rp->view = view;
 520                 if (view->fn->activate(view) == 0)
 521                         break;
 522                 rp->view = NULL;
 523         }
 524 }
 525
 526 static void
 527 raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
 528 {
 529         struct raw3270 *rp = rq->view->dev;
 530
 531         raw3270_size_device(rp);
 532         raw3270_size_device_done(rp);
 533 }
 534
 535 static void
 536 raw3270_read_modified(struct raw3270 *rp)
 537 {
 538         if (rp->state != RAW3270_STATE_W4ATTN)
 539                 return;
 540         /* Use 'read modified' to get the result of a read partition. */
 541         memset(&rp->init_readmod, 0, sizeof(rp->init_readmod));
 542         memset(&rp->init_data, 0, sizeof(rp->init_data));
 543         rp->init_readmod.ccw.cmd_code = TC_READMOD;
 544         rp->init_readmod.ccw.flags = CCW_FLAG_SLI;
 545         rp->init_readmod.ccw.count = sizeof(rp->init_data);
 546         rp->init_readmod.ccw.cda = (__u32) __pa(rp->init_data);
 547         rp->init_readmod.callback = raw3270_read_modified_cb;
 548         rp->state = RAW3270_STATE_READMOD;
 549         raw3270_start_irq(&rp->init_view, &rp->init_readmod);
 550 }
 551
 552 static void
 553 raw3270_writesf_readpart(struct raw3270 *rp)
 554 {
 555         static const unsigned char wbuf[] =
 556                 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
 557
 558         /* Store 'read partition' data stream to init_data */
 559         memset(&rp->init_readpart, 0, sizeof(rp->init_readpart));
 560         memset(&rp->init_data, 0, sizeof(rp->init_data));
 561         memcpy(&rp->init_data, wbuf, sizeof(wbuf));
 562         rp->init_readpart.ccw.cmd_code = TC_WRITESF;
 563         rp->init_readpart.ccw.flags = CCW_FLAG_SLI;
 564         rp->init_readpart.ccw.count = sizeof(wbuf);
 565         rp->init_readpart.ccw.cda = (__u32) __pa(&rp->init_data);
 566         rp->state = RAW3270_STATE_W4ATTN;
 567         raw3270_start_irq(&rp->init_view, &rp->init_readpart);
 568 }
 569
 570 /*
 571  * Device reset
 572  */
 573 static void
 574 raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
 575 {
 576         struct raw3270 *rp = rq->view->dev;
 577
 578         if (rp->state != RAW3270_STATE_RESET)
 579                 return;
 580         if (rq->rc) {
 581                 /* Reset command failed. */
 582                 rp->state = RAW3270_STATE_INIT;
 583         } else if (MACHINE_IS_VM) {
 584                 raw3270_size_device_vm(rp);
 585                 raw3270_size_device_done(rp);
 586         } else
 587                 raw3270_writesf_readpart(rp);
 588         memset(&rp->init_reset, 0, sizeof(rp->init_reset));
 589 }
 590
 591 static int
 592 __raw3270_reset_device(struct raw3270 *rp)
 593 {
 594         int rc;
 595
 596         /* Check if reset is already pending */
 597         if (rp->init_reset.view)
 598                 return -EBUSY;
 599         /* Store reset data stream to init_data/init_reset */
 600         rp->init_data[0] = TW_KR;
 601         rp->init_reset.ccw.cmd_code = TC_EWRITEA;
 602         rp->init_reset.ccw.flags = CCW_FLAG_SLI;
 603         rp->init_reset.ccw.count = 1;
 604         rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
 605         rp->init_reset.callback = raw3270_reset_device_cb;
 606         rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
 607         if (rc == 0 && rp->state == RAW3270_STATE_INIT)
 608                 rp->state = RAW3270_STATE_RESET;
 609         return rc;
 610 }
 611
 612 static int
 613 raw3270_reset_device(struct raw3270 *rp)
 614 {
 615         unsigned long flags;
 616         int rc;
 617
 618         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 619         rc = __raw3270_reset_device(rp);
 620         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 621         return rc;
 622 }
 623
 624 int
 625 raw3270_reset(struct raw3270_view *view)
 626 {
 627         struct raw3270 *rp;
 628         int rc;
 629
 630         rp = view->dev;
 631         if (!rp || rp->view != view ||
 632             test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 633                 rc = -EACCES;
 634         else if (!raw3270_state_ready(rp))
 635                 rc = -EBUSY;
 636         else
 637                 rc = raw3270_reset_device(view->dev);
 638         return rc;
 639 }
 640
 641 static void
 642 __raw3270_disconnect(struct raw3270 *rp)
 643 {
 644         struct raw3270_request *rq;
 645         struct raw3270_view *view;
 646
 647         rp->state = RAW3270_STATE_INIT;
 648         rp->view = &rp->init_view;
 649         /* Cancel all queued requests */
 650         while (!list_empty(&rp->req_queue)) {
 651                 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
 652                 view = rq->view;
 653                 rq->rc = -EACCES;
 654                 list_del_init(&rq->list);
 655                 if (rq->callback)
 656                         rq->callback(rq, rq->callback_data);
 657                 raw3270_put_view(view);
 658         }
 659         /* Start from scratch */
 660         __raw3270_reset_device(rp);
 661 }
 662
 663 static void
 664 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
 665                  struct irb *irb)
 666 {
 667         struct raw3270 *rp;
 668
 669         if (rq) {
 670                 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
 671                         if (irb->ecw[0] & SNS0_CMD_REJECT)
 672                                 rq->rc = -EOPNOTSUPP;
 673                         else
 674                                 rq->rc = -EIO;
 675                 }
 676         }
 677         if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
 678                 /* Queue read modified after attention interrupt */
 679                 rp = view->dev;
 680                 raw3270_read_modified(rp);
 681         }
 682 }
 683
 684 static struct raw3270_fn raw3270_init_fn = {
 685         .intv = raw3270_init_irq
 686 };
 687
 688 /*
 689  * Setup new 3270 device.
 690  */
 691 static int
 692 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
 693 {
 694         struct list_head *l;
 695         struct raw3270 *tmp;
 696         int minor;
 697
 698         memset(rp, 0, sizeof(struct raw3270));
 699         /* Copy ebcdic -> ascii translation table. */
 700         memcpy(ascebc, _ascebc, 256);
 701         if (tubxcorrect) {
 702                 /* correct brackets and circumflex */
 703                 ascebc['['] = 0xad;
 704                 ascebc[']'] = 0xbd;
 705                 ascebc['^'] = 0xb0;
 706         }
 707         rp->ascebc = ascebc;
 708
 709         /* Set defaults. */
 710         rp->rows = 24;
 711         rp->cols = 80;
 712
 713         INIT_LIST_HEAD(&rp->req_queue);
 714         INIT_LIST_HEAD(&rp->view_list);
 715
 716         rp->init_view.dev = rp;
 717         rp->init_view.fn = &raw3270_init_fn;
 718         rp->view = &rp->init_view;
 719
 720         /*
 721          * Add device to list and find the smallest unused minor
 722          * number for it. Note: there is no device with minor 0,
 723          * see special case for fs3270.c:fs3270_open().
 724          */
 725         mutex_lock(&raw3270_mutex);
 726         /* Keep the list sorted. */
 727         minor = RAW3270_FIRSTMINOR;
 728         rp->minor = -1;
 729         list_for_each(l, &raw3270_devices) {
 730                 tmp = list_entry(l, struct raw3270, list);
 731                 if (tmp->minor > minor) {
 732                         rp->minor = minor;
 733                         __list_add(&rp->list, l->prev, l);
 734                         break;
 735                 }
 736                 minor++;
 737         }
 738         if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
 739                 rp->minor = minor;
 740                 list_add_tail(&rp->list, &raw3270_devices);
 741         }
 742         mutex_unlock(&raw3270_mutex);
 743         /* No free minor number? Then give up. */
 744         if (rp->minor == -1)
 745                 return -EUSERS;
 746         rp->cdev = cdev;
 747         dev_set_drvdata(&cdev->dev, rp);
 748         cdev->handler = raw3270_irq;
 749         return 0;
 750 }
 751
 752 #ifdef CONFIG_TN3270_CONSOLE
 753 /* Tentative definition - see below for actual definition. */
 754 static struct ccw_driver raw3270_ccw_driver;
 755
 756 /*
 757  * Setup 3270 device configured as console.
 758  */
 759 struct raw3270 __init *raw3270_setup_console(void)
 760 {
 761         struct ccw_device *cdev;
 762         unsigned long flags;
 763         struct raw3270 *rp;
 764         char *ascebc;
 765         int rc;
 766
 767         cdev = ccw_device_create_console(&raw3270_ccw_driver);
 768         if (IS_ERR(cdev))
 769                 return ERR_CAST(cdev);
 770
 771         rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 772         ascebc = kzalloc(256, GFP_KERNEL);
 773         rc = raw3270_setup_device(cdev, rp, ascebc);
 774         if (rc)
 775                 return ERR_PTR(rc);
 776         set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
 777
 778         rc = ccw_device_enable_console(cdev);
 779         if (rc) {
 780                 ccw_device_destroy_console(cdev);
 781                 return ERR_PTR(rc);
 782         }
 783
 784         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 785         do {
 786                 __raw3270_reset_device(rp);
 787                 while (!raw3270_state_final(rp)) {
 788                         ccw_device_wait_idle(rp->cdev);
 789                         barrier();
 790                 }
 791         } while (rp->state != RAW3270_STATE_READY);
 792         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 793         return rp;
 794 }
 795
 796 void
 797 raw3270_wait_cons_dev(struct raw3270 *rp)
 798 {
 799         unsigned long flags;
 800
 801         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 802         ccw_device_wait_idle(rp->cdev);
 803         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 804 }
 805
 806 #endif
 807
 808 /*
 809  * Create a 3270 device structure.
 810  */
 811 static struct raw3270 *
 812 raw3270_create_device(struct ccw_device *cdev)
 813 {
 814         struct raw3270 *rp;
 815         char *ascebc;
 816         int rc;
 817
 818         rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
 819         if (!rp)
 820                 return ERR_PTR(-ENOMEM);
 821         ascebc = kmalloc(256, GFP_KERNEL);
 822         if (!ascebc) {
 823                 kfree(rp);
 824                 return ERR_PTR(-ENOMEM);
 825         }
 826         rc = raw3270_setup_device(cdev, rp, ascebc);
 827         if (rc) {
 828                 kfree(rp->ascebc);
 829                 kfree(rp);
 830                 rp = ERR_PTR(rc);
 831         }
 832         /* Get reference to ccw_device structure. */
 833         get_device(&cdev->dev);
 834         return rp;
 835 }
 836
 837 /*
 838  * Activate a view.
 839  */
 840 int
 841 raw3270_activate_view(struct raw3270_view *view)
 842 {
 843         struct raw3270 *rp;
 844         struct raw3270_view *oldview, *nv;
 845         unsigned long flags;
 846         int rc;
 847
 848         rp = view->dev;
 849         if (!rp)
 850                 return -ENODEV;
 851         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 852         if (rp->view == view)
 853                 rc = 0;
 854         else if (!raw3270_state_ready(rp))
 855                 rc = -EBUSY;
 856         else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
 857                 rc = -EACCES;
 858         else {
 859                 oldview = NULL;
 860                 if (rp->view && rp->view->fn->deactivate) {
 861                         oldview = rp->view;
 862                         oldview->fn->deactivate(oldview);
 863                 }
 864                 rp->view = view;
 865                 rc = view->fn->activate(view);
 866                 if (rc) {
 867                         /* Didn't work. Try to reactivate the old view. */
 868                         rp->view = oldview;
 869                         if (!oldview || oldview->fn->activate(oldview) != 0) {
 870                                 /* Didn't work as well. Try any other view. */
 871                                 list_for_each_entry(nv, &rp->view_list, list)
 872                                         if (nv != view && nv != oldview) {
 873                                                 rp->view = nv;
 874                                                 if (nv->fn->activate(nv) == 0)
 875                                                         break;
 876                                                 rp->view = NULL;
 877                                         }
 878                         }
 879                 }
 880         }
 881         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 882         return rc;
 883 }
 884
 885 /*
 886  * Deactivate current view.
 887  */
 888 void
 889 raw3270_deactivate_view(struct raw3270_view *view)
 890 {
 891         unsigned long flags;
 892         struct raw3270 *rp;
 893
 894         rp = view->dev;
 895         if (!rp)
 896                 return;
 897         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 898         if (rp->view == view) {
 899                 view->fn->deactivate(view);
 900                 rp->view = NULL;
 901                 /* Move deactivated view to end of list. */
 902                 list_del_init(&view->list);
 903                 list_add_tail(&view->list, &rp->view_list);
 904                 /* Try to activate another view. */
 905                 if (raw3270_state_ready(rp) &&
 906                     !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
 907                         list_for_each_entry(view, &rp->view_list, list) {
 908                                 rp->view = view;
 909                                 if (view->fn->activate(view) == 0)
 910                                         break;
 911                                 rp->view = NULL;
 912                         }
 913                 }
 914         }
 915         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 916 }
 917
 918 /*
 919  * Add view to device with minor "minor".
 920  */
 921 int
 922 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
 923 {
 924         unsigned long flags;
 925         struct raw3270 *rp;
 926         int rc;
 927
 928         if (minor <= 0)
 929                 return -ENODEV;
 930         mutex_lock(&raw3270_mutex);
 931         rc = -ENODEV;
 932         list_for_each_entry(rp, &raw3270_devices, list) {
 933                 if (rp->minor != minor)
 934                         continue;
 935                 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
 936                 atomic_set(&view->ref_count, 2);
 937                 view->dev = rp;
 938                 view->fn = fn;
 939                 view->model = rp->model;
 940                 view->rows = rp->rows;
 941                 view->cols = rp->cols;
 942                 view->ascebc = rp->ascebc;
 943                 spin_lock_init(&view->lock);
 944                 lockdep_set_subclass(&view->lock, subclass);
 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 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);