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