xref: /openbmc/linux/drivers/s390/char/raw3270.c (revision 7587eb18)
1 /*
2  * IBM/3270 Driver - core functions.
3  *
4  * Author(s):
5  *   Original 3270 Code for 2.4 written by Richard Hitt (UTS Global)
6  *   Rewritten for 2.5 by Martin Schwidefsky <schwidefsky@de.ibm.com>
7  *     Copyright IBM Corp. 2003, 2009
8  */
9 
10 #include <linux/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 
31 struct class *class3270;
32 
33 /* The main 3270 data structure. */
34 struct raw3270 {
35 	struct list_head list;
36 	struct ccw_device *cdev;
37 	int minor;
38 
39 	short model, rows, cols;
40 	unsigned int state;
41 	unsigned long flags;
42 
43 	struct list_head req_queue;	/* Request queue. */
44 	struct list_head view_list;	/* List of available views. */
45 	struct raw3270_view *view;	/* Active view. */
46 
47 	struct timer_list timer;	/* Device timer. */
48 
49 	unsigned char *ascebc;		/* ascii -> ebcdic table */
50 
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];
56 };
57 
58 /* raw3270->state */
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 */
64 
65 /* raw3270->flags */
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 */
70 
71 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
72 static DEFINE_MUTEX(raw3270_mutex);
73 
74 /* List of 3270 devices. */
75 static LIST_HEAD(raw3270_devices);
76 
77 /*
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).
81  */
82 static int raw3270_registered;
83 
84 /* Module parameters */
85 static bool tubxcorrect = 0;
86 module_param(tubxcorrect, bool, 0);
87 
88 /*
89  * Wait queue for device init/delete, view delete.
90  */
91 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
92 
93 static void __raw3270_disconnect(struct raw3270 *rp);
94 
95 /*
96  * Encode array for 12 bit 3270 addresses.
97  */
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
107 };
108 
109 static inline int raw3270_state_ready(struct raw3270 *rp)
110 {
111 	return rp->state == RAW3270_STATE_READY;
112 }
113 
114 static inline int raw3270_state_final(struct raw3270 *rp)
115 {
116 	return rp->state == RAW3270_STATE_INIT ||
117 		rp->state == RAW3270_STATE_READY;
118 }
119 
120 void
121 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
122 {
123 	if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
124 		cp[0] = (addr >> 8) & 0x3f;
125 		cp[1] = addr & 0xff;
126 	} else {
127 		cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
128 		cp[1] = raw3270_ebcgraf[addr & 0x3f];
129 	}
130 }
131 
132 /*
133  * Allocate a new 3270 ccw request
134  */
135 struct raw3270_request *
136 raw3270_request_alloc(size_t size)
137 {
138 	struct raw3270_request *rq;
139 
140 	/* Allocate request structure */
141 	rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
142 	if (!rq)
143 		return ERR_PTR(-ENOMEM);
144 
145 	/* alloc output buffer. */
146 	if (size > 0) {
147 		rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
148 		if (!rq->buffer) {
149 			kfree(rq);
150 			return ERR_PTR(-ENOMEM);
151 		}
152 	}
153 	rq->size = size;
154 	INIT_LIST_HEAD(&rq->list);
155 
156 	/*
157 	 * Setup ccw.
158 	 */
159 	rq->ccw.cda = __pa(rq->buffer);
160 	rq->ccw.flags = CCW_FLAG_SLI;
161 
162 	return rq;
163 }
164 
165 /*
166  * Free 3270 ccw request
167  */
168 void
169 raw3270_request_free (struct raw3270_request *rq)
170 {
171 	kfree(rq->buffer);
172 	kfree(rq);
173 }
174 
175 /*
176  * Reset request to initial state.
177  */
178 void
179 raw3270_request_reset(struct raw3270_request *rq)
180 {
181 	BUG_ON(!list_empty(&rq->list));
182 	rq->ccw.cmd_code = 0;
183 	rq->ccw.count = 0;
184 	rq->ccw.cda = __pa(rq->buffer);
185 	rq->ccw.flags = CCW_FLAG_SLI;
186 	rq->rescnt = 0;
187 	rq->rc = 0;
188 }
189 
190 /*
191  * Set command code to ccw of a request.
192  */
193 void
194 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
195 {
196 	rq->ccw.cmd_code = cmd;
197 }
198 
199 /*
200  * Add data fragment to output buffer.
201  */
202 int
203 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
204 {
205 	if (size + rq->ccw.count > rq->size)
206 		return -E2BIG;
207 	memcpy(rq->buffer + rq->ccw.count, data, size);
208 	rq->ccw.count += size;
209 	return 0;
210 }
211 
212 /*
213  * Set address/length pair to ccw of a request.
214  */
215 void
216 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
217 {
218 	rq->ccw.cda = __pa(data);
219 	rq->ccw.count = size;
220 }
221 
222 /*
223  * Set idal buffer to ccw of a request.
224  */
225 void
226 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
227 {
228 	rq->ccw.cda = __pa(ib->data);
229 	rq->ccw.count = ib->size;
230 	rq->ccw.flags |= CCW_FLAG_IDA;
231 }
232 
233 /*
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.
236  */
237 static int
238 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
239 		struct raw3270_request *rq)
240 {
241 	rq->view = view;
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);
248 		if (rq->rc) {
249 			raw3270_put_view(view);
250 			return rq->rc;
251 		}
252 	}
253 	list_add_tail(&rq->list, &rp->req_queue);
254 	return 0;
255 }
256 
257 int
258 raw3270_view_active(struct raw3270_view *view)
259 {
260 	struct raw3270 *rp = view->dev;
261 
262 	return rp && rp->view == view &&
263 		!test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
264 }
265 
266 int
267 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
268 {
269 	unsigned long flags;
270 	struct raw3270 *rp;
271 	int rc;
272 
273 	spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
274 	rp = view->dev;
275 	if (!rp || rp->view != view ||
276 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
277 		rc = -EACCES;
278 	else if (!raw3270_state_ready(rp))
279 		rc = -EBUSY;
280 	else
281 		rc =  __raw3270_start(rp, view, rq);
282 	spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
283 	return rc;
284 }
285 
286 int
287 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
288 {
289 	struct raw3270 *rp;
290 	int rc;
291 
292 	rp = view->dev;
293 	if (!rp || rp->view != view ||
294 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
295 		rc = -EACCES;
296 	else if (!raw3270_state_ready(rp))
297 		rc = -EBUSY;
298 	else
299 		rc =  __raw3270_start(rp, view, rq);
300 	return rc;
301 }
302 
303 int
304 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
305 {
306 	struct raw3270 *rp;
307 
308 	rp = view->dev;
309 	rq->view = view;
310 	raw3270_get_view(view);
311 	list_add_tail(&rq->list, &rp->req_queue);
312 	return 0;
313 }
314 
315 /*
316  * 3270 interrupt routine, called from the ccw_device layer
317  */
318 static void
319 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
320 {
321 	struct raw3270 *rp;
322 	struct raw3270_view *view;
323 	struct raw3270_request *rq;
324 
325 	rp = dev_get_drvdata(&cdev->dev);
326 	if (!rp)
327 		return;
328 	rq = (struct raw3270_request *) intparm;
329 	view = rq ? rq->view : rp->view;
330 
331 	if (!IS_ERR(irb)) {
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 |
336 					    DEV_STAT_DEV_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);
345 		}
346 		/* Call interrupt handler of the view */
347 		if (view)
348 			view->fn->intv(view, rq, irb);
349 	}
350 
351 	if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags))
352 		/* Device busy, do not start I/O */
353 		return;
354 
355 	if (rq && !list_empty(&rq->list)) {
356 		/* The request completed, remove from queue and do callback. */
357 		list_del_init(&rq->list);
358 		if (rq->callback)
359 			rq->callback(rq, rq->callback_data);
360 		/* Do put_device for get_device in raw3270_start. */
361 		raw3270_put_view(view);
362 	}
363 
364 	/*
365 	 * Try to start each request on request queue until one is
366 	 * started successful.
367 	 */
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);
372 		if (rq->rc == 0)
373 			break;
374 		/* Start failed. Remove request and do callback. */
375 		list_del_init(&rq->list);
376 		if (rq->callback)
377 			rq->callback(rq, rq->callback_data);
378 		/* Do put_device for get_device in raw3270_start. */
379 		raw3270_put_view(view);
380 	}
381 }
382 
383 /*
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').
391  */
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 */
397 		char  flags0;
398 		char  flags1;
399 		short w;	/* Width of usable area */
400 		short h;	/* Heigth of usavle area */
401 		char  units;	/* 0x00:in; 0x01:mm */
402 		int   xr;
403 		int   yr;
404 		char  aw;
405 		char  ah;
406 		short buffsz;	/* Character buffer size, bytes */
407 		char  xmin;
408 		char  ymin;
409 		char  xmax;
410 		char  ymax;
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 */
415 		char  res;
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 */
420 		int   auaxr;
421 		int   auayr;
422 		char  awauai;
423 		char  ahauai;
424 	} __attribute__ ((packed)) aua;
425 } __attribute__ ((packed));
426 
427 static void
428 raw3270_size_device_vm(struct raw3270 *rp)
429 {
430 	int rc, model;
431 	struct ccw_dev_id dev_id;
432 	struct diag210 diag_data;
433 
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)
441 		model = 2;
442 	switch (model) {
443 	case 2:
444 		rp->model = model;
445 		rp->rows = 24;
446 		rp->cols = 80;
447 		break;
448 	case 3:
449 		rp->model = model;
450 		rp->rows = 32;
451 		rp->cols = 80;
452 		break;
453 	case 4:
454 		rp->model = model;
455 		rp->rows = 43;
456 		rp->cols = 80;
457 		break;
458 	case 5:
459 		rp->model = model;
460 		rp->rows = 27;
461 		rp->cols = 132;
462 		break;
463 	}
464 }
465 
466 static void
467 raw3270_size_device(struct raw3270 *rp)
468 {
469 	struct raw3270_ua *uap;
470 
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. */
477 		rp->model = 2;
478 		rp->rows = 24;
479 		rp->cols = 80;
480 		return;
481 	}
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;
493 	}
494 	/* Try to find a model. */
495 	rp->model = 0;
496 	if (rp->rows == 24 && rp->cols == 80)
497 		rp->model = 2;
498 	if (rp->rows == 32 && rp->cols == 80)
499 		rp->model = 3;
500 	if (rp->rows == 43 && rp->cols == 80)
501 		rp->model = 4;
502 	if (rp->rows == 27 && rp->cols == 132)
503 		rp->model = 5;
504 }
505 
506 static void
507 raw3270_size_device_done(struct raw3270 *rp)
508 {
509 	struct raw3270_view *view;
510 
511 	rp->view = NULL;
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) {
519 		rp->view = view;
520 		if (view->fn->activate(view) == 0)
521 			break;
522 		rp->view = NULL;
523 	}
524 }
525 
526 static void
527 raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
528 {
529 	struct raw3270 *rp = rq->view->dev;
530 
531 	raw3270_size_device(rp);
532 	raw3270_size_device_done(rp);
533 }
534 
535 static void
536 raw3270_read_modified(struct raw3270 *rp)
537 {
538 	if (rp->state != RAW3270_STATE_W4ATTN)
539 		return;
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);
550 }
551 
552 static void
553 raw3270_writesf_readpart(struct raw3270 *rp)
554 {
555 	static const unsigned char wbuf[] =
556 		{ 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
557 
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);
568 }
569 
570 /*
571  * Device reset
572  */
573 static void
574 raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
575 {
576 	struct raw3270 *rp = rq->view->dev;
577 
578 	if (rp->state != RAW3270_STATE_RESET)
579 		return;
580 	if (rq->rc) {
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);
586 	} else
587 		raw3270_writesf_readpart(rp);
588 	memset(&rp->init_reset, 0, sizeof(rp->init_reset));
589 }
590 
591 static int
592 __raw3270_reset_device(struct raw3270 *rp)
593 {
594 	int rc;
595 
596 	/* Check if reset is already pending */
597 	if (rp->init_reset.view)
598 		return -EBUSY;
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;
609 	return rc;
610 }
611 
612 static int
613 raw3270_reset_device(struct raw3270 *rp)
614 {
615 	unsigned long flags;
616 	int rc;
617 
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);
621 	return rc;
622 }
623 
624 int
625 raw3270_reset(struct raw3270_view *view)
626 {
627 	struct raw3270 *rp;
628 	int rc;
629 
630 	rp = view->dev;
631 	if (!rp || rp->view != view ||
632 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
633 		rc = -EACCES;
634 	else if (!raw3270_state_ready(rp))
635 		rc = -EBUSY;
636 	else
637 		rc = raw3270_reset_device(view->dev);
638 	return rc;
639 }
640 
641 static void
642 __raw3270_disconnect(struct raw3270 *rp)
643 {
644 	struct raw3270_request *rq;
645 	struct raw3270_view *view;
646 
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);
652 		view = rq->view;
653 		rq->rc = -EACCES;
654 		list_del_init(&rq->list);
655 		if (rq->callback)
656 			rq->callback(rq, rq->callback_data);
657 		raw3270_put_view(view);
658 	}
659 	/* Start from scratch */
660 	__raw3270_reset_device(rp);
661 }
662 
663 static void
664 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
665 		 struct irb *irb)
666 {
667 	struct raw3270 *rp;
668 
669 	if (rq) {
670 		if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
671 			if (irb->ecw[0] & SNS0_CMD_REJECT)
672 				rq->rc = -EOPNOTSUPP;
673 			else
674 				rq->rc = -EIO;
675 		}
676 	}
677 	if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
678 		/* Queue read modified after attention interrupt */
679 		rp = view->dev;
680 		raw3270_read_modified(rp);
681 	}
682 }
683 
684 static struct raw3270_fn raw3270_init_fn = {
685 	.intv = raw3270_init_irq
686 };
687 
688 /*
689  * Setup new 3270 device.
690  */
691 static int
692 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
693 {
694 	struct list_head *l;
695 	struct raw3270 *tmp;
696 	int minor;
697 
698 	memset(rp, 0, sizeof(struct raw3270));
699 	/* Copy ebcdic -> ascii translation table. */
700 	memcpy(ascebc, _ascebc, 256);
701 	if (tubxcorrect) {
702 		/* correct brackets and circumflex */
703 		ascebc['['] = 0xad;
704 		ascebc[']'] = 0xbd;
705 		ascebc['^'] = 0xb0;
706 	}
707 	rp->ascebc = ascebc;
708 
709 	/* Set defaults. */
710 	rp->rows = 24;
711 	rp->cols = 80;
712 
713 	INIT_LIST_HEAD(&rp->req_queue);
714 	INIT_LIST_HEAD(&rp->view_list);
715 
716 	rp->init_view.dev = rp;
717 	rp->init_view.fn = &raw3270_init_fn;
718 	rp->view = &rp->init_view;
719 
720 	/*
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().
724 	 */
725 	mutex_lock(&raw3270_mutex);
726 	/* Keep the list sorted. */
727 	minor = RAW3270_FIRSTMINOR;
728 	rp->minor = -1;
729 	list_for_each(l, &raw3270_devices) {
730 		tmp = list_entry(l, struct raw3270, list);
731 		if (tmp->minor > minor) {
732 			rp->minor = minor;
733 			__list_add(&rp->list, l->prev, l);
734 			break;
735 		}
736 		minor++;
737 	}
738 	if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
739 		rp->minor = minor;
740 		list_add_tail(&rp->list, &raw3270_devices);
741 	}
742 	mutex_unlock(&raw3270_mutex);
743 	/* No free minor number? Then give up. */
744 	if (rp->minor == -1)
745 		return -EUSERS;
746 	rp->cdev = cdev;
747 	dev_set_drvdata(&cdev->dev, rp);
748 	cdev->handler = raw3270_irq;
749 	return 0;
750 }
751 
752 #ifdef CONFIG_TN3270_CONSOLE
753 /* Tentative definition - see below for actual definition. */
754 static struct ccw_driver raw3270_ccw_driver;
755 
756 /*
757  * Setup 3270 device configured as console.
758  */
759 struct raw3270 __init *raw3270_setup_console(void)
760 {
761 	struct ccw_device *cdev;
762 	unsigned long flags;
763 	struct raw3270 *rp;
764 	char *ascebc;
765 	int rc;
766 
767 	cdev = ccw_device_create_console(&raw3270_ccw_driver);
768 	if (IS_ERR(cdev))
769 		return ERR_CAST(cdev);
770 
771 	rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
772 	ascebc = kzalloc(256, GFP_KERNEL);
773 	rc = raw3270_setup_device(cdev, rp, ascebc);
774 	if (rc)
775 		return ERR_PTR(rc);
776 	set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
777 
778 	rc = ccw_device_enable_console(cdev);
779 	if (rc) {
780 		ccw_device_destroy_console(cdev);
781 		return ERR_PTR(rc);
782 	}
783 
784 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
785 	do {
786 		__raw3270_reset_device(rp);
787 		while (!raw3270_state_final(rp)) {
788 			ccw_device_wait_idle(rp->cdev);
789 			barrier();
790 		}
791 	} while (rp->state != RAW3270_STATE_READY);
792 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
793 	return rp;
794 }
795 
796 void
797 raw3270_wait_cons_dev(struct raw3270 *rp)
798 {
799 	unsigned long flags;
800 
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);
804 }
805 
806 #endif
807 
808 /*
809  * Create a 3270 device structure.
810  */
811 static struct raw3270 *
812 raw3270_create_device(struct ccw_device *cdev)
813 {
814 	struct raw3270 *rp;
815 	char *ascebc;
816 	int rc;
817 
818 	rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
819 	if (!rp)
820 		return ERR_PTR(-ENOMEM);
821 	ascebc = kmalloc(256, GFP_KERNEL);
822 	if (!ascebc) {
823 		kfree(rp);
824 		return ERR_PTR(-ENOMEM);
825 	}
826 	rc = raw3270_setup_device(cdev, rp, ascebc);
827 	if (rc) {
828 		kfree(rp->ascebc);
829 		kfree(rp);
830 		rp = ERR_PTR(rc);
831 	}
832 	/* Get reference to ccw_device structure. */
833 	get_device(&cdev->dev);
834 	return rp;
835 }
836 
837 /*
838  * Activate a view.
839  */
840 int
841 raw3270_activate_view(struct raw3270_view *view)
842 {
843 	struct raw3270 *rp;
844 	struct raw3270_view *oldview, *nv;
845 	unsigned long flags;
846 	int rc;
847 
848 	rp = view->dev;
849 	if (!rp)
850 		return -ENODEV;
851 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
852 	if (rp->view == view)
853 		rc = 0;
854 	else if (!raw3270_state_ready(rp))
855 		rc = -EBUSY;
856 	else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
857 		rc = -EACCES;
858 	else {
859 		oldview = NULL;
860 		if (rp->view && rp->view->fn->deactivate) {
861 			oldview = rp->view;
862 			oldview->fn->deactivate(oldview);
863 		}
864 		rp->view = view;
865 		rc = view->fn->activate(view);
866 		if (rc) {
867 			/* Didn't work. Try to reactivate the old view. */
868 			rp->view = oldview;
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) {
873 						rp->view = nv;
874 						if (nv->fn->activate(nv) == 0)
875 							break;
876 						rp->view = NULL;
877 					}
878 			}
879 		}
880 	}
881 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
882 	return rc;
883 }
884 
885 /*
886  * Deactivate current view.
887  */
888 void
889 raw3270_deactivate_view(struct raw3270_view *view)
890 {
891 	unsigned long flags;
892 	struct raw3270 *rp;
893 
894 	rp = view->dev;
895 	if (!rp)
896 		return;
897 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
898 	if (rp->view == view) {
899 		view->fn->deactivate(view);
900 		rp->view = NULL;
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) {
908 				rp->view = view;
909 				if (view->fn->activate(view) == 0)
910 					break;
911 				rp->view = NULL;
912 			}
913 		}
914 	}
915 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
916 }
917 
918 /*
919  * Add view to device with minor "minor".
920  */
921 int
922 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
923 {
924 	unsigned long flags;
925 	struct raw3270 *rp;
926 	int rc;
927 
928 	if (minor <= 0)
929 		return -ENODEV;
930 	mutex_lock(&raw3270_mutex);
931 	rc = -ENODEV;
932 	list_for_each_entry(rp, &raw3270_devices, list) {
933 		if (rp->minor != minor)
934 			continue;
935 		spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
936 		atomic_set(&view->ref_count, 2);
937 		view->dev = rp;
938 		view->fn = fn;
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 		list_add(&view->list, &rp->view_list);
945 		rc = 0;
946 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
947 		break;
948 	}
949 	mutex_unlock(&raw3270_mutex);
950 	return rc;
951 }
952 
953 /*
954  * Find specific view of device with minor "minor".
955  */
956 struct raw3270_view *
957 raw3270_find_view(struct raw3270_fn *fn, int minor)
958 {
959 	struct raw3270 *rp;
960 	struct raw3270_view *view, *tmp;
961 	unsigned long flags;
962 
963 	mutex_lock(&raw3270_mutex);
964 	view = ERR_PTR(-ENODEV);
965 	list_for_each_entry(rp, &raw3270_devices, list) {
966 		if (rp->minor != minor)
967 			continue;
968 		spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
969 		list_for_each_entry(tmp, &rp->view_list, list) {
970 			if (tmp->fn == fn) {
971 				raw3270_get_view(tmp);
972 				view = tmp;
973 				break;
974 			}
975 		}
976 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
977 		break;
978 	}
979 	mutex_unlock(&raw3270_mutex);
980 	return view;
981 }
982 
983 /*
984  * Remove view from device and free view structure via call to view->fn->free.
985  */
986 void
987 raw3270_del_view(struct raw3270_view *view)
988 {
989 	unsigned long flags;
990 	struct raw3270 *rp;
991 	struct raw3270_view *nv;
992 
993 	rp = view->dev;
994 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
995 	if (rp->view == view) {
996 		view->fn->deactivate(view);
997 		rp->view = NULL;
998 	}
999 	list_del_init(&view->list);
1000 	if (!rp->view && raw3270_state_ready(rp) &&
1001 	    !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
1002 		/* Try to activate another view. */
1003 		list_for_each_entry(nv, &rp->view_list, list) {
1004 			if (nv->fn->activate(nv) == 0) {
1005 				rp->view = nv;
1006 				break;
1007 			}
1008 		}
1009 	}
1010 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1011 	/* Wait for reference counter to drop to zero. */
1012 	atomic_dec(&view->ref_count);
1013 	wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1014 	if (view->fn->free)
1015 		view->fn->free(view);
1016 }
1017 
1018 /*
1019  * Remove a 3270 device structure.
1020  */
1021 static void
1022 raw3270_delete_device(struct raw3270 *rp)
1023 {
1024 	struct ccw_device *cdev;
1025 
1026 	/* Remove from device chain. */
1027 	mutex_lock(&raw3270_mutex);
1028 	list_del_init(&rp->list);
1029 	mutex_unlock(&raw3270_mutex);
1030 
1031 	/* Disconnect from ccw_device. */
1032 	cdev = rp->cdev;
1033 	rp->cdev = NULL;
1034 	dev_set_drvdata(&cdev->dev, NULL);
1035 	cdev->handler = NULL;
1036 
1037 	/* Put ccw_device structure. */
1038 	put_device(&cdev->dev);
1039 
1040 	/* Now free raw3270 structure. */
1041 	kfree(rp->ascebc);
1042 	kfree(rp);
1043 }
1044 
1045 static int
1046 raw3270_probe (struct ccw_device *cdev)
1047 {
1048 	return 0;
1049 }
1050 
1051 /*
1052  * Additional attributes for a 3270 device
1053  */
1054 static ssize_t
1055 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1056 {
1057 	return snprintf(buf, PAGE_SIZE, "%i\n",
1058 			((struct raw3270 *) dev_get_drvdata(dev))->model);
1059 }
1060 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1061 
1062 static ssize_t
1063 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1064 {
1065 	return snprintf(buf, PAGE_SIZE, "%i\n",
1066 			((struct raw3270 *) dev_get_drvdata(dev))->rows);
1067 }
1068 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1069 
1070 static ssize_t
1071 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1072 {
1073 	return snprintf(buf, PAGE_SIZE, "%i\n",
1074 			((struct raw3270 *) dev_get_drvdata(dev))->cols);
1075 }
1076 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1077 
1078 static struct attribute * raw3270_attrs[] = {
1079 	&dev_attr_model.attr,
1080 	&dev_attr_rows.attr,
1081 	&dev_attr_columns.attr,
1082 	NULL,
1083 };
1084 
1085 static struct attribute_group raw3270_attr_group = {
1086 	.attrs = raw3270_attrs,
1087 };
1088 
1089 static int raw3270_create_attributes(struct raw3270 *rp)
1090 {
1091 	return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1092 }
1093 
1094 /*
1095  * Notifier for device addition/removal
1096  */
1097 static LIST_HEAD(raw3270_notifier);
1098 
1099 int raw3270_register_notifier(struct raw3270_notifier *notifier)
1100 {
1101 	struct raw3270 *rp;
1102 
1103 	mutex_lock(&raw3270_mutex);
1104 	list_add_tail(&notifier->list, &raw3270_notifier);
1105 	list_for_each_entry(rp, &raw3270_devices, list)
1106 		notifier->create(rp->minor);
1107 	mutex_unlock(&raw3270_mutex);
1108 	return 0;
1109 }
1110 
1111 void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
1112 {
1113 	struct raw3270 *rp;
1114 
1115 	mutex_lock(&raw3270_mutex);
1116 	list_for_each_entry(rp, &raw3270_devices, list)
1117 		notifier->destroy(rp->minor);
1118 	list_del(&notifier->list);
1119 	mutex_unlock(&raw3270_mutex);
1120 }
1121 
1122 /*
1123  * Set 3270 device online.
1124  */
1125 static int
1126 raw3270_set_online (struct ccw_device *cdev)
1127 {
1128 	struct raw3270_notifier *np;
1129 	struct raw3270 *rp;
1130 	int rc;
1131 
1132 	rp = raw3270_create_device(cdev);
1133 	if (IS_ERR(rp))
1134 		return PTR_ERR(rp);
1135 	rc = raw3270_create_attributes(rp);
1136 	if (rc)
1137 		goto failure;
1138 	raw3270_reset_device(rp);
1139 	mutex_lock(&raw3270_mutex);
1140 	list_for_each_entry(np, &raw3270_notifier, list)
1141 		np->create(rp->minor);
1142 	mutex_unlock(&raw3270_mutex);
1143 	return 0;
1144 
1145 failure:
1146 	raw3270_delete_device(rp);
1147 	return rc;
1148 }
1149 
1150 /*
1151  * Remove 3270 device structure.
1152  */
1153 static void
1154 raw3270_remove (struct ccw_device *cdev)
1155 {
1156 	unsigned long flags;
1157 	struct raw3270 *rp;
1158 	struct raw3270_view *v;
1159 	struct raw3270_notifier *np;
1160 
1161 	rp = dev_get_drvdata(&cdev->dev);
1162 	/*
1163 	 * _remove is the opposite of _probe; it's probe that
1164 	 * should set up rp.  raw3270_remove gets entered for
1165 	 * devices even if they haven't been varied online.
1166 	 * Thus, rp may validly be NULL here.
1167 	 */
1168 	if (rp == NULL)
1169 		return;
1170 
1171 	sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1172 
1173 	/* Deactivate current view and remove all views. */
1174 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1175 	if (rp->view) {
1176 		if (rp->view->fn->deactivate)
1177 			rp->view->fn->deactivate(rp->view);
1178 		rp->view = NULL;
1179 	}
1180 	while (!list_empty(&rp->view_list)) {
1181 		v = list_entry(rp->view_list.next, struct raw3270_view, list);
1182 		if (v->fn->release)
1183 			v->fn->release(v);
1184 		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1185 		raw3270_del_view(v);
1186 		spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1187 	}
1188 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1189 
1190 	mutex_lock(&raw3270_mutex);
1191 	list_for_each_entry(np, &raw3270_notifier, list)
1192 		np->destroy(rp->minor);
1193 	mutex_unlock(&raw3270_mutex);
1194 
1195 	/* Reset 3270 device. */
1196 	raw3270_reset_device(rp);
1197 	/* And finally remove it. */
1198 	raw3270_delete_device(rp);
1199 }
1200 
1201 /*
1202  * Set 3270 device offline.
1203  */
1204 static int
1205 raw3270_set_offline (struct ccw_device *cdev)
1206 {
1207 	struct raw3270 *rp;
1208 
1209 	rp = dev_get_drvdata(&cdev->dev);
1210 	if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1211 		return -EBUSY;
1212 	raw3270_remove(cdev);
1213 	return 0;
1214 }
1215 
1216 static int raw3270_pm_stop(struct ccw_device *cdev)
1217 {
1218 	struct raw3270 *rp;
1219 	struct raw3270_view *view;
1220 	unsigned long flags;
1221 
1222 	rp = dev_get_drvdata(&cdev->dev);
1223 	if (!rp)
1224 		return 0;
1225 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1226 	if (rp->view && rp->view->fn->deactivate)
1227 		rp->view->fn->deactivate(rp->view);
1228 	if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1229 		/*
1230 		 * Release tty and fullscreen for all non-console
1231 		 * devices.
1232 		 */
1233 		list_for_each_entry(view, &rp->view_list, list) {
1234 			if (view->fn->release)
1235 				view->fn->release(view);
1236 		}
1237 	}
1238 	set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1239 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1240 	return 0;
1241 }
1242 
1243 static int raw3270_pm_start(struct ccw_device *cdev)
1244 {
1245 	struct raw3270 *rp;
1246 	unsigned long flags;
1247 
1248 	rp = dev_get_drvdata(&cdev->dev);
1249 	if (!rp)
1250 		return 0;
1251 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1252 	clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1253 	if (rp->view && rp->view->fn->activate)
1254 		rp->view->fn->activate(rp->view);
1255 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1256 	return 0;
1257 }
1258 
1259 void raw3270_pm_unfreeze(struct raw3270_view *view)
1260 {
1261 #ifdef CONFIG_TN3270_CONSOLE
1262 	struct raw3270 *rp;
1263 
1264 	rp = view->dev;
1265 	if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1266 		ccw_device_force_console(rp->cdev);
1267 #endif
1268 }
1269 
1270 static struct ccw_device_id raw3270_id[] = {
1271 	{ CCW_DEVICE(0x3270, 0) },
1272 	{ CCW_DEVICE(0x3271, 0) },
1273 	{ CCW_DEVICE(0x3272, 0) },
1274 	{ CCW_DEVICE(0x3273, 0) },
1275 	{ CCW_DEVICE(0x3274, 0) },
1276 	{ CCW_DEVICE(0x3275, 0) },
1277 	{ CCW_DEVICE(0x3276, 0) },
1278 	{ CCW_DEVICE(0x3277, 0) },
1279 	{ CCW_DEVICE(0x3278, 0) },
1280 	{ CCW_DEVICE(0x3279, 0) },
1281 	{ CCW_DEVICE(0x3174, 0) },
1282 	{ /* end of list */ },
1283 };
1284 
1285 static struct ccw_driver raw3270_ccw_driver = {
1286 	.driver = {
1287 		.name	= "3270",
1288 		.owner	= THIS_MODULE,
1289 	},
1290 	.ids		= raw3270_id,
1291 	.probe		= &raw3270_probe,
1292 	.remove		= &raw3270_remove,
1293 	.set_online	= &raw3270_set_online,
1294 	.set_offline	= &raw3270_set_offline,
1295 	.freeze		= &raw3270_pm_stop,
1296 	.thaw		= &raw3270_pm_start,
1297 	.restore	= &raw3270_pm_start,
1298 	.int_class	= IRQIO_C70,
1299 };
1300 
1301 static int
1302 raw3270_init(void)
1303 {
1304 	struct raw3270 *rp;
1305 	int rc;
1306 
1307 	if (raw3270_registered)
1308 		return 0;
1309 	raw3270_registered = 1;
1310 	rc = ccw_driver_register(&raw3270_ccw_driver);
1311 	if (rc == 0) {
1312 		/* Create attributes for early (= console) device. */
1313 		mutex_lock(&raw3270_mutex);
1314 		class3270 = class_create(THIS_MODULE, "3270");
1315 		list_for_each_entry(rp, &raw3270_devices, list) {
1316 			get_device(&rp->cdev->dev);
1317 			raw3270_create_attributes(rp);
1318 		}
1319 		mutex_unlock(&raw3270_mutex);
1320 	}
1321 	return rc;
1322 }
1323 
1324 static void
1325 raw3270_exit(void)
1326 {
1327 	ccw_driver_unregister(&raw3270_ccw_driver);
1328 	class_destroy(class3270);
1329 }
1330 
1331 MODULE_LICENSE("GPL");
1332 
1333 module_init(raw3270_init);
1334 module_exit(raw3270_exit);
1335 
1336 EXPORT_SYMBOL(class3270);
1337 EXPORT_SYMBOL(raw3270_request_alloc);
1338 EXPORT_SYMBOL(raw3270_request_free);
1339 EXPORT_SYMBOL(raw3270_request_reset);
1340 EXPORT_SYMBOL(raw3270_request_set_cmd);
1341 EXPORT_SYMBOL(raw3270_request_add_data);
1342 EXPORT_SYMBOL(raw3270_request_set_data);
1343 EXPORT_SYMBOL(raw3270_request_set_idal);
1344 EXPORT_SYMBOL(raw3270_buffer_address);
1345 EXPORT_SYMBOL(raw3270_add_view);
1346 EXPORT_SYMBOL(raw3270_del_view);
1347 EXPORT_SYMBOL(raw3270_find_view);
1348 EXPORT_SYMBOL(raw3270_activate_view);
1349 EXPORT_SYMBOL(raw3270_deactivate_view);
1350 EXPORT_SYMBOL(raw3270_start);
1351 EXPORT_SYMBOL(raw3270_start_locked);
1352 EXPORT_SYMBOL(raw3270_start_irq);
1353 EXPORT_SYMBOL(raw3270_reset);
1354 EXPORT_SYMBOL(raw3270_register_notifier);
1355 EXPORT_SYMBOL(raw3270_unregister_notifier);
1356 EXPORT_SYMBOL(raw3270_wait_queue);
1357