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