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