drivers/s390/char/raw3270.c

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

DEFINITIONS
