2 * drivers/s390/char/raw3270.c
3 * IBM/3270 Driver - core functions.
6 * Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
7 * Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com>
8 * -- Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
11 #include <linux/config.h>
12 #include <linux/bootmem.h>
13 #include <linux/module.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/list.h>
18 #include <linux/slab.h>
19 #include <linux/types.h>
20 #include <linux/wait.h>
22 #include <asm/ccwdev.h>
24 #include <asm/ebcdic.h>
28 /* The main 3270 data structure. */
30 struct list_head list;
31 struct ccw_device *cdev;
34 short model, rows, cols;
37 struct list_head req_queue; /* Request queue. */
38 struct list_head view_list; /* List of available views. */
39 struct raw3270_view *view; /* Active view. */
41 struct timer_list timer; /* Device timer. */
43 unsigned char *ascebc; /* ascii -> ebcdic table */
47 #define RAW3270_FLAGS_14BITADDR 0 /* 14-bit buffer addresses */
48 #define RAW3270_FLAGS_BUSY 1 /* Device busy, leave it alone */
49 #define RAW3270_FLAGS_ATTN 2 /* Device sent an ATTN interrupt */
50 #define RAW3270_FLAGS_SHUTDOWN 4 /* Device is in offline processing */
51 #define RAW3270_FLAGS_CONSOLE 8 /* Device is the console. */
53 /* Lock to protect global data of raw3270 (devices, views, etc). */
54 static spinlock_t raw3270_lock = SPIN_LOCK_UNLOCKED;
56 /* List of 3270 devices. */
57 static struct list_head raw3270_devices = LIST_HEAD_INIT(raw3270_devices);
60 * Flag to indicate if the driver has been registered. Some operations
61 * like waiting for the end of i/o need to be done differently as long
62 * as the kernel is still starting up (console support).
64 static int raw3270_registered;
66 /* Module parameters */
67 static int tubxcorrect = 0;
68 MODULE_PARM(tubxcorrect, "i");
71 * Wait queue for device init/delete, view delete.
73 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
76 * Encode array for 12 bit 3270 addresses.
78 unsigned char raw3270_ebcgraf[64] = {
79 0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
80 0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
81 0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
82 0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
83 0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
84 0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
85 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
86 0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
90 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
92 if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
93 cp[0] = (addr >> 8) & 0x3f;
96 cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
97 cp[1] = raw3270_ebcgraf[addr & 0x3f];
102 * Allocate a new 3270 ccw request
104 struct raw3270_request *
105 raw3270_request_alloc(size_t size)
107 struct raw3270_request *rq;
109 /* Allocate request structure */
110 rq = kmalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
112 return ERR_PTR(-ENOMEM);
113 memset(rq, 0, sizeof(struct raw3270_request));
115 /* alloc output buffer. */
117 rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
120 return ERR_PTR(-ENOMEM);
124 INIT_LIST_HEAD(&rq->list);
129 rq->ccw.cda = __pa(rq->buffer);
130 rq->ccw.flags = CCW_FLAG_SLI;
135 #ifdef CONFIG_TN3270_CONSOLE
137 * Allocate a new 3270 ccw request from bootmem. Only works very
138 * early in the boot process. Only con3270.c should be using this.
140 struct raw3270_request *
141 raw3270_request_alloc_bootmem(size_t size)
143 struct raw3270_request *rq;
145 rq = alloc_bootmem_low(sizeof(struct raw3270));
147 return ERR_PTR(-ENOMEM);
148 memset(rq, 0, sizeof(struct raw3270_request));
150 /* alloc output buffer. */
152 rq->buffer = alloc_bootmem_low(size);
154 free_bootmem((unsigned long) rq,
155 sizeof(struct raw3270));
156 return ERR_PTR(-ENOMEM);
160 INIT_LIST_HEAD(&rq->list);
165 rq->ccw.cda = __pa(rq->buffer);
166 rq->ccw.flags = CCW_FLAG_SLI;
173 * Free 3270 ccw request
176 raw3270_request_free (struct raw3270_request *rq)
184 * Reset request to initial state.
187 raw3270_request_reset(struct raw3270_request *rq)
189 BUG_ON(!list_empty(&rq->list));
190 rq->ccw.cmd_code = 0;
192 rq->ccw.cda = __pa(rq->buffer);
193 rq->ccw.flags = CCW_FLAG_SLI;
199 * Set command code to ccw of a request.
202 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
204 rq->ccw.cmd_code = cmd;
208 * Add data fragment to output buffer.
211 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
213 if (size + rq->ccw.count > rq->size)
215 memcpy(rq->buffer + rq->ccw.count, data, size);
216 rq->ccw.count += size;
221 * Set address/length pair to ccw of a request.
224 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
226 rq->ccw.cda = __pa(data);
227 rq->ccw.count = size;
231 * Set idal buffer to ccw of a request.
234 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
236 rq->ccw.cda = __pa(ib->data);
237 rq->ccw.count = ib->size;
238 rq->ccw.flags |= CCW_FLAG_IDA;
245 raw3270_halt_io_nolock(struct raw3270 *rp, struct raw3270_request *rq)
250 if (raw3270_request_final(rq))
252 /* Check if interrupt has already been processed */
253 for (retries = 0; retries < 5; retries++) {
255 rc = ccw_device_halt(rp->cdev, (long) rq);
257 rc = ccw_device_clear(rp->cdev, (long) rq);
259 break; /* termination successful */
265 raw3270_halt_io(struct raw3270 *rp, struct raw3270_request *rq)
270 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
271 rc = raw3270_halt_io_nolock(rp, rq);
272 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
277 * Add the request to the request queue, try to start it if the
278 * 3270 device is idle. Return without waiting for end of i/o.
281 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
282 struct raw3270_request *rq)
285 raw3270_get_view(view);
286 if (list_empty(&rp->req_queue) &&
287 !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
288 /* No other requests are on the queue. Start this one. */
289 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
290 (unsigned long) rq, 0, 0);
292 raw3270_put_view(view);
296 list_add_tail(&rq->list, &rp->req_queue);
301 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
307 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
309 if (!rp || rp->view != view)
311 else if (test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags))
314 rc = __raw3270_start(rp, view, rq);
315 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
320 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
326 raw3270_get_view(view);
327 list_add_tail(&rq->list, &rp->req_queue);
332 * 3270 interrupt routine, called from the ccw_device layer
335 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
338 struct raw3270_view *view;
339 struct raw3270_request *rq;
342 rp = (struct raw3270 *) cdev->dev.driver_data;
345 rq = (struct raw3270_request *) intparm;
346 view = rq ? rq->view : rp->view;
349 rc = RAW3270_IO_RETRY;
350 else if (irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END |
351 DEV_STAT_UNIT_EXCEP)) {
352 /* Handle CE-DE-UE and subsequent UDE */
353 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
354 rc = RAW3270_IO_BUSY;
355 } else if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
356 /* Wait for UDE if busy flag is set. */
357 if (irb->scsw.dstat & DEV_STAT_DEV_END) {
358 clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
359 /* Got it, now retry. */
360 rc = RAW3270_IO_RETRY;
362 rc = RAW3270_IO_BUSY;
364 rc = view->fn->intv(view, rq, irb);
366 rc = RAW3270_IO_DONE;
369 case RAW3270_IO_DONE:
371 case RAW3270_IO_BUSY:
373 * Intervention required by the operator. We have to wait
374 * for unsolicited device end.
377 case RAW3270_IO_RETRY:
380 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
381 (unsigned long) rq, 0, 0);
383 return; /* Sucessfully restarted. */
385 case RAW3270_IO_STOP:
388 raw3270_halt_io_nolock(rp, rq);
395 BUG_ON(list_empty(&rq->list));
396 /* The request completed, remove from queue and do callback. */
397 list_del_init(&rq->list);
399 rq->callback(rq, rq->callback_data);
400 /* Do put_device for get_device in raw3270_start. */
401 raw3270_put_view(view);
404 * Try to start each request on request queue until one is
405 * started successful.
407 while (!list_empty(&rp->req_queue)) {
408 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
409 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
410 (unsigned long) rq, 0, 0);
413 /* Start failed. Remove request and do callback. */
414 list_del_init(&rq->list);
416 rq->callback(rq, rq->callback_data);
417 /* Do put_device for get_device in raw3270_start. */
418 raw3270_put_view(view);
426 struct raw3270_ua { /* Query Reply structure for Usable Area */
427 struct { /* Usable Area Query Reply Base */
428 short l; /* Length of this structured field */
429 char sfid; /* 0x81 if Query Reply */
430 char qcode; /* 0x81 if Usable Area */
433 short w; /* Width of usable area */
434 short h; /* Heigth of usavle area */
435 char units; /* 0x00:in; 0x01:mm */
440 short buffsz; /* Character buffer size, bytes */
445 } __attribute__ ((packed)) uab;
446 struct { /* Alternate Usable Area Self-Defining Parameter */
447 char l; /* Length of this Self-Defining Parm */
448 char sdpid; /* 0x02 if Alternate Usable Area */
450 char auaid; /* 0x01 is Id for the A U A */
451 short wauai; /* Width of AUAi */
452 short hauai; /* Height of AUAi */
453 char auaunits; /* 0x00:in, 0x01:mm */
458 } __attribute__ ((packed)) aua;
459 } __attribute__ ((packed));
461 static unsigned char raw3270_init_data[256];
462 static struct raw3270_request raw3270_init_request;
463 static struct diag210 raw3270_init_diag210;
464 static DECLARE_MUTEX(raw3270_init_sem);
467 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
471 * Unit-Check Processing:
472 * Expect Command Reject or Intervention Required.
474 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
475 /* Request finished abnormally. */
476 if (irb->ecw[0] & SNS0_INTERVENTION_REQ) {
477 set_bit(RAW3270_FLAGS_BUSY, &view->dev->flags);
478 return RAW3270_IO_BUSY;
482 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
483 if (irb->ecw[0] & SNS0_CMD_REJECT)
484 rq->rc = -EOPNOTSUPP;
488 /* Request finished normally. Copy residual count. */
489 rq->rescnt = irb->scsw.count;
491 if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
492 set_bit(RAW3270_FLAGS_ATTN, &view->dev->flags);
493 wake_up(&raw3270_wait_queue);
495 return RAW3270_IO_DONE;
498 static struct raw3270_fn raw3270_init_fn = {
499 .intv = raw3270_init_irq
502 static struct raw3270_view raw3270_init_view = {
503 .fn = &raw3270_init_fn
507 * raw3270_wait/raw3270_wait_interruptible/__raw3270_wakeup
508 * Wait for end of request. The request must have been started
509 * with raw3270_start, rc = 0. The device lock may NOT have been
510 * released between calling raw3270_start and raw3270_wait.
513 raw3270_wake_init(struct raw3270_request *rq, void *data)
515 wake_up((wait_queue_head_t *) data);
519 * Special wait function that can cope with console initialization.
522 raw3270_start_init(struct raw3270 *rp, struct raw3270_view *view,
523 struct raw3270_request *rq)
526 wait_queue_head_t wq;
529 #ifdef CONFIG_TN3270_CONSOLE
530 if (raw3270_registered == 0) {
531 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
533 rc = __raw3270_start(rp, view, rq);
535 while (!raw3270_request_final(rq)) {
539 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
543 init_waitqueue_head(&wq);
544 rq->callback = raw3270_wake_init;
545 rq->callback_data = &wq;
546 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
547 rc = __raw3270_start(rp, view, rq);
548 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
551 /* Now wait for the completion. */
552 rc = wait_event_interruptible(wq, raw3270_request_final(rq));
553 if (rc == -ERESTARTSYS) { /* Interrupted by a signal. */
554 raw3270_halt_io(view->dev, rq);
561 __raw3270_size_device_vm(struct raw3270 *rp)
565 raw3270_init_diag210.vrdcdvno =
566 _ccw_device_get_device_number(rp->cdev);
567 raw3270_init_diag210.vrdclen = sizeof(struct diag210);
568 rc = diag210(&raw3270_init_diag210);
571 model = raw3270_init_diag210.vrdccrmd;
594 printk(KERN_WARNING "vrdccrmd is 0x%.8x\n", model);
602 __raw3270_size_device(struct raw3270 *rp)
604 static const unsigned char wbuf[] =
605 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
607 struct raw3270_ua *uap;
608 unsigned short count;
612 * To determine the size of the 3270 device we need to do:
613 * 1) send a 'read partition' data stream to the device
614 * 2) wait for the attn interrupt that preceeds the query reply
615 * 3) do a read modified to get the query reply
616 * To make things worse we have to cope with intervention
617 * required (3270 device switched to 'stand-by') and command
618 * rejects (old devices that can't do 'read partition').
620 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request));
621 memset(raw3270_init_data, 0, sizeof(raw3270_init_data));
622 /* Store 'read partition' data stream to raw3270_init_data */
623 memcpy(raw3270_init_data, wbuf, sizeof(wbuf));
624 INIT_LIST_HEAD(&raw3270_init_request.list);
625 raw3270_init_request.ccw.cmd_code = TC_WRITESF;
626 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
627 raw3270_init_request.ccw.count = sizeof(wbuf);
628 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
630 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
632 /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */
633 if (rc == -EOPNOTSUPP && MACHINE_IS_VM)
634 return __raw3270_size_device_vm(rp);
638 /* Wait for attention interrupt. */
639 #ifdef CONFIG_TN3270_CONSOLE
640 if (raw3270_registered == 0) {
641 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
642 while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags))
644 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
647 rc = wait_event_interruptible(raw3270_wait_queue,
648 test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags));
653 * The device accepted the 'read partition' command. Now
654 * set up a read ccw and issue it.
656 raw3270_init_request.ccw.cmd_code = TC_READMOD;
657 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
658 raw3270_init_request.ccw.count = sizeof(raw3270_init_data);
659 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
660 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
663 /* Got a Query Reply */
664 count = sizeof(raw3270_init_data) - raw3270_init_request.rescnt;
665 uap = (struct raw3270_ua *) (raw3270_init_data + 1);
666 /* Paranoia check. */
667 if (raw3270_init_data[0] != 0x88 || uap->uab.qcode != 0x81)
669 /* Copy rows/columns of default Usable Area */
670 rp->rows = uap->uab.h;
671 rp->cols = uap->uab.w;
672 /* Check for 14 bit addressing */
673 if ((uap->uab.flags0 & 0x0d) == 0x01)
674 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
675 /* Check for Alternate Usable Area */
676 if (uap->uab.l == sizeof(struct raw3270_ua) &&
677 uap->aua.sdpid == 0x02) {
678 rp->rows = uap->aua.hauai;
679 rp->cols = uap->aua.wauai;
685 raw3270_size_device(struct raw3270 *rp)
689 down(&raw3270_init_sem);
690 rp->view = &raw3270_init_view;
691 raw3270_init_view.dev = rp;
692 rc = __raw3270_size_device(rp);
693 raw3270_init_view.dev = 0;
695 up(&raw3270_init_sem);
696 if (rc == 0) { /* Found something. */
697 /* Try to find a model. */
699 if (rp->rows == 24 && rp->cols == 80)
701 if (rp->rows == 32 && rp->cols == 80)
703 if (rp->rows == 43 && rp->cols == 80)
705 if (rp->rows == 27 && rp->cols == 132)
712 raw3270_reset_device(struct raw3270 *rp)
716 down(&raw3270_init_sem);
717 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request));
718 memset(raw3270_init_data, 0, sizeof(raw3270_init_data));
719 /* Store reset data stream to raw3270_init_data/raw3270_init_request */
720 raw3270_init_data[0] = TW_KR;
721 INIT_LIST_HEAD(&raw3270_init_request.list);
722 raw3270_init_request.ccw.cmd_code = TC_EWRITEA;
723 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
724 raw3270_init_request.ccw.count = 1;
725 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
726 rp->view = &raw3270_init_view;
727 raw3270_init_view.dev = rp;
728 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
729 raw3270_init_view.dev = 0;
731 up(&raw3270_init_sem);
736 * Setup new 3270 device.
739 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
745 memset(rp, 0, sizeof(struct raw3270));
746 /* Copy ebcdic -> ascii translation table. */
747 memcpy(ascebc, _ascebc, 256);
749 /* correct brackets and circumflex */
760 INIT_LIST_HEAD(&rp->req_queue);
761 INIT_LIST_HEAD(&rp->view_list);
764 * Add device to list and find the smallest unused minor
767 spin_lock(&raw3270_lock);
768 /* Keep the list sorted. */
771 list_for_each(l, &raw3270_devices) {
772 tmp = list_entry(l, struct raw3270, list);
773 if (tmp->minor > minor) {
775 __list_add(&rp->list, l->prev, l);
780 if (rp->minor == -1 && minor < RAW3270_MAXDEVS) {
782 list_add_tail(&rp->list, &raw3270_devices);
784 spin_unlock(&raw3270_lock);
785 /* No free minor number? Then give up. */
789 cdev->dev.driver_data = rp;
790 cdev->handler = raw3270_irq;
794 #ifdef CONFIG_TN3270_CONSOLE
796 * Setup 3270 device configured as console.
799 raw3270_setup_console(struct ccw_device *cdev)
805 rp = (struct raw3270 *) alloc_bootmem(sizeof(struct raw3270));
806 ascebc = (char *) alloc_bootmem(256);
807 rc = raw3270_setup_device(cdev, rp, ascebc);
810 set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
811 raw3270_reset_device(rp);
812 raw3270_size_device(rp);
813 raw3270_reset_device(rp);
818 raw3270_wait_cons_dev(struct raw3270 *rp)
822 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
824 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
830 * Create a 3270 device structure.
832 static struct raw3270 *
833 raw3270_create_device(struct ccw_device *cdev)
839 rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL);
841 return ERR_PTR(-ENOMEM);
842 ascebc = kmalloc(256, GFP_KERNEL);
845 return ERR_PTR(-ENOMEM);
847 rc = raw3270_setup_device(cdev, rp, ascebc);
853 /* Get reference to ccw_device structure. */
854 get_device(&cdev->dev);
862 raw3270_activate_view(struct raw3270_view *view)
865 struct raw3270_view *oldview, *nv;
872 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
873 if (rp->view == view)
875 else if (test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags))
881 oldview->fn->deactivate(oldview);
884 rc = view->fn->activate(view);
886 /* Didn't work. Try to reactivate the old view. */
888 if (!oldview || oldview->fn->activate(oldview) != 0) {
889 /* Didn't work as well. Try any other view. */
890 list_for_each_entry(nv, &rp->view_list, list)
891 if (nv != view && nv != oldview) {
893 if (nv->fn->activate(nv) == 0)
900 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
905 * Deactivate current view.
908 raw3270_deactivate_view(struct raw3270_view *view)
916 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
917 if (rp->view == view) {
918 view->fn->deactivate(view);
920 /* Move deactivated view to end of list. */
921 list_del_init(&view->list);
922 list_add_tail(&view->list, &rp->view_list);
923 /* Try to activate another view. */
924 if (!test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags)) {
925 list_for_each_entry(view, &rp->view_list, list)
926 if (view->fn->activate(view) == 0) {
932 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
936 * Add view to device with minor "minor".
939 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
945 spin_lock(&raw3270_lock);
947 list_for_each_entry(rp, &raw3270_devices, list) {
948 if (rp->minor != minor)
950 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
951 if (!test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags)) {
952 atomic_set(&view->ref_count, 2);
955 view->model = rp->model;
956 view->rows = rp->rows;
957 view->cols = rp->cols;
958 view->ascebc = rp->ascebc;
959 spin_lock_init(&view->lock);
960 list_add_tail(&view->list, &rp->view_list);
963 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
966 spin_unlock(&raw3270_lock);
971 * Find specific view of device with minor "minor".
973 struct raw3270_view *
974 raw3270_find_view(struct raw3270_fn *fn, int minor)
977 struct raw3270_view *view, *tmp;
980 spin_lock(&raw3270_lock);
981 view = ERR_PTR(-ENODEV);
982 list_for_each_entry(rp, &raw3270_devices, list) {
983 if (rp->minor != minor)
985 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
986 if (!test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags)) {
987 list_for_each_entry(tmp, &rp->view_list, list) {
989 raw3270_get_view(tmp);
994 view = ERR_PTR(-ENOENT);
995 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
998 spin_unlock(&raw3270_lock);
1003 * Remove view from device and free view structure via call to view->fn->free.
1006 raw3270_del_view(struct raw3270_view *view)
1008 unsigned long flags;
1012 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1013 if (rp->view == view) {
1014 view->fn->deactivate(view);
1017 list_del_init(&view->list);
1018 if (!rp->view && !test_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags)) {
1019 /* Try to activate another view. */
1020 list_for_each_entry(view, &rp->view_list, list)
1021 if (view->fn->activate(view) == 0) {
1026 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1027 /* Wait for reference counter to drop to zero. */
1028 atomic_dec(&view->ref_count);
1029 wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1031 view->fn->free(view);
1035 * Remove a 3270 device structure.
1038 raw3270_delete_device(struct raw3270 *rp)
1040 struct ccw_device *cdev;
1042 /* Remove from device chain. */
1043 spin_lock(&raw3270_lock);
1044 list_del_init(&rp->list);
1045 spin_unlock(&raw3270_lock);
1047 /* Disconnect from ccw_device. */
1050 cdev->dev.driver_data = 0;
1053 /* Put ccw_device structure. */
1054 put_device(&cdev->dev);
1056 /* Now free raw3270 structure. */
1062 raw3270_probe (struct ccw_device *cdev)
1068 * Additional attributes for a 3270 device
1071 raw3270_model_show(struct device *dev, char *buf)
1073 return snprintf(buf, PAGE_SIZE, "%i\n",
1074 ((struct raw3270 *) dev->driver_data)->model);
1076 static DEVICE_ATTR(model, 0444, raw3270_model_show, 0);
1079 raw3270_rows_show(struct device *dev, char *buf)
1081 return snprintf(buf, PAGE_SIZE, "%i\n",
1082 ((struct raw3270 *) dev->driver_data)->rows);
1084 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, 0);
1087 raw3270_columns_show(struct device *dev, char *buf)
1089 return snprintf(buf, PAGE_SIZE, "%i\n",
1090 ((struct raw3270 *) dev->driver_data)->cols);
1092 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, 0);
1094 static struct attribute * raw3270_attrs[] = {
1095 &dev_attr_model.attr,
1096 &dev_attr_rows.attr,
1097 &dev_attr_columns.attr,
1101 static struct attribute_group raw3270_attr_group = {
1102 .attrs = raw3270_attrs,
1106 raw3270_create_attributes(struct raw3270 *rp)
1108 //FIXME: check return code
1109 sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1112 /* Hackish. A notifier chain would be cleaner. */
1113 extern void tty3270_notifier(int index, int active);
1116 * Set 3270 device online.
1119 raw3270_set_online (struct ccw_device *cdev)
1123 rp = raw3270_create_device(cdev);
1126 raw3270_reset_device(rp);
1127 raw3270_size_device(rp);
1128 raw3270_reset_device(rp);
1129 raw3270_create_attributes(rp);
1130 tty3270_notifier(rp->minor, 1);
1135 * Remove 3270 device structure.
1138 raw3270_remove (struct ccw_device *cdev)
1140 unsigned long flags;
1142 struct raw3270_view *v;
1144 rp = cdev->dev.driver_data;
1145 set_bit(RAW3270_FLAGS_SHUTDOWN, &rp->flags);
1147 sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1149 /* Deactivate current view and remove all views. */
1150 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1152 rp->view->fn->deactivate(rp->view);
1155 while (!list_empty(&rp->view_list)) {
1156 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1159 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1160 raw3270_del_view(v);
1161 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1163 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1165 tty3270_notifier(rp->minor, 0);
1167 /* Reset 3270 device. */
1168 raw3270_reset_device(rp);
1169 /* And finally remove it. */
1170 raw3270_delete_device(rp);
1174 * Set 3270 device offline.
1177 raw3270_set_offline (struct ccw_device *cdev)
1181 rp = cdev->dev.driver_data;
1182 if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1184 raw3270_remove(cdev);
1188 static struct ccw_device_id raw3270_id[] = {
1189 { CCW_DEVICE(0x3270, 0) },
1190 { CCW_DEVICE(0x3271, 0) },
1191 { CCW_DEVICE(0x3272, 0) },
1192 { CCW_DEVICE(0x3273, 0) },
1193 { CCW_DEVICE(0x3274, 0) },
1194 { CCW_DEVICE(0x3275, 0) },
1195 { CCW_DEVICE(0x3276, 0) },
1196 { CCW_DEVICE(0x3277, 0) },
1197 { CCW_DEVICE(0x3278, 0) },
1198 { CCW_DEVICE(0x3279, 0) },
1199 { CCW_DEVICE(0x3174, 0) },
1200 { /* end of list */ },
1203 static struct ccw_driver raw3270_ccw_driver = {
1205 .owner = THIS_MODULE,
1207 .probe = &raw3270_probe,
1208 .remove = &raw3270_remove,
1209 .set_online = &raw3270_set_online,
1210 .set_offline = &raw3270_set_offline,
1219 if (raw3270_registered)
1221 raw3270_registered = 1;
1222 rc = ccw_driver_register(&raw3270_ccw_driver);
1224 /* Create attributes for early (= console) device. */
1225 spin_lock(&raw3270_lock);
1226 list_for_each_entry(rp, &raw3270_devices, list) {
1227 get_device(&rp->cdev->dev);
1228 raw3270_create_attributes(rp);
1229 tty3270_notifier(rp->minor, 1);
1231 spin_unlock(&raw3270_lock);
1239 ccw_driver_unregister(&raw3270_ccw_driver);
1242 MODULE_LICENSE("GPL");
1244 EXPORT_SYMBOL(raw3270_init);
1245 EXPORT_SYMBOL(raw3270_exit);
1246 EXPORT_SYMBOL(raw3270_request_alloc);
1247 EXPORT_SYMBOL(raw3270_request_free);
1248 EXPORT_SYMBOL(raw3270_request_reset);
1249 EXPORT_SYMBOL(raw3270_request_set_cmd);
1250 EXPORT_SYMBOL(raw3270_request_add_data);
1251 EXPORT_SYMBOL(raw3270_request_set_data);
1252 EXPORT_SYMBOL(raw3270_request_set_idal);
1253 EXPORT_SYMBOL(raw3270_buffer_address);
1254 EXPORT_SYMBOL(raw3270_add_view);
1255 EXPORT_SYMBOL(raw3270_del_view);
1256 EXPORT_SYMBOL(raw3270_find_view);
1257 EXPORT_SYMBOL(raw3270_activate_view);
1258 EXPORT_SYMBOL(raw3270_deactivate_view);
1259 EXPORT_SYMBOL(raw3270_start);
1260 EXPORT_SYMBOL(raw3270_start_irq);