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