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_READY 4 /* Device is useable by views */
51 #define RAW3270_FLAGS_CONSOLE 8 /* Device is the console. */
53 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
54 static DECLARE_MUTEX(raw3270_sem);
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_READY, &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 };
606 struct raw3270_ua *uap;
607 unsigned short count;
611 * To determine the size of the 3270 device we need to do:
612 * 1) send a 'read partition' data stream to the device
613 * 2) wait for the attn interrupt that preceeds the query reply
614 * 3) do a read modified to get the query reply
615 * To make things worse we have to cope with intervention
616 * required (3270 device switched to 'stand-by') and command
617 * rejects (old devices that can't do 'read partition').
619 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request));
620 memset(raw3270_init_data, 0, sizeof(raw3270_init_data));
621 /* Store 'read partition' data stream to raw3270_init_data */
622 memcpy(raw3270_init_data, wbuf, sizeof(wbuf));
623 INIT_LIST_HEAD(&raw3270_init_request.list);
624 raw3270_init_request.ccw.cmd_code = TC_WRITESF;
625 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
626 raw3270_init_request.ccw.count = sizeof(wbuf);
627 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
629 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
631 /* Check error cases: -ERESTARTSYS, -EIO and -EOPNOTSUPP */
632 if (rc == -EOPNOTSUPP && MACHINE_IS_VM)
633 return __raw3270_size_device_vm(rp);
637 /* Wait for attention interrupt. */
638 #ifdef CONFIG_TN3270_CONSOLE
639 if (raw3270_registered == 0) {
642 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
643 while (!test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags))
645 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
648 rc = wait_event_interruptible(raw3270_wait_queue,
649 test_and_clear_bit(RAW3270_FLAGS_ATTN, &rp->flags));
654 * The device accepted the 'read partition' command. Now
655 * set up a read ccw and issue it.
657 raw3270_init_request.ccw.cmd_code = TC_READMOD;
658 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
659 raw3270_init_request.ccw.count = sizeof(raw3270_init_data);
660 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
661 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
664 /* Got a Query Reply */
665 count = sizeof(raw3270_init_data) - raw3270_init_request.rescnt;
666 uap = (struct raw3270_ua *) (raw3270_init_data + 1);
667 /* Paranoia check. */
668 if (raw3270_init_data[0] != 0x88 || uap->uab.qcode != 0x81)
670 /* Copy rows/columns of default Usable Area */
671 rp->rows = uap->uab.h;
672 rp->cols = uap->uab.w;
673 /* Check for 14 bit addressing */
674 if ((uap->uab.flags0 & 0x0d) == 0x01)
675 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
676 /* Check for Alternate Usable Area */
677 if (uap->uab.l == sizeof(struct raw3270_ua) &&
678 uap->aua.sdpid == 0x02) {
679 rp->rows = uap->aua.hauai;
680 rp->cols = uap->aua.wauai;
686 raw3270_size_device(struct raw3270 *rp)
690 down(&raw3270_init_sem);
691 rp->view = &raw3270_init_view;
692 raw3270_init_view.dev = rp;
693 rc = __raw3270_size_device(rp);
694 raw3270_init_view.dev = 0;
696 up(&raw3270_init_sem);
697 if (rc == 0) { /* Found something. */
698 /* Try to find a model. */
700 if (rp->rows == 24 && rp->cols == 80)
702 if (rp->rows == 32 && rp->cols == 80)
704 if (rp->rows == 43 && rp->cols == 80)
706 if (rp->rows == 27 && rp->cols == 132)
713 raw3270_reset_device(struct raw3270 *rp)
717 down(&raw3270_init_sem);
718 memset(&raw3270_init_request, 0, sizeof(raw3270_init_request));
719 memset(raw3270_init_data, 0, sizeof(raw3270_init_data));
720 /* Store reset data stream to raw3270_init_data/raw3270_init_request */
721 raw3270_init_data[0] = TW_KR;
722 INIT_LIST_HEAD(&raw3270_init_request.list);
723 raw3270_init_request.ccw.cmd_code = TC_EWRITEA;
724 raw3270_init_request.ccw.flags = CCW_FLAG_SLI;
725 raw3270_init_request.ccw.count = 1;
726 raw3270_init_request.ccw.cda = (__u32) __pa(raw3270_init_data);
727 rp->view = &raw3270_init_view;
728 raw3270_init_view.dev = rp;
729 rc = raw3270_start_init(rp, &raw3270_init_view, &raw3270_init_request);
730 raw3270_init_view.dev = 0;
732 up(&raw3270_init_sem);
737 * Setup new 3270 device.
740 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
746 memset(rp, 0, sizeof(struct raw3270));
747 /* Copy ebcdic -> ascii translation table. */
748 memcpy(ascebc, _ascebc, 256);
750 /* correct brackets and circumflex */
761 INIT_LIST_HEAD(&rp->req_queue);
762 INIT_LIST_HEAD(&rp->view_list);
765 * Add device to list and find the smallest unused minor
769 /* Keep the list sorted. */
772 list_for_each(l, &raw3270_devices) {
773 tmp = list_entry(l, struct raw3270, list);
774 if (tmp->minor > minor) {
776 __list_add(&rp->list, l->prev, l);
781 if (rp->minor == -1 && minor < RAW3270_MAXDEVS) {
783 list_add_tail(&rp->list, &raw3270_devices);
786 /* No free minor number? Then give up. */
790 cdev->dev.driver_data = rp;
791 cdev->handler = raw3270_irq;
795 #ifdef CONFIG_TN3270_CONSOLE
797 * Setup 3270 device configured as console.
800 raw3270_setup_console(struct ccw_device *cdev)
806 rp = (struct raw3270 *) alloc_bootmem(sizeof(struct raw3270));
807 ascebc = (char *) alloc_bootmem(256);
808 rc = raw3270_setup_device(cdev, rp, ascebc);
811 set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
812 raw3270_reset_device(rp);
813 raw3270_size_device(rp);
814 raw3270_reset_device(rp);
815 set_bit(RAW3270_FLAGS_READY, &rp->flags);
820 raw3270_wait_cons_dev(struct raw3270 *rp)
824 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
826 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
832 * Create a 3270 device structure.
834 static struct raw3270 *
835 raw3270_create_device(struct ccw_device *cdev)
841 rp = kmalloc(sizeof(struct raw3270), GFP_KERNEL);
843 return ERR_PTR(-ENOMEM);
844 ascebc = kmalloc(256, GFP_KERNEL);
847 return ERR_PTR(-ENOMEM);
849 rc = raw3270_setup_device(cdev, rp, ascebc);
855 /* Get reference to ccw_device structure. */
856 get_device(&cdev->dev);
864 raw3270_activate_view(struct raw3270_view *view)
867 struct raw3270_view *oldview, *nv;
874 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
875 if (rp->view == view)
877 else if (!test_bit(RAW3270_FLAGS_READY, &rp->flags))
883 oldview->fn->deactivate(oldview);
886 rc = view->fn->activate(view);
888 /* Didn't work. Try to reactivate the old view. */
890 if (!oldview || oldview->fn->activate(oldview) != 0) {
891 /* Didn't work as well. Try any other view. */
892 list_for_each_entry(nv, &rp->view_list, list)
893 if (nv != view && nv != oldview) {
895 if (nv->fn->activate(nv) == 0)
902 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
907 * Deactivate current view.
910 raw3270_deactivate_view(struct raw3270_view *view)
918 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
919 if (rp->view == view) {
920 view->fn->deactivate(view);
922 /* Move deactivated view to end of list. */
923 list_del_init(&view->list);
924 list_add_tail(&view->list, &rp->view_list);
925 /* Try to activate another view. */
926 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
927 list_for_each_entry(view, &rp->view_list, list)
928 if (view->fn->activate(view) == 0) {
934 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
938 * Add view to device with minor "minor".
941 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
949 list_for_each_entry(rp, &raw3270_devices, list) {
950 if (rp->minor != minor)
952 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
953 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
954 atomic_set(&view->ref_count, 2);
957 view->model = rp->model;
958 view->rows = rp->rows;
959 view->cols = rp->cols;
960 view->ascebc = rp->ascebc;
961 spin_lock_init(&view->lock);
962 list_add_tail(&view->list, &rp->view_list);
965 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
973 * Find specific view of device with minor "minor".
975 struct raw3270_view *
976 raw3270_find_view(struct raw3270_fn *fn, int minor)
979 struct raw3270_view *view, *tmp;
983 view = ERR_PTR(-ENODEV);
984 list_for_each_entry(rp, &raw3270_devices, list) {
985 if (rp->minor != minor)
987 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
988 if (test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
989 view = ERR_PTR(-ENOENT);
990 list_for_each_entry(tmp, &rp->view_list, list) {
992 raw3270_get_view(tmp);
998 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1006 * Remove view from device and free view structure via call to view->fn->free.
1009 raw3270_del_view(struct raw3270_view *view)
1011 unsigned long flags;
1013 struct raw3270_view *nv;
1016 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1017 if (rp->view == view) {
1018 view->fn->deactivate(view);
1021 list_del_init(&view->list);
1022 if (!rp->view && test_bit(RAW3270_FLAGS_READY, &rp->flags)) {
1023 /* Try to activate another view. */
1024 list_for_each_entry(nv, &rp->view_list, list) {
1025 if (nv->fn->activate(view) == 0) {
1031 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1032 /* Wait for reference counter to drop to zero. */
1033 atomic_sub(2, &view->ref_count);
1034 wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1036 view->fn->free(view);
1040 * Remove a 3270 device structure.
1043 raw3270_delete_device(struct raw3270 *rp)
1045 struct ccw_device *cdev;
1047 /* Remove from device chain. */
1049 list_del_init(&rp->list);
1052 /* Disconnect from ccw_device. */
1055 cdev->dev.driver_data = 0;
1058 /* Put ccw_device structure. */
1059 put_device(&cdev->dev);
1061 /* Now free raw3270 structure. */
1067 raw3270_probe (struct ccw_device *cdev)
1073 * Additional attributes for a 3270 device
1076 raw3270_model_show(struct device *dev, char *buf)
1078 return snprintf(buf, PAGE_SIZE, "%i\n",
1079 ((struct raw3270 *) dev->driver_data)->model);
1081 static DEVICE_ATTR(model, 0444, raw3270_model_show, 0);
1084 raw3270_rows_show(struct device *dev, char *buf)
1086 return snprintf(buf, PAGE_SIZE, "%i\n",
1087 ((struct raw3270 *) dev->driver_data)->rows);
1089 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, 0);
1092 raw3270_columns_show(struct device *dev, char *buf)
1094 return snprintf(buf, PAGE_SIZE, "%i\n",
1095 ((struct raw3270 *) dev->driver_data)->cols);
1097 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, 0);
1099 static struct attribute * raw3270_attrs[] = {
1100 &dev_attr_model.attr,
1101 &dev_attr_rows.attr,
1102 &dev_attr_columns.attr,
1106 static struct attribute_group raw3270_attr_group = {
1107 .attrs = raw3270_attrs,
1111 raw3270_create_attributes(struct raw3270 *rp)
1113 //FIXME: check return code
1114 sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1118 * Notifier for device addition/removal
1120 struct raw3270_notifier {
1121 struct list_head list;
1122 void (*notifier)(int, int);
1125 static struct list_head raw3270_notifier = LIST_HEAD_INIT(raw3270_notifier);
1127 int raw3270_register_notifier(void (*notifier)(int, int))
1129 struct raw3270_notifier *np;
1132 np = kmalloc(sizeof(struct raw3270_notifier), GFP_KERNEL);
1135 np->notifier = notifier;
1137 list_add_tail(&np->list, &raw3270_notifier);
1138 list_for_each_entry(rp, &raw3270_devices, list) {
1139 get_device(&rp->cdev->dev);
1140 notifier(rp->minor, 1);
1146 void raw3270_unregister_notifier(void (*notifier)(int, int))
1148 struct raw3270_notifier *np;
1151 list_for_each_entry(np, &raw3270_notifier, list)
1152 if (np->notifier == notifier) {
1153 list_del(&np->list);
1161 * Set 3270 device online.
1164 raw3270_set_online (struct ccw_device *cdev)
1167 struct raw3270_notifier *np;
1169 rp = raw3270_create_device(cdev);
1172 raw3270_reset_device(rp);
1173 raw3270_size_device(rp);
1174 raw3270_reset_device(rp);
1175 raw3270_create_attributes(rp);
1176 set_bit(RAW3270_FLAGS_READY, &rp->flags);
1178 list_for_each_entry(np, &raw3270_notifier, list)
1179 np->notifier(rp->minor, 1);
1185 * Remove 3270 device structure.
1188 raw3270_remove (struct ccw_device *cdev)
1190 unsigned long flags;
1192 struct raw3270_view *v;
1193 struct raw3270_notifier *np;
1195 rp = cdev->dev.driver_data;
1196 clear_bit(RAW3270_FLAGS_READY, &rp->flags);
1198 sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1200 /* Deactivate current view and remove all views. */
1201 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1203 rp->view->fn->deactivate(rp->view);
1206 while (!list_empty(&rp->view_list)) {
1207 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1210 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1211 raw3270_del_view(v);
1212 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1214 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1217 list_for_each_entry(np, &raw3270_notifier, list)
1218 np->notifier(rp->minor, 0);
1221 /* Reset 3270 device. */
1222 raw3270_reset_device(rp);
1223 /* And finally remove it. */
1224 raw3270_delete_device(rp);
1228 * Set 3270 device offline.
1231 raw3270_set_offline (struct ccw_device *cdev)
1235 rp = cdev->dev.driver_data;
1236 if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1238 raw3270_remove(cdev);
1242 static struct ccw_device_id raw3270_id[] = {
1243 { CCW_DEVICE(0x3270, 0) },
1244 { CCW_DEVICE(0x3271, 0) },
1245 { CCW_DEVICE(0x3272, 0) },
1246 { CCW_DEVICE(0x3273, 0) },
1247 { CCW_DEVICE(0x3274, 0) },
1248 { CCW_DEVICE(0x3275, 0) },
1249 { CCW_DEVICE(0x3276, 0) },
1250 { CCW_DEVICE(0x3277, 0) },
1251 { CCW_DEVICE(0x3278, 0) },
1252 { CCW_DEVICE(0x3279, 0) },
1253 { CCW_DEVICE(0x3174, 0) },
1254 { /* end of list */ },
1257 static struct ccw_driver raw3270_ccw_driver = {
1259 .owner = THIS_MODULE,
1261 .probe = &raw3270_probe,
1262 .remove = &raw3270_remove,
1263 .set_online = &raw3270_set_online,
1264 .set_offline = &raw3270_set_offline,
1273 if (raw3270_registered)
1275 raw3270_registered = 1;
1276 rc = ccw_driver_register(&raw3270_ccw_driver);
1278 /* Create attributes for early (= console) device. */
1280 list_for_each_entry(rp, &raw3270_devices, list) {
1281 get_device(&rp->cdev->dev);
1282 raw3270_create_attributes(rp);
1292 ccw_driver_unregister(&raw3270_ccw_driver);
1295 MODULE_LICENSE("GPL");
1297 module_init(raw3270_init);
1298 module_exit(raw3270_exit);
1300 EXPORT_SYMBOL(raw3270_request_alloc);
1301 EXPORT_SYMBOL(raw3270_request_free);
1302 EXPORT_SYMBOL(raw3270_request_reset);
1303 EXPORT_SYMBOL(raw3270_request_set_cmd);
1304 EXPORT_SYMBOL(raw3270_request_add_data);
1305 EXPORT_SYMBOL(raw3270_request_set_data);
1306 EXPORT_SYMBOL(raw3270_request_set_idal);
1307 EXPORT_SYMBOL(raw3270_buffer_address);
1308 EXPORT_SYMBOL(raw3270_add_view);
1309 EXPORT_SYMBOL(raw3270_del_view);
1310 EXPORT_SYMBOL(raw3270_find_view);
1311 EXPORT_SYMBOL(raw3270_activate_view);
1312 EXPORT_SYMBOL(raw3270_deactivate_view);
1313 EXPORT_SYMBOL(raw3270_start);
1314 EXPORT_SYMBOL(raw3270_start_irq);
1315 EXPORT_SYMBOL(raw3270_register_notifier);
1316 EXPORT_SYMBOL(raw3270_unregister_notifier);
1317 EXPORT_SYMBOL(raw3270_wait_queue);