2 * IBM/3270 Driver - core functions.
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
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>
19 #include <asm/ccwdev.h>
21 #include <asm/ebcdic.h>
26 #include <linux/major.h>
27 #include <linux/kdev_t.h>
28 #include <linux/device.h>
29 #include <linux/mutex.h>
31 struct class *class3270;
33 /* The main 3270 data structure. */
35 struct list_head list;
36 struct ccw_device *cdev;
39 short model, rows, cols;
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. */
47 struct timer_list timer; /* Device timer. */
49 unsigned char *ascebc; /* ascii -> ebcdic table */
51 struct raw3270_view init_view;
52 struct raw3270_request init_reset;
53 struct raw3270_request init_readpart;
54 struct raw3270_request init_readmod;
55 unsigned char init_data[256];
59 #define RAW3270_STATE_INIT 0 /* Initial state */
60 #define RAW3270_STATE_RESET 1 /* Reset command is pending */
61 #define RAW3270_STATE_W4ATTN 2 /* Wait for attention interrupt */
62 #define RAW3270_STATE_READMOD 3 /* Read partition is pending */
63 #define RAW3270_STATE_READY 4 /* Device is usable by views */
66 #define RAW3270_FLAGS_14BITADDR 0 /* 14-bit buffer addresses */
67 #define RAW3270_FLAGS_BUSY 1 /* Device busy, leave it alone */
68 #define RAW3270_FLAGS_CONSOLE 2 /* Device is the console. */
69 #define RAW3270_FLAGS_FROZEN 3 /* set if 3270 is frozen for suspend */
71 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
72 static DEFINE_MUTEX(raw3270_mutex);
74 /* List of 3270 devices. */
75 static LIST_HEAD(raw3270_devices);
78 * Flag to indicate if the driver has been registered. Some operations
79 * like waiting for the end of i/o need to be done differently as long
80 * as the kernel is still starting up (console support).
82 static int raw3270_registered;
84 /* Module parameters */
85 static bool tubxcorrect;
86 module_param(tubxcorrect, bool, 0);
89 * Wait queue for device init/delete, view delete.
91 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
93 static void __raw3270_disconnect(struct raw3270 *rp);
96 * Encode array for 12 bit 3270 addresses.
98 static unsigned char raw3270_ebcgraf[64] = {
99 0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
100 0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
101 0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
102 0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
103 0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
104 0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
105 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
106 0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
109 static inline int raw3270_state_ready(struct raw3270 *rp)
111 return rp->state == RAW3270_STATE_READY;
114 static inline int raw3270_state_final(struct raw3270 *rp)
116 return rp->state == RAW3270_STATE_INIT ||
117 rp->state == RAW3270_STATE_READY;
121 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
123 if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
124 cp[0] = (addr >> 8) & 0x3f;
127 cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
128 cp[1] = raw3270_ebcgraf[addr & 0x3f];
133 * Allocate a new 3270 ccw request
135 struct raw3270_request *
136 raw3270_request_alloc(size_t size)
138 struct raw3270_request *rq;
140 /* Allocate request structure */
141 rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
143 return ERR_PTR(-ENOMEM);
145 /* alloc output buffer. */
147 rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
150 return ERR_PTR(-ENOMEM);
154 INIT_LIST_HEAD(&rq->list);
159 rq->ccw.cda = __pa(rq->buffer);
160 rq->ccw.flags = CCW_FLAG_SLI;
166 * Free 3270 ccw request
169 raw3270_request_free (struct raw3270_request *rq)
176 * Reset request to initial state.
179 raw3270_request_reset(struct raw3270_request *rq)
181 BUG_ON(!list_empty(&rq->list));
182 rq->ccw.cmd_code = 0;
184 rq->ccw.cda = __pa(rq->buffer);
185 rq->ccw.flags = CCW_FLAG_SLI;
191 * Set command code to ccw of a request.
194 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
196 rq->ccw.cmd_code = cmd;
200 * Add data fragment to output buffer.
203 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
205 if (size + rq->ccw.count > rq->size)
207 memcpy(rq->buffer + rq->ccw.count, data, size);
208 rq->ccw.count += size;
213 * Set address/length pair to ccw of a request.
216 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
218 rq->ccw.cda = __pa(data);
219 rq->ccw.count = size;
223 * Set idal buffer to ccw of a request.
226 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
228 rq->ccw.cda = __pa(ib->data);
229 rq->ccw.count = ib->size;
230 rq->ccw.flags |= CCW_FLAG_IDA;
234 * Add the request to the request queue, try to start it if the
235 * 3270 device is idle. Return without waiting for end of i/o.
238 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
239 struct raw3270_request *rq)
242 raw3270_get_view(view);
243 if (list_empty(&rp->req_queue) &&
244 !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
245 /* No other requests are on the queue. Start this one. */
246 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
247 (unsigned long) rq, 0, 0);
249 raw3270_put_view(view);
253 list_add_tail(&rq->list, &rp->req_queue);
258 raw3270_view_active(struct raw3270_view *view)
260 struct raw3270 *rp = view->dev;
262 return rp && rp->view == view &&
263 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
267 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
273 spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
275 if (!rp || rp->view != view ||
276 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
278 else if (!raw3270_state_ready(rp))
281 rc = __raw3270_start(rp, view, rq);
282 spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
287 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
293 if (!rp || rp->view != view ||
294 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
296 else if (!raw3270_state_ready(rp))
299 rc = __raw3270_start(rp, view, rq);
304 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
310 raw3270_get_view(view);
311 list_add_tail(&rq->list, &rp->req_queue);
316 * 3270 interrupt routine, called from the ccw_device layer
319 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
322 struct raw3270_view *view;
323 struct raw3270_request *rq;
325 rp = dev_get_drvdata(&cdev->dev);
328 rq = (struct raw3270_request *) intparm;
329 view = rq ? rq->view : rp->view;
332 /* Handle CE-DE-UE and subsequent UDE */
333 if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END)
334 clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
335 if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END |
337 DEV_STAT_UNIT_EXCEP))
338 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
339 /* Handle disconnected devices */
340 if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
341 (irb->ecw[0] & SNS0_INTERVENTION_REQ)) {
342 set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
343 if (rp->state > RAW3270_STATE_RESET)
344 __raw3270_disconnect(rp);
346 /* Call interrupt handler of the view */
348 view->fn->intv(view, rq, irb);
351 if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags))
352 /* Device busy, do not start I/O */
355 if (rq && !list_empty(&rq->list)) {
356 /* The request completed, remove from queue and do callback. */
357 list_del_init(&rq->list);
359 rq->callback(rq, rq->callback_data);
360 /* Do put_device for get_device in raw3270_start. */
361 raw3270_put_view(view);
365 * Try to start each request on request queue until one is
366 * started successful.
368 while (!list_empty(&rp->req_queue)) {
369 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
370 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
371 (unsigned long) rq, 0, 0);
374 /* Start failed. Remove request and do callback. */
375 list_del_init(&rq->list);
377 rq->callback(rq, rq->callback_data);
378 /* Do put_device for get_device in raw3270_start. */
379 raw3270_put_view(view);
384 * To determine the size of the 3270 device we need to do:
385 * 1) send a 'read partition' data stream to the device
386 * 2) wait for the attn interrupt that precedes the query reply
387 * 3) do a read modified to get the query reply
388 * To make things worse we have to cope with intervention
389 * required (3270 device switched to 'stand-by') and command
390 * rejects (old devices that can't do 'read partition').
392 struct raw3270_ua { /* Query Reply structure for Usable Area */
393 struct { /* Usable Area Query Reply Base */
394 short l; /* Length of this structured field */
395 char sfid; /* 0x81 if Query Reply */
396 char qcode; /* 0x81 if Usable Area */
399 short w; /* Width of usable area */
400 short h; /* Heigth of usavle area */
401 char units; /* 0x00:in; 0x01:mm */
406 short buffsz; /* Character buffer size, bytes */
411 } __attribute__ ((packed)) uab;
412 struct { /* Alternate Usable Area Self-Defining Parameter */
413 char l; /* Length of this Self-Defining Parm */
414 char sdpid; /* 0x02 if Alternate Usable Area */
416 char auaid; /* 0x01 is Id for the A U A */
417 short wauai; /* Width of AUAi */
418 short hauai; /* Height of AUAi */
419 char auaunits; /* 0x00:in, 0x01:mm */
424 } __attribute__ ((packed)) aua;
425 } __attribute__ ((packed));
428 raw3270_size_device_vm(struct raw3270 *rp)
431 struct ccw_dev_id dev_id;
432 struct diag210 diag_data;
434 ccw_device_get_id(rp->cdev, &dev_id);
435 diag_data.vrdcdvno = dev_id.devno;
436 diag_data.vrdclen = sizeof(struct diag210);
437 rc = diag210(&diag_data);
438 model = diag_data.vrdccrmd;
439 /* Use default model 2 if the size could not be detected */
440 if (rc || model < 2 || model > 5)
467 raw3270_size_device(struct raw3270 *rp)
469 struct raw3270_ua *uap;
471 /* Got a Query Reply */
472 uap = (struct raw3270_ua *) (rp->init_data + 1);
473 /* Paranoia check. */
474 if (rp->init_readmod.rc || rp->init_data[0] != 0x88 ||
475 uap->uab.qcode != 0x81) {
476 /* Couldn't detect size. Use default model 2. */
482 /* Copy rows/columns of default Usable Area */
483 rp->rows = uap->uab.h;
484 rp->cols = uap->uab.w;
485 /* Check for 14 bit addressing */
486 if ((uap->uab.flags0 & 0x0d) == 0x01)
487 set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
488 /* Check for Alternate Usable Area */
489 if (uap->uab.l == sizeof(struct raw3270_ua) &&
490 uap->aua.sdpid == 0x02) {
491 rp->rows = uap->aua.hauai;
492 rp->cols = uap->aua.wauai;
494 /* Try to find a model. */
496 if (rp->rows == 24 && rp->cols == 80)
498 if (rp->rows == 32 && rp->cols == 80)
500 if (rp->rows == 43 && rp->cols == 80)
502 if (rp->rows == 27 && rp->cols == 132)
507 raw3270_size_device_done(struct raw3270 *rp)
509 struct raw3270_view *view;
512 rp->state = RAW3270_STATE_READY;
513 /* Notify views about new size */
514 list_for_each_entry(view, &rp->view_list, list)
515 if (view->fn->resize)
516 view->fn->resize(view, rp->model, rp->rows, rp->cols);
517 /* Setup processing done, now activate a view */
518 list_for_each_entry(view, &rp->view_list, list) {
520 if (view->fn->activate(view) == 0)
527 raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
529 struct raw3270 *rp = rq->view->dev;
531 raw3270_size_device(rp);
532 raw3270_size_device_done(rp);
536 raw3270_read_modified(struct raw3270 *rp)
538 if (rp->state != RAW3270_STATE_W4ATTN)
540 /* Use 'read modified' to get the result of a read partition. */
541 memset(&rp->init_readmod, 0, sizeof(rp->init_readmod));
542 memset(&rp->init_data, 0, sizeof(rp->init_data));
543 rp->init_readmod.ccw.cmd_code = TC_READMOD;
544 rp->init_readmod.ccw.flags = CCW_FLAG_SLI;
545 rp->init_readmod.ccw.count = sizeof(rp->init_data);
546 rp->init_readmod.ccw.cda = (__u32) __pa(rp->init_data);
547 rp->init_readmod.callback = raw3270_read_modified_cb;
548 rp->state = RAW3270_STATE_READMOD;
549 raw3270_start_irq(&rp->init_view, &rp->init_readmod);
553 raw3270_writesf_readpart(struct raw3270 *rp)
555 static const unsigned char wbuf[] =
556 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
558 /* Store 'read partition' data stream to init_data */
559 memset(&rp->init_readpart, 0, sizeof(rp->init_readpart));
560 memset(&rp->init_data, 0, sizeof(rp->init_data));
561 memcpy(&rp->init_data, wbuf, sizeof(wbuf));
562 rp->init_readpart.ccw.cmd_code = TC_WRITESF;
563 rp->init_readpart.ccw.flags = CCW_FLAG_SLI;
564 rp->init_readpart.ccw.count = sizeof(wbuf);
565 rp->init_readpart.ccw.cda = (__u32) __pa(&rp->init_data);
566 rp->state = RAW3270_STATE_W4ATTN;
567 raw3270_start_irq(&rp->init_view, &rp->init_readpart);
574 raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
576 struct raw3270 *rp = rq->view->dev;
578 if (rp->state != RAW3270_STATE_RESET)
581 /* Reset command failed. */
582 rp->state = RAW3270_STATE_INIT;
583 } else if (MACHINE_IS_VM) {
584 raw3270_size_device_vm(rp);
585 raw3270_size_device_done(rp);
587 raw3270_writesf_readpart(rp);
588 memset(&rp->init_reset, 0, sizeof(rp->init_reset));
592 __raw3270_reset_device(struct raw3270 *rp)
596 /* Check if reset is already pending */
597 if (rp->init_reset.view)
599 /* Store reset data stream to init_data/init_reset */
600 rp->init_data[0] = TW_KR;
601 rp->init_reset.ccw.cmd_code = TC_EWRITEA;
602 rp->init_reset.ccw.flags = CCW_FLAG_SLI;
603 rp->init_reset.ccw.count = 1;
604 rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
605 rp->init_reset.callback = raw3270_reset_device_cb;
606 rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
607 if (rc == 0 && rp->state == RAW3270_STATE_INIT)
608 rp->state = RAW3270_STATE_RESET;
613 raw3270_reset_device(struct raw3270 *rp)
618 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
619 rc = __raw3270_reset_device(rp);
620 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
625 raw3270_reset(struct raw3270_view *view)
631 if (!rp || rp->view != view ||
632 test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
634 else if (!raw3270_state_ready(rp))
637 rc = raw3270_reset_device(view->dev);
642 __raw3270_disconnect(struct raw3270 *rp)
644 struct raw3270_request *rq;
645 struct raw3270_view *view;
647 rp->state = RAW3270_STATE_INIT;
648 rp->view = &rp->init_view;
649 /* Cancel all queued requests */
650 while (!list_empty(&rp->req_queue)) {
651 rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
654 list_del_init(&rq->list);
656 rq->callback(rq, rq->callback_data);
657 raw3270_put_view(view);
659 /* Start from scratch */
660 __raw3270_reset_device(rp);
664 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
670 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
671 if (irb->ecw[0] & SNS0_CMD_REJECT)
672 rq->rc = -EOPNOTSUPP;
677 if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
678 /* Queue read modified after attention interrupt */
680 raw3270_read_modified(rp);
684 static struct raw3270_fn raw3270_init_fn = {
685 .intv = raw3270_init_irq
689 * Setup new 3270 device.
692 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
698 memset(rp, 0, sizeof(struct raw3270));
699 /* Copy ebcdic -> ascii translation table. */
700 memcpy(ascebc, _ascebc, 256);
702 /* correct brackets and circumflex */
713 INIT_LIST_HEAD(&rp->req_queue);
714 INIT_LIST_HEAD(&rp->view_list);
716 rp->init_view.dev = rp;
717 rp->init_view.fn = &raw3270_init_fn;
718 rp->view = &rp->init_view;
721 * Add device to list and find the smallest unused minor
722 * number for it. Note: there is no device with minor 0,
723 * see special case for fs3270.c:fs3270_open().
725 mutex_lock(&raw3270_mutex);
726 /* Keep the list sorted. */
727 minor = RAW3270_FIRSTMINOR;
729 list_for_each(l, &raw3270_devices) {
730 tmp = list_entry(l, struct raw3270, list);
731 if (tmp->minor > minor) {
733 __list_add(&rp->list, l->prev, l);
738 if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
740 list_add_tail(&rp->list, &raw3270_devices);
742 mutex_unlock(&raw3270_mutex);
743 /* No free minor number? Then give up. */
747 dev_set_drvdata(&cdev->dev, rp);
748 cdev->handler = raw3270_irq;
752 #ifdef CONFIG_TN3270_CONSOLE
753 /* Tentative definition - see below for actual definition. */
754 static struct ccw_driver raw3270_ccw_driver;
757 * Setup 3270 device configured as console.
759 struct raw3270 __init *raw3270_setup_console(void)
761 struct ccw_device *cdev;
767 cdev = ccw_device_create_console(&raw3270_ccw_driver);
769 return ERR_CAST(cdev);
771 rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
772 ascebc = kzalloc(256, GFP_KERNEL);
773 rc = raw3270_setup_device(cdev, rp, ascebc);
776 set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
778 rc = ccw_device_enable_console(cdev);
780 ccw_device_destroy_console(cdev);
784 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
786 __raw3270_reset_device(rp);
787 while (!raw3270_state_final(rp)) {
788 ccw_device_wait_idle(rp->cdev);
791 } while (rp->state != RAW3270_STATE_READY);
792 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
797 raw3270_wait_cons_dev(struct raw3270 *rp)
801 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
802 ccw_device_wait_idle(rp->cdev);
803 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
809 * Create a 3270 device structure.
811 static struct raw3270 *
812 raw3270_create_device(struct ccw_device *cdev)
818 rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
820 return ERR_PTR(-ENOMEM);
821 ascebc = kmalloc(256, GFP_KERNEL);
824 return ERR_PTR(-ENOMEM);
826 rc = raw3270_setup_device(cdev, rp, ascebc);
832 /* Get reference to ccw_device structure. */
833 get_device(&cdev->dev);
841 raw3270_activate_view(struct raw3270_view *view)
844 struct raw3270_view *oldview, *nv;
851 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
852 if (rp->view == view)
854 else if (!raw3270_state_ready(rp))
856 else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
860 if (rp->view && rp->view->fn->deactivate) {
862 oldview->fn->deactivate(oldview);
865 rc = view->fn->activate(view);
867 /* Didn't work. Try to reactivate the old view. */
869 if (!oldview || oldview->fn->activate(oldview) != 0) {
870 /* Didn't work as well. Try any other view. */
871 list_for_each_entry(nv, &rp->view_list, list)
872 if (nv != view && nv != oldview) {
874 if (nv->fn->activate(nv) == 0)
881 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
886 * Deactivate current view.
889 raw3270_deactivate_view(struct raw3270_view *view)
897 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
898 if (rp->view == view) {
899 view->fn->deactivate(view);
901 /* Move deactivated view to end of list. */
902 list_del_init(&view->list);
903 list_add_tail(&view->list, &rp->view_list);
904 /* Try to activate another view. */
905 if (raw3270_state_ready(rp) &&
906 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
907 list_for_each_entry(view, &rp->view_list, list) {
909 if (view->fn->activate(view) == 0)
915 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
919 * Add view to device with minor "minor".
922 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
930 mutex_lock(&raw3270_mutex);
932 list_for_each_entry(rp, &raw3270_devices, list) {
933 if (rp->minor != minor)
935 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
936 atomic_set(&view->ref_count, 2);
939 view->model = rp->model;
940 view->rows = rp->rows;
941 view->cols = rp->cols;
942 view->ascebc = rp->ascebc;
943 spin_lock_init(&view->lock);
944 lockdep_set_subclass(&view->lock, subclass);
945 list_add(&view->list, &rp->view_list);
947 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
950 mutex_unlock(&raw3270_mutex);
955 * Find specific view of device with minor "minor".
957 struct raw3270_view *
958 raw3270_find_view(struct raw3270_fn *fn, int minor)
961 struct raw3270_view *view, *tmp;
964 mutex_lock(&raw3270_mutex);
965 view = ERR_PTR(-ENODEV);
966 list_for_each_entry(rp, &raw3270_devices, list) {
967 if (rp->minor != minor)
969 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
970 list_for_each_entry(tmp, &rp->view_list, list) {
972 raw3270_get_view(tmp);
977 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
980 mutex_unlock(&raw3270_mutex);
985 * Remove view from device and free view structure via call to view->fn->free.
988 raw3270_del_view(struct raw3270_view *view)
992 struct raw3270_view *nv;
995 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
996 if (rp->view == view) {
997 view->fn->deactivate(view);
1000 list_del_init(&view->list);
1001 if (!rp->view && raw3270_state_ready(rp) &&
1002 !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
1003 /* Try to activate another view. */
1004 list_for_each_entry(nv, &rp->view_list, list) {
1005 if (nv->fn->activate(nv) == 0) {
1011 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1012 /* Wait for reference counter to drop to zero. */
1013 atomic_dec(&view->ref_count);
1014 wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1016 view->fn->free(view);
1020 * Remove a 3270 device structure.
1023 raw3270_delete_device(struct raw3270 *rp)
1025 struct ccw_device *cdev;
1027 /* Remove from device chain. */
1028 mutex_lock(&raw3270_mutex);
1029 list_del_init(&rp->list);
1030 mutex_unlock(&raw3270_mutex);
1032 /* Disconnect from ccw_device. */
1035 dev_set_drvdata(&cdev->dev, NULL);
1036 cdev->handler = NULL;
1038 /* Put ccw_device structure. */
1039 put_device(&cdev->dev);
1041 /* Now free raw3270 structure. */
1047 raw3270_probe (struct ccw_device *cdev)
1053 * Additional attributes for a 3270 device
1056 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1058 return snprintf(buf, PAGE_SIZE, "%i\n",
1059 ((struct raw3270 *) dev_get_drvdata(dev))->model);
1061 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1064 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1066 return snprintf(buf, PAGE_SIZE, "%i\n",
1067 ((struct raw3270 *) dev_get_drvdata(dev))->rows);
1069 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1072 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1074 return snprintf(buf, PAGE_SIZE, "%i\n",
1075 ((struct raw3270 *) dev_get_drvdata(dev))->cols);
1077 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1079 static struct attribute * raw3270_attrs[] = {
1080 &dev_attr_model.attr,
1081 &dev_attr_rows.attr,
1082 &dev_attr_columns.attr,
1086 static const struct attribute_group raw3270_attr_group = {
1087 .attrs = raw3270_attrs,
1090 static int raw3270_create_attributes(struct raw3270 *rp)
1092 return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1096 * Notifier for device addition/removal
1098 static LIST_HEAD(raw3270_notifier);
1100 int raw3270_register_notifier(struct raw3270_notifier *notifier)
1104 mutex_lock(&raw3270_mutex);
1105 list_add_tail(¬ifier->list, &raw3270_notifier);
1106 list_for_each_entry(rp, &raw3270_devices, list)
1107 notifier->create(rp->minor);
1108 mutex_unlock(&raw3270_mutex);
1112 void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
1116 mutex_lock(&raw3270_mutex);
1117 list_for_each_entry(rp, &raw3270_devices, list)
1118 notifier->destroy(rp->minor);
1119 list_del(¬ifier->list);
1120 mutex_unlock(&raw3270_mutex);
1124 * Set 3270 device online.
1127 raw3270_set_online (struct ccw_device *cdev)
1129 struct raw3270_notifier *np;
1133 rp = raw3270_create_device(cdev);
1136 rc = raw3270_create_attributes(rp);
1139 raw3270_reset_device(rp);
1140 mutex_lock(&raw3270_mutex);
1141 list_for_each_entry(np, &raw3270_notifier, list)
1142 np->create(rp->minor);
1143 mutex_unlock(&raw3270_mutex);
1147 raw3270_delete_device(rp);
1152 * Remove 3270 device structure.
1155 raw3270_remove (struct ccw_device *cdev)
1157 unsigned long flags;
1159 struct raw3270_view *v;
1160 struct raw3270_notifier *np;
1162 rp = dev_get_drvdata(&cdev->dev);
1164 * _remove is the opposite of _probe; it's probe that
1165 * should set up rp. raw3270_remove gets entered for
1166 * devices even if they haven't been varied online.
1167 * Thus, rp may validly be NULL here.
1172 sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1174 /* Deactivate current view and remove all views. */
1175 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1177 if (rp->view->fn->deactivate)
1178 rp->view->fn->deactivate(rp->view);
1181 while (!list_empty(&rp->view_list)) {
1182 v = list_entry(rp->view_list.next, struct raw3270_view, list);
1185 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1186 raw3270_del_view(v);
1187 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1189 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1191 mutex_lock(&raw3270_mutex);
1192 list_for_each_entry(np, &raw3270_notifier, list)
1193 np->destroy(rp->minor);
1194 mutex_unlock(&raw3270_mutex);
1196 /* Reset 3270 device. */
1197 raw3270_reset_device(rp);
1198 /* And finally remove it. */
1199 raw3270_delete_device(rp);
1203 * Set 3270 device offline.
1206 raw3270_set_offline (struct ccw_device *cdev)
1210 rp = dev_get_drvdata(&cdev->dev);
1211 if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1213 raw3270_remove(cdev);
1217 static int raw3270_pm_stop(struct ccw_device *cdev)
1220 struct raw3270_view *view;
1221 unsigned long flags;
1223 rp = dev_get_drvdata(&cdev->dev);
1226 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1227 if (rp->view && rp->view->fn->deactivate)
1228 rp->view->fn->deactivate(rp->view);
1229 if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1231 * Release tty and fullscreen for all non-console
1234 list_for_each_entry(view, &rp->view_list, list) {
1235 if (view->fn->release)
1236 view->fn->release(view);
1239 set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1240 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1244 static int raw3270_pm_start(struct ccw_device *cdev)
1247 unsigned long flags;
1249 rp = dev_get_drvdata(&cdev->dev);
1252 spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1253 clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1254 if (rp->view && rp->view->fn->activate)
1255 rp->view->fn->activate(rp->view);
1256 spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1260 void raw3270_pm_unfreeze(struct raw3270_view *view)
1262 #ifdef CONFIG_TN3270_CONSOLE
1266 if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1267 ccw_device_force_console(rp->cdev);
1271 static struct ccw_device_id raw3270_id[] = {
1272 { CCW_DEVICE(0x3270, 0) },
1273 { CCW_DEVICE(0x3271, 0) },
1274 { CCW_DEVICE(0x3272, 0) },
1275 { CCW_DEVICE(0x3273, 0) },
1276 { CCW_DEVICE(0x3274, 0) },
1277 { CCW_DEVICE(0x3275, 0) },
1278 { CCW_DEVICE(0x3276, 0) },
1279 { CCW_DEVICE(0x3277, 0) },
1280 { CCW_DEVICE(0x3278, 0) },
1281 { CCW_DEVICE(0x3279, 0) },
1282 { CCW_DEVICE(0x3174, 0) },
1283 { /* end of list */ },
1286 static struct ccw_driver raw3270_ccw_driver = {
1289 .owner = THIS_MODULE,
1292 .probe = &raw3270_probe,
1293 .remove = &raw3270_remove,
1294 .set_online = &raw3270_set_online,
1295 .set_offline = &raw3270_set_offline,
1296 .freeze = &raw3270_pm_stop,
1297 .thaw = &raw3270_pm_start,
1298 .restore = &raw3270_pm_start,
1299 .int_class = IRQIO_C70,
1308 if (raw3270_registered)
1310 raw3270_registered = 1;
1311 rc = ccw_driver_register(&raw3270_ccw_driver);
1313 /* Create attributes for early (= console) device. */
1314 mutex_lock(&raw3270_mutex);
1315 class3270 = class_create(THIS_MODULE, "3270");
1316 list_for_each_entry(rp, &raw3270_devices, list) {
1317 get_device(&rp->cdev->dev);
1318 raw3270_create_attributes(rp);
1320 mutex_unlock(&raw3270_mutex);
1328 ccw_driver_unregister(&raw3270_ccw_driver);
1329 class_destroy(class3270);
1332 MODULE_LICENSE("GPL");
1334 module_init(raw3270_init);
1335 module_exit(raw3270_exit);
1337 EXPORT_SYMBOL(class3270);
1338 EXPORT_SYMBOL(raw3270_request_alloc);
1339 EXPORT_SYMBOL(raw3270_request_free);
1340 EXPORT_SYMBOL(raw3270_request_reset);
1341 EXPORT_SYMBOL(raw3270_request_set_cmd);
1342 EXPORT_SYMBOL(raw3270_request_add_data);
1343 EXPORT_SYMBOL(raw3270_request_set_data);
1344 EXPORT_SYMBOL(raw3270_request_set_idal);
1345 EXPORT_SYMBOL(raw3270_buffer_address);
1346 EXPORT_SYMBOL(raw3270_add_view);
1347 EXPORT_SYMBOL(raw3270_del_view);
1348 EXPORT_SYMBOL(raw3270_find_view);
1349 EXPORT_SYMBOL(raw3270_activate_view);
1350 EXPORT_SYMBOL(raw3270_deactivate_view);
1351 EXPORT_SYMBOL(raw3270_start);
1352 EXPORT_SYMBOL(raw3270_start_locked);
1353 EXPORT_SYMBOL(raw3270_start_irq);
1354 EXPORT_SYMBOL(raw3270_reset);
1355 EXPORT_SYMBOL(raw3270_register_notifier);
1356 EXPORT_SYMBOL(raw3270_unregister_notifier);
1357 EXPORT_SYMBOL(raw3270_wait_queue);