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