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