1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/err.h>
12#include <linux/init.h>
13#include <linux/interrupt.h>
14#include <linux/list.h>
15#include <linux/slab.h>
16#include <linux/types.h>
17#include <linux/wait.h>
18
19#include <asm/ccwdev.h>
20#include <asm/cio.h>
21#include <asm/ebcdic.h>
22#include <asm/diag.h>
23
24#include "raw3270.h"
25
26#include <linux/major.h>
27#include <linux/kdev_t.h>
28#include <linux/device.h>
29#include <linux/mutex.h>
30
31static struct class *class3270;
32
33
34struct raw3270 {
35 struct list_head list;
36 struct ccw_device *cdev;
37 int minor;
38
39 short model, rows, cols;
40 unsigned long flags;
41
42 struct list_head req_queue;
43 struct list_head view_list;
44 struct raw3270_view *view;
45
46 struct timer_list timer;
47
48 unsigned char *ascebc;
49 struct device *clttydev;
50 struct device *cltubdev;
51
52 struct raw3270_request init_request;
53 unsigned char init_data[256];
54};
55
56
57#define RAW3270_FLAGS_14BITADDR 0
58#define RAW3270_FLAGS_BUSY 1
59#define RAW3270_FLAGS_ATTN 2
60#define RAW3270_FLAGS_READY 4
61#define RAW3270_FLAGS_CONSOLE 8
62#define RAW3270_FLAGS_FROZEN 16
63
64
65static DEFINE_MUTEX(raw3270_mutex);
66
67
68static LIST_HEAD(raw3270_devices);
69
70
71
72
73
74
75static int raw3270_registered;
76
77
78static int tubxcorrect = 0;
79module_param(tubxcorrect, bool, 0);
80
81
82
83
84DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
85
86
87
88
89static unsigned char raw3270_ebcgraf[64] = {
90 0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
91 0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
92 0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
93 0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
94 0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
95 0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
96 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
97 0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
98};
99
100void
101raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
102{
103 if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
104 cp[0] = (addr >> 8) & 0x3f;
105 cp[1] = addr & 0xff;
106 } else {
107 cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
108 cp[1] = raw3270_ebcgraf[addr & 0x3f];
109 }
110}
111
112
113
114
115struct raw3270_request *
116raw3270_request_alloc(size_t size)
117{
118 struct raw3270_request *rq;
119
120
121 rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
122 if (!rq)
123 return ERR_PTR(-ENOMEM);
124
125
126 if (size > 0) {
127 rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
128 if (!rq->buffer) {
129 kfree(rq);
130 return ERR_PTR(-ENOMEM);
131 }
132 }
133 rq->size = size;
134 INIT_LIST_HEAD(&rq->list);
135
136
137
138
139 rq->ccw.cda = __pa(rq->buffer);
140 rq->ccw.flags = CCW_FLAG_SLI;
141
142 return rq;
143}
144
145
146
147
148void
149raw3270_request_free (struct raw3270_request *rq)
150{
151 kfree(rq->buffer);
152 kfree(rq);
153}
154
155
156
157
158void
159raw3270_request_reset(struct raw3270_request *rq)
160{
161 BUG_ON(!list_empty(&rq->list));
162 rq->ccw.cmd_code = 0;
163 rq->ccw.count = 0;
164 rq->ccw.cda = __pa(rq->buffer);
165 rq->ccw.flags = CCW_FLAG_SLI;
166 rq->rescnt = 0;
167 rq->rc = 0;
168}
169
170
171
172
173void
174raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
175{
176 rq->ccw.cmd_code = cmd;
177}
178
179
180
181
182int
183raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
184{
185 if (size + rq->ccw.count > rq->size)
186 return -E2BIG;
187 memcpy(rq->buffer + rq->ccw.count, data, size);
188 rq->ccw.count += size;
189 return 0;
190}
191
192
193
194
195void
196raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
197{
198 rq->ccw.cda = __pa(data);
199 rq->ccw.count = size;
200}
201
202
203
204
205void
206raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
207{
208 rq->ccw.cda = __pa(ib->data);
209 rq->ccw.count = ib->size;
210 rq->ccw.flags |= CCW_FLAG_IDA;
211}
212
213
214
215
216static int
217raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
218{
219 int retries;
220 int rc;
221
222 if (raw3270_request_final(rq))
223 return 0;
224
225 for (retries = 0; retries < 5; retries++) {
226 if (retries < 2)
227 rc = ccw_device_halt(rp->cdev, (long) rq);
228 else
229 rc = ccw_device_clear(rp->cdev, (long) rq);
230 if (rc == 0)
231 break;
232 }
233 return rc;
234}
235
236static int
237raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
238{
239 unsigned long flags;
240 int rc;
241
242 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
243 rc = raw3270_halt_io_nolock(rp, rq);
244 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
245 return rc;
246}
247
248
249
250
251
252static int
253__raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
254 struct raw3270_request *rq)
255{
256 rq->view = view;
257 raw3270_get_view(view);
258 if (list_empty(&rp->req_queue) &&
259 !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
260
261 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
262 (unsigned long) rq, 0, 0);
263 if (rq->rc) {
264 raw3270_put_view(view);
265 return rq->rc;
266 }
267 }
268 list_add_tail(&rq->list, &rp->req_queue);
269 return 0;
270}
271
272int
273raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
274{
275 unsigned long flags;
276 struct raw3270 *rp;
277 int rc;
278
279 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
280 rp = view->dev;
281 if (!rp || rp->view != view ||
282 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
283 rc = -EACCES;
284 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
285 rc = -ENODEV;
286 else
287 rc = __raw3270_start(rp, view, rq);
288 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
289 return rc;
290}
291
292int
293raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
294{
295 struct raw3270 *rp;
296 int rc;
297
298 rp = view->dev;
299 if (!rp || rp->view != view ||
300 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
301 rc = -EACCES;
302 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
303 rc = -ENODEV;
304 else
305 rc = __raw3270_start(rp, view, rq);
306 return rc;
307}
308
309int
310raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
311{
312 struct raw3270 *rp;
313
314 rp = view->dev;
315 rq->view = view;
316 raw3270_get_view(view);
317 list_add_tail(&rq->list, &rp->req_queue);
318 return 0;
319}
320
321
322
323
324static void
325raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
326{
327 struct raw3270 *rp;
328 struct raw3270_view *view;
329 struct raw3270_request *rq;
330 int rc;
331
332 rp = dev_get_drvdata(&cdev->dev);
333 if (!rp)
334 return;
335 rq = (struct raw3270_request *) intparm;
336 view = rq ? rq->view : rp->view;
337
338 if (IS_ERR(irb))
339 rc = RAW3270_IO_RETRY;
340 else if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
341 rq->rc = -EIO;
342 rc = RAW3270_IO_DONE;
343 } else if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END |
344 DEV_STAT_UNIT_EXCEP)) {
345
346 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
347 rc = RAW3270_IO_BUSY;
348 } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
349
350 if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
351 clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
352
353 rc = RAW3270_IO_RETRY;
354 } else
355 rc = RAW3270_IO_BUSY;
356 } else if (view)
357 rc = view->fn->intv(view, rq, irb);
358 else
359 rc = RAW3270_IO_DONE;
360
361 switch (rc) {
362 case RAW3270_IO_DONE:
363 break;
364 case RAW3270_IO_BUSY:
365
366
367
368
369 return;
370 case RAW3270_IO_RETRY:
371 if (!rq)
372 break;
373 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
374 (unsigned long) rq, 0, 0);
375 if (rq->rc == 0)
376 return;
377 break;
378 case RAW3270_IO_STOP:
379 if (!rq)
380 break;
381 raw3270_halt_io_nolock(rp, rq);
382 rq->rc = -EIO;
383 break;
384 default:
385 BUG();
386 }
387 if (rq) {
388 BUG_ON(list_empty(&rq->list));
389
390 list_del_init(&rq->list);
391 if (rq->callback)
392 rq->callback(rq, rq->callback_data);
393
394 raw3270_put_view(view);
395 }
396
397
398
399
400 while (!list_empty(&rp->req_queue)) {
401 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
402 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
403 (unsigned long) rq, 0, 0);
404 if (rq->rc == 0)
405 break;
406
407 list_del_init(&rq->list);
408 if (rq->callback)
409 rq->callback(rq, rq->callback_data);
410
411 raw3270_put_view(view);
412 }
413}
414
415
416
417
418
419struct raw3270_ua {
420 struct {
421 short l;
422 char sfid;
423 char qcode;
424 char flags0;
425 char flags1;
426 short w;
427 short h;
428 char units;
429 int xr;
430 int yr;
431 char aw;
432 char ah;
433 short buffsz;
434 char xmin;
435 char ymin;
436 char xmax;
437 char ymax;
438 } __attribute__ ((packed)) uab;
439 struct {
440 char l;
441 char sdpid;
442 char res;
443 char auaid;
444 short wauai;
445 short hauai;
446 char auaunits;
447 int auaxr;
448 int auayr;
449 char awauai;
450 char ahauai;
451 } __attribute__ ((packed)) aua;
452} __attribute__ ((packed));
453
454static struct diag210 raw3270_init_diag210;
455static DEFINE_MUTEX(raw3270_init_mutex);
456
457static int
458raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
459 struct irb *irb)
460{
461
462
463
464
465 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
466
467 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
468 set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
469 return RAW3270_IO_BUSY;
470 }
471 }
472 if (rq) {
473 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
474 if (irb->ecw[0] & SNS0_CMD_REJECT)
475 rq->rc = -EOPNOTSUPP;
476 else
477 rq->rc = -EIO;
478 } else
479
480 rq->rescnt = irb->scsw.cmd.count;
481 }
482 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
483 set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags);
484 wake_up(&raw3270_wait_queue);
485 }
486 return RAW3270_IO_DONE;
487}
488
489static struct raw3270_fn raw3270_init_fn = {
490 .intv = raw3270_init_irq
491};
492
493static struct raw3270_view raw3270_init_view = {
494 .fn = &raw3270_init_fn
495};
496
497
498
499
500
501
502
503static void
504raw3270_wake_init(struct raw3270_request *rq, void *data)
505{
506 wake_up((wait_queue_head_t *) data);
507}
508
509
510
511
512static int
513raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
514 struct raw3270_request *rq)
515{
516 unsigned long flags;
517 int rc;
518
519#ifdef CONFIG_TN3270_CONSOLE
520 if (raw3270_registered == 0) {
521 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
522 rq->callback = NULL;
523 rc = __raw3270_start(rp, view, rq);
524 if (rc == 0)
525 while (!raw3270_request_final(rq)) {
526 wait_cons_dev();
527 barrier();
528 }
529 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
530 return rq->rc;
531 }
532#endif
533 rq->callback = raw3270_wake_init;
534 rq->callback_data = &raw3270_wait_queue;
535 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
536 rc = __raw3270_start(rp, view, rq);
537 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
538 if (rc)
539 return rc;
540
541 rc = wait_event_interruptible(raw3270_wait_queue,
542 raw3270_request_final(rq));
543 if (rc == -ERESTARTSYS) {
544 raw3270_halt_io(view->dev, rq);
545
546 wait_event(raw3270_wait_queue, raw3270_request_final(rq));
547 return -ERESTARTSYS;
548 }
549 return rq->rc;
550}
551
552static int
553__raw3270_size_device_vm(struct raw3270 *rp)
554{
555 int rc, model;
556 struct ccw_dev_id dev_id;
557
558 ccw_device_get_id(rp->cdev, &dev_id);
559 raw3270_init_diag210.vrdcdvno = dev_id.devno;
560 raw3270_init_diag210.vrdclen = sizeof(struct diag210);
561 rc = diag210(&raw3270_init_diag210);
562 if (rc)
563 return rc;
564 model = raw3270_init_diag210.vrdccrmd;
565 switch (model) {
566 case 2:
567 rp->model = model;
568 rp->rows = 24;
569 rp->cols = 80;
570 break;
571 case 3:
572 rp->model = model;
573 rp->rows = 32;
574 rp->cols = 80;
575 break;
576 case 4:
577 rp->model = model;
578 rp->rows = 43;
579 rp->cols = 80;
580 break;
581 case 5:
582 rp->model = model;
583 rp->rows = 27;
584 rp->cols = 132;
585 break;
586 default:
587 rc = -EOPNOTSUPP;
588 break;
589 }
590 return rc;
591}
592
593static int
594__raw3270_size_device(struct raw3270 *rp)
595{
596 static const unsigned char wbuf[] =
597 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
598 struct raw3270_ua *uap;
599 unsigned short count;
600 int rc;
601
602
603
604
605
606
607
608
609
610
611 memset(&rp->init_request, 0, sizeof(rp->init_request));
612 memset(&rp->init_data, 0, 256);
613
614 memcpy(&rp->init_data, wbuf, sizeof(wbuf));
615 INIT_LIST_HEAD(&rp->init_request.list);
616 rp->init_request.ccw.cmd_code = TC_WRITESF;
617 rp->init_request.ccw.flags = CCW_FLAG_SLI;
618 rp->init_request.ccw.count = sizeof(wbuf);
619 rp->init_request.ccw.cda = (__u32) __pa(&rp->init_data);
620
621 rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
622 if (rc)
623
624 return rc;
625
626
627#ifdef CONFIG_TN3270_CONSOLE
628 if (raw3270_registered == 0) {
629 unsigned long flags;
630
631 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
632 while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags))
633 wait_cons_dev();
634 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
635 } else
636#endif
637 rc = wait_event_interruptible(raw3270_wait_queue,
638 test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags));
639 if (rc)
640 return rc;
641
642
643
644
645
646 rp->init_request.ccw.cmd_code = TC_READMOD;
647 rp->init_request.ccw.flags = CCW_FLAG_SLI;
648 rp->init_request.ccw.count = sizeof(rp->init_data);
649 rp->init_request.ccw.cda = (__u32) __pa(rp->init_data);
650 rc = raw3270_start_init(rp, &raw3270_init_view, &rp->init_request);
651 if (rc)
652 return rc;
653
654 count = sizeof(rp->init_data) - rp->init_request.rescnt;
655 uap = (struct raw3270_ua *) (rp->init_data + 1);
656
657 if (rp->init_data[0] != 0x88 || uap->uab.qcode != 0x81)
658 return -EOPNOTSUPP;
659
660 rp->rows = uap->uab.h;
661 rp->cols = uap->uab.w;
662
663 if ((uap->uab.flags0 & 0x0d) == 0x01)
664 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
665
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) {
690
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
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
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
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
763 memcpy(ascebc, _ascebc, 256);
764 if (tubxcorrect) {
765
766 ascebc['['] = 0xad;
767 ascebc[']'] = 0xbd;
768 ascebc['^'] = 0xb0;
769 }
770 rp->ascebc = ascebc;
771
772
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
781
782
783
784 mutex_lock(&raw3270_mutex);
785
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
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
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
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
877 get_device(&cdev->dev);
878 return rp;
879}
880
881
882
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
912 rp->view = oldview;
913 if (!oldview || oldview->fn->activate(oldview) != 0) {
914
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
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
946 list_del_init(&view->list);
947 list_add_tail(&view->list, &rp->view_list);
948
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
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
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
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
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
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
1069
1070static void
1071raw3270_delete_device(struct raw3270 *rp)
1072{
1073 struct ccw_device *cdev;
1074
1075
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
1085 cdev = rp->cdev;
1086 rp->cdev = NULL;
1087 dev_set_drvdata(&cdev->dev, NULL);
1088 cdev->handler = NULL;
1089
1090
1091 put_device(&cdev->dev);
1092
1093
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
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
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
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
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
1267
1268
1269
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
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
1299 raw3270_reset_device(rp);
1300
1301 raw3270_delete_device(rp);
1302}
1303
1304
1305
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
1334
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 { },
1386};
1387
1388static struct ccw_driver raw3270_ccw_driver = {
1389 .name = "3270",
1390 .owner = THIS_MODULE,
1391 .ids = raw3270_id,
1392 .probe = &raw3270_probe,
1393 .remove = &raw3270_remove,
1394 .set_online = &raw3270_set_online,
1395 .set_offline = &raw3270_set_offline,
1396 .freeze = &raw3270_pm_stop,
1397 .thaw = &raw3270_pm_start,
1398 .restore = &raw3270_pm_start,
1399};
1400
1401static int
1402raw3270_init(void)
1403{
1404 struct raw3270 *rp;
1405 int rc;
1406
1407 if (raw3270_registered)
1408 return 0;
1409 raw3270_registered = 1;
1410 rc = ccw_driver_register(&raw3270_ccw_driver);
1411 if (rc == 0) {
1412
1413 mutex_lock(&raw3270_mutex);
1414 class3270 = class_create(THIS_MODULE, "3270");
1415 list_for_each_entry(rp, &raw3270_devices, list) {
1416 get_device(&rp->cdev->dev);
1417 raw3270_create_attributes(rp);
1418 }
1419 mutex_unlock(&raw3270_mutex);
1420 }
1421 return rc;
1422}
1423
1424static void
1425raw3270_exit(void)
1426{
1427 ccw_driver_unregister(&raw3270_ccw_driver);
1428 class_destroy(class3270);
1429}
1430
1431MODULE_LICENSE("GPL");
1432
1433module_init(raw3270_init);
1434module_exit(raw3270_exit);
1435
1436EXPORT_SYMBOL(raw3270_request_alloc);
1437EXPORT_SYMBOL(raw3270_request_free);
1438EXPORT_SYMBOL(raw3270_request_reset);
1439EXPORT_SYMBOL(raw3270_request_set_cmd);
1440EXPORT_SYMBOL(raw3270_request_add_data);
1441EXPORT_SYMBOL(raw3270_request_set_data);
1442EXPORT_SYMBOL(raw3270_request_set_idal);
1443EXPORT_SYMBOL(raw3270_buffer_address);
1444EXPORT_SYMBOL(raw3270_add_view);
1445EXPORT_SYMBOL(raw3270_del_view);
1446EXPORT_SYMBOL(raw3270_find_view);
1447EXPORT_SYMBOL(raw3270_activate_view);
1448EXPORT_SYMBOL(raw3270_deactivate_view);
1449EXPORT_SYMBOL(raw3270_start);
1450EXPORT_SYMBOL(raw3270_start_locked);
1451EXPORT_SYMBOL(raw3270_start_irq);
1452EXPORT_SYMBOL(raw3270_reset);
1453EXPORT_SYMBOL(raw3270_register_notifier);
1454EXPORT_SYMBOL(raw3270_unregister_notifier);
1455EXPORT_SYMBOL(raw3270_wait_queue);
1456