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