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); 1457