1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * IBM/3270 Driver - core functions.
4  *
5  * Author(s):
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 IBM Corp. 2003, 2009
9  */
10 
11 #include <linux/module.h>
12 #include <linux/err.h>
13 #include <linux/init.h>
14 #include <linux/interrupt.h>
15 #include <linux/list.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18 #include <linux/wait.h>
19 
20 #include <asm/ccwdev.h>
21 #include <asm/cio.h>
22 #include <asm/ebcdic.h>
23 #include <asm/diag.h>
24 
25 #include "raw3270.h"
26 
27 #include <linux/major.h>
28 #include <linux/kdev_t.h>
29 #include <linux/device.h>
30 #include <linux/mutex.h>
31 
32 struct class *class3270;
33 
34 /* The main 3270 data structure. */
35 struct raw3270 {
36 	struct list_head list;
37 	struct ccw_device *cdev;
38 	int minor;
39 
40 	short model, rows, cols;
41 	unsigned int state;
42 	unsigned long flags;
43 
44 	struct list_head req_queue;	/* Request queue. */
45 	struct list_head view_list;	/* List of available views. */
46 	struct raw3270_view *view;	/* Active view. */
47 
48 	struct timer_list timer;	/* Device timer. */
49 
50 	unsigned char *ascebc;		/* ascii -> ebcdic table */
51 
52 	struct raw3270_view init_view;
53 	struct raw3270_request init_reset;
54 	struct raw3270_request init_readpart;
55 	struct raw3270_request init_readmod;
56 	unsigned char init_data[256];
57 };
58 
59 /* raw3270->state */
60 #define RAW3270_STATE_INIT	0	/* Initial state */
61 #define RAW3270_STATE_RESET	1	/* Reset command is pending */
62 #define RAW3270_STATE_W4ATTN	2	/* Wait for attention interrupt */
63 #define RAW3270_STATE_READMOD	3	/* Read partition is pending */
64 #define RAW3270_STATE_READY	4	/* Device is usable by views */
65 
66 /* raw3270->flags */
67 #define RAW3270_FLAGS_14BITADDR	0	/* 14-bit buffer addresses */
68 #define RAW3270_FLAGS_BUSY	1	/* Device busy, leave it alone */
69 #define RAW3270_FLAGS_CONSOLE	2	/* Device is the console. */
70 #define RAW3270_FLAGS_FROZEN	3	/* set if 3270 is frozen for suspend */
71 
72 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
73 static DEFINE_MUTEX(raw3270_mutex);
74 
75 /* List of 3270 devices. */
76 static LIST_HEAD(raw3270_devices);
77 
78 /*
79  * Flag to indicate if the driver has been registered. Some operations
80  * like waiting for the end of i/o need to be done differently as long
81  * as the kernel is still starting up (console support).
82  */
83 static int raw3270_registered;
84 
85 /* Module parameters */
86 static bool tubxcorrect;
87 module_param(tubxcorrect, bool, 0);
88 
89 /*
90  * Wait queue for device init/delete, view delete.
91  */
92 DECLARE_WAIT_QUEUE_HEAD(raw3270_wait_queue);
93 
94 static void __raw3270_disconnect(struct raw3270 *rp);
95 
96 /*
97  * Encode array for 12 bit 3270 addresses.
98  */
99 static unsigned char raw3270_ebcgraf[64] =	{
100 	0x40, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
101 	0xc8, 0xc9, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
102 	0x50, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
103 	0xd8, 0xd9, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
104 	0x60, 0x61, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
105 	0xe8, 0xe9, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
106 	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
107 	0xf8, 0xf9, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
108 };
109 
raw3270_state_ready(struct raw3270 * rp)110 static inline int raw3270_state_ready(struct raw3270 *rp)
111 {
112 	return rp->state == RAW3270_STATE_READY;
113 }
114 
raw3270_state_final(struct raw3270 * rp)115 static inline int raw3270_state_final(struct raw3270 *rp)
116 {
117 	return rp->state == RAW3270_STATE_INIT ||
118 		rp->state == RAW3270_STATE_READY;
119 }
120 
121 void
raw3270_buffer_address(struct raw3270 * rp,char * cp,unsigned short addr)122 raw3270_buffer_address(struct raw3270 *rp, char *cp, unsigned short addr)
123 {
124 	if (test_bit(RAW3270_FLAGS_14BITADDR, &rp->flags)) {
125 		cp[0] = (addr >> 8) & 0x3f;
126 		cp[1] = addr & 0xff;
127 	} else {
128 		cp[0] = raw3270_ebcgraf[(addr >> 6) & 0x3f];
129 		cp[1] = raw3270_ebcgraf[addr & 0x3f];
130 	}
131 }
132 
133 /*
134  * Allocate a new 3270 ccw request
135  */
136 struct raw3270_request *
raw3270_request_alloc(size_t size)137 raw3270_request_alloc(size_t size)
138 {
139 	struct raw3270_request *rq;
140 
141 	/* Allocate request structure */
142 	rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
143 	if (!rq)
144 		return ERR_PTR(-ENOMEM);
145 
146 	/* alloc output buffer. */
147 	if (size > 0) {
148 		rq->buffer = kmalloc(size, GFP_KERNEL | GFP_DMA);
149 		if (!rq->buffer) {
150 			kfree(rq);
151 			return ERR_PTR(-ENOMEM);
152 		}
153 	}
154 	rq->size = size;
155 	INIT_LIST_HEAD(&rq->list);
156 
157 	/*
158 	 * Setup ccw.
159 	 */
160 	rq->ccw.cda = __pa(rq->buffer);
161 	rq->ccw.flags = CCW_FLAG_SLI;
162 
163 	return rq;
164 }
165 
166 /*
167  * Free 3270 ccw request
168  */
169 void
raw3270_request_free(struct raw3270_request * rq)170 raw3270_request_free (struct raw3270_request *rq)
171 {
172 	kfree(rq->buffer);
173 	kfree(rq);
174 }
175 
176 /*
177  * Reset request to initial state.
178  */
179 void
raw3270_request_reset(struct raw3270_request * rq)180 raw3270_request_reset(struct raw3270_request *rq)
181 {
182 	BUG_ON(!list_empty(&rq->list));
183 	rq->ccw.cmd_code = 0;
184 	rq->ccw.count = 0;
185 	rq->ccw.cda = __pa(rq->buffer);
186 	rq->ccw.flags = CCW_FLAG_SLI;
187 	rq->rescnt = 0;
188 	rq->rc = 0;
189 }
190 
191 /*
192  * Set command code to ccw of a request.
193  */
194 void
raw3270_request_set_cmd(struct raw3270_request * rq,u8 cmd)195 raw3270_request_set_cmd(struct raw3270_request *rq, u8 cmd)
196 {
197 	rq->ccw.cmd_code = cmd;
198 }
199 
200 /*
201  * Add data fragment to output buffer.
202  */
203 int
raw3270_request_add_data(struct raw3270_request * rq,void * data,size_t size)204 raw3270_request_add_data(struct raw3270_request *rq, void *data, size_t size)
205 {
206 	if (size + rq->ccw.count > rq->size)
207 		return -E2BIG;
208 	memcpy(rq->buffer + rq->ccw.count, data, size);
209 	rq->ccw.count += size;
210 	return 0;
211 }
212 
213 /*
214  * Set address/length pair to ccw of a request.
215  */
216 void
raw3270_request_set_data(struct raw3270_request * rq,void * data,size_t size)217 raw3270_request_set_data(struct raw3270_request *rq, void *data, size_t size)
218 {
219 	rq->ccw.cda = __pa(data);
220 	rq->ccw.count = size;
221 }
222 
223 /*
224  * Set idal buffer to ccw of a request.
225  */
226 void
raw3270_request_set_idal(struct raw3270_request * rq,struct idal_buffer * ib)227 raw3270_request_set_idal(struct raw3270_request *rq, struct idal_buffer *ib)
228 {
229 	rq->ccw.cda = __pa(ib->data);
230 	rq->ccw.count = ib->size;
231 	rq->ccw.flags |= CCW_FLAG_IDA;
232 }
233 
234 /*
235  * Add the request to the request queue, try to start it if the
236  * 3270 device is idle. Return without waiting for end of i/o.
237  */
238 static int
__raw3270_start(struct raw3270 * rp,struct raw3270_view * view,struct raw3270_request * rq)239 __raw3270_start(struct raw3270 *rp, struct raw3270_view *view,
240 		struct raw3270_request *rq)
241 {
242 	rq->view = view;
243 	raw3270_get_view(view);
244 	if (list_empty(&rp->req_queue) &&
245 	    !test_bit(RAW3270_FLAGS_BUSY, &rp->flags)) {
246 		/* No other requests are on the queue. Start this one. */
247 		rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
248 					       (unsigned long) rq, 0, 0);
249 		if (rq->rc) {
250 			raw3270_put_view(view);
251 			return rq->rc;
252 		}
253 	}
254 	list_add_tail(&rq->list, &rp->req_queue);
255 	return 0;
256 }
257 
258 int
raw3270_view_active(struct raw3270_view * view)259 raw3270_view_active(struct raw3270_view *view)
260 {
261 	struct raw3270 *rp = view->dev;
262 
263 	return rp && rp->view == view &&
264 		!test_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
265 }
266 
267 int
raw3270_start(struct raw3270_view * view,struct raw3270_request * rq)268 raw3270_start(struct raw3270_view *view, struct raw3270_request *rq)
269 {
270 	unsigned long flags;
271 	struct raw3270 *rp;
272 	int rc;
273 
274 	spin_lock_irqsave(get_ccwdev_lock(view->dev->cdev), flags);
275 	rp = view->dev;
276 	if (!rp || rp->view != view ||
277 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
278 		rc = -EACCES;
279 	else if (!raw3270_state_ready(rp))
280 		rc = -EBUSY;
281 	else
282 		rc =  __raw3270_start(rp, view, rq);
283 	spin_unlock_irqrestore(get_ccwdev_lock(view->dev->cdev), flags);
284 	return rc;
285 }
286 
287 int
raw3270_start_locked(struct raw3270_view * view,struct raw3270_request * rq)288 raw3270_start_locked(struct raw3270_view *view, struct raw3270_request *rq)
289 {
290 	struct raw3270 *rp;
291 	int rc;
292 
293 	rp = view->dev;
294 	if (!rp || rp->view != view ||
295 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
296 		rc = -EACCES;
297 	else if (!raw3270_state_ready(rp))
298 		rc = -EBUSY;
299 	else
300 		rc =  __raw3270_start(rp, view, rq);
301 	return rc;
302 }
303 
304 int
raw3270_start_irq(struct raw3270_view * view,struct raw3270_request * rq)305 raw3270_start_irq(struct raw3270_view *view, struct raw3270_request *rq)
306 {
307 	struct raw3270 *rp;
308 
309 	rp = view->dev;
310 	rq->view = view;
311 	raw3270_get_view(view);
312 	list_add_tail(&rq->list, &rp->req_queue);
313 	return 0;
314 }
315 
316 /*
317  * 3270 interrupt routine, called from the ccw_device layer
318  */
319 static void
raw3270_irq(struct ccw_device * cdev,unsigned long intparm,struct irb * irb)320 raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
321 {
322 	struct raw3270 *rp;
323 	struct raw3270_view *view;
324 	struct raw3270_request *rq;
325 
326 	rp = dev_get_drvdata(&cdev->dev);
327 	if (!rp)
328 		return;
329 	rq = (struct raw3270_request *) intparm;
330 	view = rq ? rq->view : rp->view;
331 
332 	if (!IS_ERR(irb)) {
333 		/* Handle CE-DE-UE and subsequent UDE */
334 		if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END)
335 			clear_bit(RAW3270_FLAGS_BUSY, &rp->flags);
336 		if (irb->scsw.cmd.dstat == (DEV_STAT_CHN_END |
337 					    DEV_STAT_DEV_END |
338 					    DEV_STAT_UNIT_EXCEP))
339 			set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
340 		/* Handle disconnected devices */
341 		if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
342 		    (irb->ecw[0] & SNS0_INTERVENTION_REQ)) {
343 			set_bit(RAW3270_FLAGS_BUSY, &rp->flags);
344 			if (rp->state > RAW3270_STATE_RESET)
345 				__raw3270_disconnect(rp);
346 		}
347 		/* Call interrupt handler of the view */
348 		if (view)
349 			view->fn->intv(view, rq, irb);
350 	}
351 
352 	if (test_bit(RAW3270_FLAGS_BUSY, &rp->flags))
353 		/* Device busy, do not start I/O */
354 		return;
355 
356 	if (rq && !list_empty(&rq->list)) {
357 		/* The request completed, remove from queue and do callback. */
358 		list_del_init(&rq->list);
359 		if (rq->callback)
360 			rq->callback(rq, rq->callback_data);
361 		/* Do put_device for get_device in raw3270_start. */
362 		raw3270_put_view(view);
363 	}
364 
365 	/*
366 	 * Try to start each request on request queue until one is
367 	 * started successful.
368 	 */
369 	while (!list_empty(&rp->req_queue)) {
370 		rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
371 		rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
372 					  (unsigned long) rq, 0, 0);
373 		if (rq->rc == 0)
374 			break;
375 		/* Start failed. Remove request and do callback. */
376 		list_del_init(&rq->list);
377 		if (rq->callback)
378 			rq->callback(rq, rq->callback_data);
379 		/* Do put_device for get_device in raw3270_start. */
380 		raw3270_put_view(view);
381 	}
382 }
383 
384 /*
385  * To determine the size of the 3270 device we need to do:
386  * 1) send a 'read partition' data stream to the device
387  * 2) wait for the attn interrupt that precedes the query reply
388  * 3) do a read modified to get the query reply
389  * To make things worse we have to cope with intervention
390  * required (3270 device switched to 'stand-by') and command
391  * rejects (old devices that can't do 'read partition').
392  */
393 struct raw3270_ua {	/* Query Reply structure for Usable Area */
394 	struct {	/* Usable Area Query Reply Base */
395 		short l;	/* Length of this structured field */
396 		char  sfid;	/* 0x81 if Query Reply */
397 		char  qcode;	/* 0x81 if Usable Area */
398 		char  flags0;
399 		char  flags1;
400 		short w;	/* Width of usable area */
401 		short h;	/* Heigth of usavle area */
402 		char  units;	/* 0x00:in; 0x01:mm */
403 		int   xr;
404 		int   yr;
405 		char  aw;
406 		char  ah;
407 		short buffsz;	/* Character buffer size, bytes */
408 		char  xmin;
409 		char  ymin;
410 		char  xmax;
411 		char  ymax;
412 	} __attribute__ ((packed)) uab;
413 	struct {	/* Alternate Usable Area Self-Defining Parameter */
414 		char  l;	/* Length of this Self-Defining Parm */
415 		char  sdpid;	/* 0x02 if Alternate Usable Area */
416 		char  res;
417 		char  auaid;	/* 0x01 is Id for the A U A */
418 		short wauai;	/* Width of AUAi */
419 		short hauai;	/* Height of AUAi */
420 		char  auaunits;	/* 0x00:in, 0x01:mm */
421 		int   auaxr;
422 		int   auayr;
423 		char  awauai;
424 		char  ahauai;
425 	} __attribute__ ((packed)) aua;
426 } __attribute__ ((packed));
427 
428 static void
raw3270_size_device_vm(struct raw3270 * rp)429 raw3270_size_device_vm(struct raw3270 *rp)
430 {
431 	int rc, model;
432 	struct ccw_dev_id dev_id;
433 	struct diag210 diag_data;
434 
435 	ccw_device_get_id(rp->cdev, &dev_id);
436 	diag_data.vrdcdvno = dev_id.devno;
437 	diag_data.vrdclen = sizeof(struct diag210);
438 	rc = diag210(&diag_data);
439 	model = diag_data.vrdccrmd;
440 	/* Use default model 2 if the size could not be detected */
441 	if (rc || model < 2 || model > 5)
442 		model = 2;
443 	switch (model) {
444 	case 2:
445 		rp->model = model;
446 		rp->rows = 24;
447 		rp->cols = 80;
448 		break;
449 	case 3:
450 		rp->model = model;
451 		rp->rows = 32;
452 		rp->cols = 80;
453 		break;
454 	case 4:
455 		rp->model = model;
456 		rp->rows = 43;
457 		rp->cols = 80;
458 		break;
459 	case 5:
460 		rp->model = model;
461 		rp->rows = 27;
462 		rp->cols = 132;
463 		break;
464 	}
465 }
466 
467 static void
raw3270_size_device(struct raw3270 * rp)468 raw3270_size_device(struct raw3270 *rp)
469 {
470 	struct raw3270_ua *uap;
471 
472 	/* Got a Query Reply */
473 	uap = (struct raw3270_ua *) (rp->init_data + 1);
474 	/* Paranoia check. */
475 	if (rp->init_readmod.rc || rp->init_data[0] != 0x88 ||
476 	    uap->uab.qcode != 0x81) {
477 		/* Couldn't detect size. Use default model 2. */
478 		rp->model = 2;
479 		rp->rows = 24;
480 		rp->cols = 80;
481 		return;
482 	}
483 	/* Copy rows/columns of default Usable Area */
484 	rp->rows = uap->uab.h;
485 	rp->cols = uap->uab.w;
486 	/* Check for 14 bit addressing */
487 	if ((uap->uab.flags0 & 0x0d) == 0x01)
488 		set_bit(RAW3270_FLAGS_14BITADDR, &rp->flags);
489 	/* Check for Alternate Usable Area */
490 	if (uap->uab.l == sizeof(struct raw3270_ua) &&
491 	    uap->aua.sdpid == 0x02) {
492 		rp->rows = uap->aua.hauai;
493 		rp->cols = uap->aua.wauai;
494 	}
495 	/* Try to find a model. */
496 	rp->model = 0;
497 	if (rp->rows == 24 && rp->cols == 80)
498 		rp->model = 2;
499 	if (rp->rows == 32 && rp->cols == 80)
500 		rp->model = 3;
501 	if (rp->rows == 43 && rp->cols == 80)
502 		rp->model = 4;
503 	if (rp->rows == 27 && rp->cols == 132)
504 		rp->model = 5;
505 }
506 
507 static void
raw3270_size_device_done(struct raw3270 * rp)508 raw3270_size_device_done(struct raw3270 *rp)
509 {
510 	struct raw3270_view *view;
511 
512 	rp->view = NULL;
513 	rp->state = RAW3270_STATE_READY;
514 	/* Notify views about new size */
515 	list_for_each_entry(view, &rp->view_list, list)
516 		if (view->fn->resize)
517 			view->fn->resize(view, rp->model, rp->rows, rp->cols);
518 	/* Setup processing done, now activate a view */
519 	list_for_each_entry(view, &rp->view_list, list) {
520 		rp->view = view;
521 		if (view->fn->activate(view) == 0)
522 			break;
523 		rp->view = NULL;
524 	}
525 }
526 
527 static void
raw3270_read_modified_cb(struct raw3270_request * rq,void * data)528 raw3270_read_modified_cb(struct raw3270_request *rq, void *data)
529 {
530 	struct raw3270 *rp = rq->view->dev;
531 
532 	raw3270_size_device(rp);
533 	raw3270_size_device_done(rp);
534 }
535 
536 static void
raw3270_read_modified(struct raw3270 * rp)537 raw3270_read_modified(struct raw3270 *rp)
538 {
539 	if (rp->state != RAW3270_STATE_W4ATTN)
540 		return;
541 	/* Use 'read modified' to get the result of a read partition. */
542 	memset(&rp->init_readmod, 0, sizeof(rp->init_readmod));
543 	memset(&rp->init_data, 0, sizeof(rp->init_data));
544 	rp->init_readmod.ccw.cmd_code = TC_READMOD;
545 	rp->init_readmod.ccw.flags = CCW_FLAG_SLI;
546 	rp->init_readmod.ccw.count = sizeof(rp->init_data);
547 	rp->init_readmod.ccw.cda = (__u32) __pa(rp->init_data);
548 	rp->init_readmod.callback = raw3270_read_modified_cb;
549 	rp->state = RAW3270_STATE_READMOD;
550 	raw3270_start_irq(&rp->init_view, &rp->init_readmod);
551 }
552 
553 static void
raw3270_writesf_readpart(struct raw3270 * rp)554 raw3270_writesf_readpart(struct raw3270 *rp)
555 {
556 	static const unsigned char wbuf[] =
557 		{ 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
558 
559 	/* Store 'read partition' data stream to init_data */
560 	memset(&rp->init_readpart, 0, sizeof(rp->init_readpart));
561 	memset(&rp->init_data, 0, sizeof(rp->init_data));
562 	memcpy(&rp->init_data, wbuf, sizeof(wbuf));
563 	rp->init_readpart.ccw.cmd_code = TC_WRITESF;
564 	rp->init_readpart.ccw.flags = CCW_FLAG_SLI;
565 	rp->init_readpart.ccw.count = sizeof(wbuf);
566 	rp->init_readpart.ccw.cda = (__u32) __pa(&rp->init_data);
567 	rp->state = RAW3270_STATE_W4ATTN;
568 	raw3270_start_irq(&rp->init_view, &rp->init_readpart);
569 }
570 
571 /*
572  * Device reset
573  */
574 static void
raw3270_reset_device_cb(struct raw3270_request * rq,void * data)575 raw3270_reset_device_cb(struct raw3270_request *rq, void *data)
576 {
577 	struct raw3270 *rp = rq->view->dev;
578 
579 	if (rp->state != RAW3270_STATE_RESET)
580 		return;
581 	if (rq->rc) {
582 		/* Reset command failed. */
583 		rp->state = RAW3270_STATE_INIT;
584 	} else if (MACHINE_IS_VM) {
585 		raw3270_size_device_vm(rp);
586 		raw3270_size_device_done(rp);
587 	} else
588 		raw3270_writesf_readpart(rp);
589 	memset(&rp->init_reset, 0, sizeof(rp->init_reset));
590 }
591 
592 static int
__raw3270_reset_device(struct raw3270 * rp)593 __raw3270_reset_device(struct raw3270 *rp)
594 {
595 	int rc;
596 
597 	/* Check if reset is already pending */
598 	if (rp->init_reset.view)
599 		return -EBUSY;
600 	/* Store reset data stream to init_data/init_reset */
601 	rp->init_data[0] = TW_KR;
602 	rp->init_reset.ccw.cmd_code = TC_EWRITEA;
603 	rp->init_reset.ccw.flags = CCW_FLAG_SLI;
604 	rp->init_reset.ccw.count = 1;
605 	rp->init_reset.ccw.cda = (__u32) __pa(rp->init_data);
606 	rp->init_reset.callback = raw3270_reset_device_cb;
607 	rc = __raw3270_start(rp, &rp->init_view, &rp->init_reset);
608 	if (rc == 0 && rp->state == RAW3270_STATE_INIT)
609 		rp->state = RAW3270_STATE_RESET;
610 	return rc;
611 }
612 
613 static int
raw3270_reset_device(struct raw3270 * rp)614 raw3270_reset_device(struct raw3270 *rp)
615 {
616 	unsigned long flags;
617 	int rc;
618 
619 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
620 	rc = __raw3270_reset_device(rp);
621 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
622 	return rc;
623 }
624 
625 int
raw3270_reset(struct raw3270_view * view)626 raw3270_reset(struct raw3270_view *view)
627 {
628 	struct raw3270 *rp;
629 	int rc;
630 
631 	rp = view->dev;
632 	if (!rp || rp->view != view ||
633 	    test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
634 		rc = -EACCES;
635 	else if (!raw3270_state_ready(rp))
636 		rc = -EBUSY;
637 	else
638 		rc = raw3270_reset_device(view->dev);
639 	return rc;
640 }
641 
642 static void
__raw3270_disconnect(struct raw3270 * rp)643 __raw3270_disconnect(struct raw3270 *rp)
644 {
645 	struct raw3270_request *rq;
646 	struct raw3270_view *view;
647 
648 	rp->state = RAW3270_STATE_INIT;
649 	rp->view = &rp->init_view;
650 	/* Cancel all queued requests */
651 	while (!list_empty(&rp->req_queue)) {
652 		rq = list_entry(rp->req_queue.next,struct raw3270_request,list);
653 		view = rq->view;
654 		rq->rc = -EACCES;
655 		list_del_init(&rq->list);
656 		if (rq->callback)
657 			rq->callback(rq, rq->callback_data);
658 		raw3270_put_view(view);
659 	}
660 	/* Start from scratch */
661 	__raw3270_reset_device(rp);
662 }
663 
664 static void
raw3270_init_irq(struct raw3270_view * view,struct raw3270_request * rq,struct irb * irb)665 raw3270_init_irq(struct raw3270_view *view, struct raw3270_request *rq,
666 		 struct irb *irb)
667 {
668 	struct raw3270 *rp;
669 
670 	if (rq) {
671 		if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
672 			if (irb->ecw[0] & SNS0_CMD_REJECT)
673 				rq->rc = -EOPNOTSUPP;
674 			else
675 				rq->rc = -EIO;
676 		}
677 	}
678 	if (irb->scsw.cmd.dstat & DEV_STAT_ATTENTION) {
679 		/* Queue read modified after attention interrupt */
680 		rp = view->dev;
681 		raw3270_read_modified(rp);
682 	}
683 }
684 
685 static struct raw3270_fn raw3270_init_fn = {
686 	.intv = raw3270_init_irq
687 };
688 
689 /*
690  * Setup new 3270 device.
691  */
692 static int
raw3270_setup_device(struct ccw_device * cdev,struct raw3270 * rp,char * ascebc)693 raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
694 {
695 	struct list_head *l;
696 	struct raw3270 *tmp;
697 	int minor;
698 
699 	memset(rp, 0, sizeof(struct raw3270));
700 	/* Copy ebcdic -> ascii translation table. */
701 	memcpy(ascebc, _ascebc, 256);
702 	if (tubxcorrect) {
703 		/* correct brackets and circumflex */
704 		ascebc['['] = 0xad;
705 		ascebc[']'] = 0xbd;
706 		ascebc['^'] = 0xb0;
707 	}
708 	rp->ascebc = ascebc;
709 
710 	/* Set defaults. */
711 	rp->rows = 24;
712 	rp->cols = 80;
713 
714 	INIT_LIST_HEAD(&rp->req_queue);
715 	INIT_LIST_HEAD(&rp->view_list);
716 
717 	rp->init_view.dev = rp;
718 	rp->init_view.fn = &raw3270_init_fn;
719 	rp->view = &rp->init_view;
720 
721 	/*
722 	 * Add device to list and find the smallest unused minor
723 	 * number for it. Note: there is no device with minor 0,
724 	 * see special case for fs3270.c:fs3270_open().
725 	 */
726 	mutex_lock(&raw3270_mutex);
727 	/* Keep the list sorted. */
728 	minor = RAW3270_FIRSTMINOR;
729 	rp->minor = -1;
730 	list_for_each(l, &raw3270_devices) {
731 		tmp = list_entry(l, struct raw3270, list);
732 		if (tmp->minor > minor) {
733 			rp->minor = minor;
734 			__list_add(&rp->list, l->prev, l);
735 			break;
736 		}
737 		minor++;
738 	}
739 	if (rp->minor == -1 && minor < RAW3270_MAXDEVS + RAW3270_FIRSTMINOR) {
740 		rp->minor = minor;
741 		list_add_tail(&rp->list, &raw3270_devices);
742 	}
743 	mutex_unlock(&raw3270_mutex);
744 	/* No free minor number? Then give up. */
745 	if (rp->minor == -1)
746 		return -EUSERS;
747 	rp->cdev = cdev;
748 	dev_set_drvdata(&cdev->dev, rp);
749 	cdev->handler = raw3270_irq;
750 	return 0;
751 }
752 
753 #ifdef CONFIG_TN3270_CONSOLE
754 /* Tentative definition - see below for actual definition. */
755 static struct ccw_driver raw3270_ccw_driver;
756 
757 /*
758  * Setup 3270 device configured as console.
759  */
raw3270_setup_console(void)760 struct raw3270 __init *raw3270_setup_console(void)
761 {
762 	struct ccw_device *cdev;
763 	unsigned long flags;
764 	struct raw3270 *rp;
765 	char *ascebc;
766 	int rc;
767 
768 	cdev = ccw_device_create_console(&raw3270_ccw_driver);
769 	if (IS_ERR(cdev))
770 		return ERR_CAST(cdev);
771 
772 	rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
773 	ascebc = kzalloc(256, GFP_KERNEL);
774 	rc = raw3270_setup_device(cdev, rp, ascebc);
775 	if (rc)
776 		return ERR_PTR(rc);
777 	set_bit(RAW3270_FLAGS_CONSOLE, &rp->flags);
778 
779 	rc = ccw_device_enable_console(cdev);
780 	if (rc) {
781 		ccw_device_destroy_console(cdev);
782 		return ERR_PTR(rc);
783 	}
784 
785 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
786 	do {
787 		__raw3270_reset_device(rp);
788 		while (!raw3270_state_final(rp)) {
789 			ccw_device_wait_idle(rp->cdev);
790 			barrier();
791 		}
792 	} while (rp->state != RAW3270_STATE_READY);
793 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
794 	return rp;
795 }
796 
797 void
raw3270_wait_cons_dev(struct raw3270 * rp)798 raw3270_wait_cons_dev(struct raw3270 *rp)
799 {
800 	unsigned long flags;
801 
802 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
803 	ccw_device_wait_idle(rp->cdev);
804 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
805 }
806 
807 #endif
808 
809 /*
810  * Create a 3270 device structure.
811  */
812 static struct raw3270 *
raw3270_create_device(struct ccw_device * cdev)813 raw3270_create_device(struct ccw_device *cdev)
814 {
815 	struct raw3270 *rp;
816 	char *ascebc;
817 	int rc;
818 
819 	rp = kzalloc(sizeof(struct raw3270), GFP_KERNEL | GFP_DMA);
820 	if (!rp)
821 		return ERR_PTR(-ENOMEM);
822 	ascebc = kmalloc(256, GFP_KERNEL);
823 	if (!ascebc) {
824 		kfree(rp);
825 		return ERR_PTR(-ENOMEM);
826 	}
827 	rc = raw3270_setup_device(cdev, rp, ascebc);
828 	if (rc) {
829 		kfree(rp->ascebc);
830 		kfree(rp);
831 		rp = ERR_PTR(rc);
832 	}
833 	/* Get reference to ccw_device structure. */
834 	get_device(&cdev->dev);
835 	return rp;
836 }
837 
838 /*
839  * Activate a view.
840  */
841 int
raw3270_activate_view(struct raw3270_view * view)842 raw3270_activate_view(struct raw3270_view *view)
843 {
844 	struct raw3270 *rp;
845 	struct raw3270_view *oldview, *nv;
846 	unsigned long flags;
847 	int rc;
848 
849 	rp = view->dev;
850 	if (!rp)
851 		return -ENODEV;
852 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
853 	if (rp->view == view)
854 		rc = 0;
855 	else if (!raw3270_state_ready(rp))
856 		rc = -EBUSY;
857 	else if (test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
858 		rc = -EACCES;
859 	else {
860 		oldview = NULL;
861 		if (rp->view && rp->view->fn->deactivate) {
862 			oldview = rp->view;
863 			oldview->fn->deactivate(oldview);
864 		}
865 		rp->view = view;
866 		rc = view->fn->activate(view);
867 		if (rc) {
868 			/* Didn't work. Try to reactivate the old view. */
869 			rp->view = oldview;
870 			if (!oldview || oldview->fn->activate(oldview) != 0) {
871 				/* Didn't work as well. Try any other view. */
872 				list_for_each_entry(nv, &rp->view_list, list)
873 					if (nv != view && nv != oldview) {
874 						rp->view = nv;
875 						if (nv->fn->activate(nv) == 0)
876 							break;
877 						rp->view = NULL;
878 					}
879 			}
880 		}
881 	}
882 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
883 	return rc;
884 }
885 
886 /*
887  * Deactivate current view.
888  */
889 void
raw3270_deactivate_view(struct raw3270_view * view)890 raw3270_deactivate_view(struct raw3270_view *view)
891 {
892 	unsigned long flags;
893 	struct raw3270 *rp;
894 
895 	rp = view->dev;
896 	if (!rp)
897 		return;
898 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
899 	if (rp->view == view) {
900 		view->fn->deactivate(view);
901 		rp->view = NULL;
902 		/* Move deactivated view to end of list. */
903 		list_del_init(&view->list);
904 		list_add_tail(&view->list, &rp->view_list);
905 		/* Try to activate another view. */
906 		if (raw3270_state_ready(rp) &&
907 		    !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
908 			list_for_each_entry(view, &rp->view_list, list) {
909 				rp->view = view;
910 				if (view->fn->activate(view) == 0)
911 					break;
912 				rp->view = NULL;
913 			}
914 		}
915 	}
916 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
917 }
918 
919 /*
920  * Add view to device with minor "minor".
921  */
922 int
raw3270_add_view(struct raw3270_view * view,struct raw3270_fn * fn,int minor,int subclass)923 raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor, int subclass)
924 {
925 	unsigned long flags;
926 	struct raw3270 *rp;
927 	int rc;
928 
929 	if (minor <= 0)
930 		return -ENODEV;
931 	mutex_lock(&raw3270_mutex);
932 	rc = -ENODEV;
933 	list_for_each_entry(rp, &raw3270_devices, list) {
934 		if (rp->minor != minor)
935 			continue;
936 		spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
937 		atomic_set(&view->ref_count, 2);
938 		view->dev = rp;
939 		view->fn = fn;
940 		view->model = rp->model;
941 		view->rows = rp->rows;
942 		view->cols = rp->cols;
943 		view->ascebc = rp->ascebc;
944 		spin_lock_init(&view->lock);
945 		lockdep_set_subclass(&view->lock, subclass);
946 		list_add(&view->list, &rp->view_list);
947 		rc = 0;
948 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
949 		break;
950 	}
951 	mutex_unlock(&raw3270_mutex);
952 	return rc;
953 }
954 
955 /*
956  * Find specific view of device with minor "minor".
957  */
958 struct raw3270_view *
raw3270_find_view(struct raw3270_fn * fn,int minor)959 raw3270_find_view(struct raw3270_fn *fn, int minor)
960 {
961 	struct raw3270 *rp;
962 	struct raw3270_view *view, *tmp;
963 	unsigned long flags;
964 
965 	mutex_lock(&raw3270_mutex);
966 	view = ERR_PTR(-ENODEV);
967 	list_for_each_entry(rp, &raw3270_devices, list) {
968 		if (rp->minor != minor)
969 			continue;
970 		spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
971 		list_for_each_entry(tmp, &rp->view_list, list) {
972 			if (tmp->fn == fn) {
973 				raw3270_get_view(tmp);
974 				view = tmp;
975 				break;
976 			}
977 		}
978 		spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
979 		break;
980 	}
981 	mutex_unlock(&raw3270_mutex);
982 	return view;
983 }
984 
985 /*
986  * Remove view from device and free view structure via call to view->fn->free.
987  */
988 void
raw3270_del_view(struct raw3270_view * view)989 raw3270_del_view(struct raw3270_view *view)
990 {
991 	unsigned long flags;
992 	struct raw3270 *rp;
993 	struct raw3270_view *nv;
994 
995 	rp = view->dev;
996 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
997 	if (rp->view == view) {
998 		view->fn->deactivate(view);
999 		rp->view = NULL;
1000 	}
1001 	list_del_init(&view->list);
1002 	if (!rp->view && raw3270_state_ready(rp) &&
1003 	    !test_bit(RAW3270_FLAGS_FROZEN, &rp->flags)) {
1004 		/* Try to activate another view. */
1005 		list_for_each_entry(nv, &rp->view_list, list) {
1006 			if (nv->fn->activate(nv) == 0) {
1007 				rp->view = nv;
1008 				break;
1009 			}
1010 		}
1011 	}
1012 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1013 	/* Wait for reference counter to drop to zero. */
1014 	atomic_dec(&view->ref_count);
1015 	wait_event(raw3270_wait_queue, atomic_read(&view->ref_count) == 0);
1016 	if (view->fn->free)
1017 		view->fn->free(view);
1018 }
1019 
1020 /*
1021  * Remove a 3270 device structure.
1022  */
1023 static void
raw3270_delete_device(struct raw3270 * rp)1024 raw3270_delete_device(struct raw3270 *rp)
1025 {
1026 	struct ccw_device *cdev;
1027 
1028 	/* Remove from device chain. */
1029 	mutex_lock(&raw3270_mutex);
1030 	list_del_init(&rp->list);
1031 	mutex_unlock(&raw3270_mutex);
1032 
1033 	/* Disconnect from ccw_device. */
1034 	cdev = rp->cdev;
1035 	rp->cdev = NULL;
1036 	dev_set_drvdata(&cdev->dev, NULL);
1037 	cdev->handler = NULL;
1038 
1039 	/* Put ccw_device structure. */
1040 	put_device(&cdev->dev);
1041 
1042 	/* Now free raw3270 structure. */
1043 	kfree(rp->ascebc);
1044 	kfree(rp);
1045 }
1046 
1047 static int
raw3270_probe(struct ccw_device * cdev)1048 raw3270_probe (struct ccw_device *cdev)
1049 {
1050 	return 0;
1051 }
1052 
1053 /*
1054  * Additional attributes for a 3270 device
1055  */
1056 static ssize_t
raw3270_model_show(struct device * dev,struct device_attribute * attr,char * buf)1057 raw3270_model_show(struct device *dev, struct device_attribute *attr, char *buf)
1058 {
1059 	return snprintf(buf, PAGE_SIZE, "%i\n",
1060 			((struct raw3270 *) dev_get_drvdata(dev))->model);
1061 }
1062 static DEVICE_ATTR(model, 0444, raw3270_model_show, NULL);
1063 
1064 static ssize_t
raw3270_rows_show(struct device * dev,struct device_attribute * attr,char * buf)1065 raw3270_rows_show(struct device *dev, struct device_attribute *attr, char *buf)
1066 {
1067 	return snprintf(buf, PAGE_SIZE, "%i\n",
1068 			((struct raw3270 *) dev_get_drvdata(dev))->rows);
1069 }
1070 static DEVICE_ATTR(rows, 0444, raw3270_rows_show, NULL);
1071 
1072 static ssize_t
raw3270_columns_show(struct device * dev,struct device_attribute * attr,char * buf)1073 raw3270_columns_show(struct device *dev, struct device_attribute *attr, char *buf)
1074 {
1075 	return snprintf(buf, PAGE_SIZE, "%i\n",
1076 			((struct raw3270 *) dev_get_drvdata(dev))->cols);
1077 }
1078 static DEVICE_ATTR(columns, 0444, raw3270_columns_show, NULL);
1079 
1080 static struct attribute * raw3270_attrs[] = {
1081 	&dev_attr_model.attr,
1082 	&dev_attr_rows.attr,
1083 	&dev_attr_columns.attr,
1084 	NULL,
1085 };
1086 
1087 static const struct attribute_group raw3270_attr_group = {
1088 	.attrs = raw3270_attrs,
1089 };
1090 
raw3270_create_attributes(struct raw3270 * rp)1091 static int raw3270_create_attributes(struct raw3270 *rp)
1092 {
1093 	return sysfs_create_group(&rp->cdev->dev.kobj, &raw3270_attr_group);
1094 }
1095 
1096 /*
1097  * Notifier for device addition/removal
1098  */
1099 static LIST_HEAD(raw3270_notifier);
1100 
raw3270_register_notifier(struct raw3270_notifier * notifier)1101 int raw3270_register_notifier(struct raw3270_notifier *notifier)
1102 {
1103 	struct raw3270 *rp;
1104 
1105 	mutex_lock(&raw3270_mutex);
1106 	list_add_tail(&notifier->list, &raw3270_notifier);
1107 	list_for_each_entry(rp, &raw3270_devices, list)
1108 		notifier->create(rp->minor);
1109 	mutex_unlock(&raw3270_mutex);
1110 	return 0;
1111 }
1112 
raw3270_unregister_notifier(struct raw3270_notifier * notifier)1113 void raw3270_unregister_notifier(struct raw3270_notifier *notifier)
1114 {
1115 	struct raw3270 *rp;
1116 
1117 	mutex_lock(&raw3270_mutex);
1118 	list_for_each_entry(rp, &raw3270_devices, list)
1119 		notifier->destroy(rp->minor);
1120 	list_del(&notifier->list);
1121 	mutex_unlock(&raw3270_mutex);
1122 }
1123 
1124 /*
1125  * Set 3270 device online.
1126  */
1127 static int
raw3270_set_online(struct ccw_device * cdev)1128 raw3270_set_online (struct ccw_device *cdev)
1129 {
1130 	struct raw3270_notifier *np;
1131 	struct raw3270 *rp;
1132 	int rc;
1133 
1134 	rp = raw3270_create_device(cdev);
1135 	if (IS_ERR(rp))
1136 		return PTR_ERR(rp);
1137 	rc = raw3270_create_attributes(rp);
1138 	if (rc)
1139 		goto failure;
1140 	raw3270_reset_device(rp);
1141 	mutex_lock(&raw3270_mutex);
1142 	list_for_each_entry(np, &raw3270_notifier, list)
1143 		np->create(rp->minor);
1144 	mutex_unlock(&raw3270_mutex);
1145 	return 0;
1146 
1147 failure:
1148 	raw3270_delete_device(rp);
1149 	return rc;
1150 }
1151 
1152 /*
1153  * Remove 3270 device structure.
1154  */
1155 static void
raw3270_remove(struct ccw_device * cdev)1156 raw3270_remove (struct ccw_device *cdev)
1157 {
1158 	unsigned long flags;
1159 	struct raw3270 *rp;
1160 	struct raw3270_view *v;
1161 	struct raw3270_notifier *np;
1162 
1163 	rp = dev_get_drvdata(&cdev->dev);
1164 	/*
1165 	 * _remove is the opposite of _probe; it's probe that
1166 	 * should set up rp.  raw3270_remove gets entered for
1167 	 * devices even if they haven't been varied online.
1168 	 * Thus, rp may validly be NULL here.
1169 	 */
1170 	if (rp == NULL)
1171 		return;
1172 
1173 	sysfs_remove_group(&cdev->dev.kobj, &raw3270_attr_group);
1174 
1175 	/* Deactivate current view and remove all views. */
1176 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1177 	if (rp->view) {
1178 		if (rp->view->fn->deactivate)
1179 			rp->view->fn->deactivate(rp->view);
1180 		rp->view = NULL;
1181 	}
1182 	while (!list_empty(&rp->view_list)) {
1183 		v = list_entry(rp->view_list.next, struct raw3270_view, list);
1184 		if (v->fn->release)
1185 			v->fn->release(v);
1186 		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1187 		raw3270_del_view(v);
1188 		spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1189 	}
1190 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1191 
1192 	mutex_lock(&raw3270_mutex);
1193 	list_for_each_entry(np, &raw3270_notifier, list)
1194 		np->destroy(rp->minor);
1195 	mutex_unlock(&raw3270_mutex);
1196 
1197 	/* Reset 3270 device. */
1198 	raw3270_reset_device(rp);
1199 	/* And finally remove it. */
1200 	raw3270_delete_device(rp);
1201 }
1202 
1203 /*
1204  * Set 3270 device offline.
1205  */
1206 static int
raw3270_set_offline(struct ccw_device * cdev)1207 raw3270_set_offline (struct ccw_device *cdev)
1208 {
1209 	struct raw3270 *rp;
1210 
1211 	rp = dev_get_drvdata(&cdev->dev);
1212 	if (test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags))
1213 		return -EBUSY;
1214 	raw3270_remove(cdev);
1215 	return 0;
1216 }
1217 
raw3270_pm_stop(struct ccw_device * cdev)1218 static int raw3270_pm_stop(struct ccw_device *cdev)
1219 {
1220 	struct raw3270 *rp;
1221 	struct raw3270_view *view;
1222 	unsigned long flags;
1223 
1224 	rp = dev_get_drvdata(&cdev->dev);
1225 	if (!rp)
1226 		return 0;
1227 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1228 	if (rp->view && rp->view->fn->deactivate)
1229 		rp->view->fn->deactivate(rp->view);
1230 	if (!test_bit(RAW3270_FLAGS_CONSOLE, &rp->flags)) {
1231 		/*
1232 		 * Release tty and fullscreen for all non-console
1233 		 * devices.
1234 		 */
1235 		list_for_each_entry(view, &rp->view_list, list) {
1236 			if (view->fn->release)
1237 				view->fn->release(view);
1238 		}
1239 	}
1240 	set_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1241 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1242 	return 0;
1243 }
1244 
raw3270_pm_start(struct ccw_device * cdev)1245 static int raw3270_pm_start(struct ccw_device *cdev)
1246 {
1247 	struct raw3270 *rp;
1248 	unsigned long flags;
1249 
1250 	rp = dev_get_drvdata(&cdev->dev);
1251 	if (!rp)
1252 		return 0;
1253 	spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
1254 	clear_bit(RAW3270_FLAGS_FROZEN, &rp->flags);
1255 	if (rp->view && rp->view->fn->activate)
1256 		rp->view->fn->activate(rp->view);
1257 	spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
1258 	return 0;
1259 }
1260 
raw3270_pm_unfreeze(struct raw3270_view * view)1261 void raw3270_pm_unfreeze(struct raw3270_view *view)
1262 {
1263 #ifdef CONFIG_TN3270_CONSOLE
1264 	struct raw3270 *rp;
1265 
1266 	rp = view->dev;
1267 	if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
1268 		ccw_device_force_console(rp->cdev);
1269 #endif
1270 }
1271 
1272 static struct ccw_device_id raw3270_id[] = {
1273 	{ CCW_DEVICE(0x3270, 0) },
1274 	{ CCW_DEVICE(0x3271, 0) },
1275 	{ CCW_DEVICE(0x3272, 0) },
1276 	{ CCW_DEVICE(0x3273, 0) },
1277 	{ CCW_DEVICE(0x3274, 0) },
1278 	{ CCW_DEVICE(0x3275, 0) },
1279 	{ CCW_DEVICE(0x3276, 0) },
1280 	{ CCW_DEVICE(0x3277, 0) },
1281 	{ CCW_DEVICE(0x3278, 0) },
1282 	{ CCW_DEVICE(0x3279, 0) },
1283 	{ CCW_DEVICE(0x3174, 0) },
1284 	{ /* end of list */ },
1285 };
1286 
1287 static struct ccw_driver raw3270_ccw_driver = {
1288 	.driver = {
1289 		.name	= "3270",
1290 		.owner	= THIS_MODULE,
1291 	},
1292 	.ids		= raw3270_id,
1293 	.probe		= &raw3270_probe,
1294 	.remove		= &raw3270_remove,
1295 	.set_online	= &raw3270_set_online,
1296 	.set_offline	= &raw3270_set_offline,
1297 	.freeze		= &raw3270_pm_stop,
1298 	.thaw		= &raw3270_pm_start,
1299 	.restore	= &raw3270_pm_start,
1300 	.int_class	= IRQIO_C70,
1301 };
1302 
1303 static int
raw3270_init(void)1304 raw3270_init(void)
1305 {
1306 	struct raw3270 *rp;
1307 	int rc;
1308 
1309 	if (raw3270_registered)
1310 		return 0;
1311 	raw3270_registered = 1;
1312 	rc = ccw_driver_register(&raw3270_ccw_driver);
1313 	if (rc == 0) {
1314 		/* Create attributes for early (= console) device. */
1315 		mutex_lock(&raw3270_mutex);
1316 		class3270 = class_create(THIS_MODULE, "3270");
1317 		list_for_each_entry(rp, &raw3270_devices, list) {
1318 			get_device(&rp->cdev->dev);
1319 			raw3270_create_attributes(rp);
1320 		}
1321 		mutex_unlock(&raw3270_mutex);
1322 	}
1323 	return rc;
1324 }
1325 
1326 static void
raw3270_exit(void)1327 raw3270_exit(void)
1328 {
1329 	ccw_driver_unregister(&raw3270_ccw_driver);
1330 	class_destroy(class3270);
1331 }
1332 
1333 MODULE_LICENSE("GPL");
1334 
1335 module_init(raw3270_init);
1336 module_exit(raw3270_exit);
1337 
1338 EXPORT_SYMBOL(class3270);
1339 EXPORT_SYMBOL(raw3270_request_alloc);
1340 EXPORT_SYMBOL(raw3270_request_free);
1341 EXPORT_SYMBOL(raw3270_request_reset);
1342 EXPORT_SYMBOL(raw3270_request_set_cmd);
1343 EXPORT_SYMBOL(raw3270_request_add_data);
1344 EXPORT_SYMBOL(raw3270_request_set_data);
1345 EXPORT_SYMBOL(raw3270_request_set_idal);
1346 EXPORT_SYMBOL(raw3270_buffer_address);
1347 EXPORT_SYMBOL(raw3270_add_view);
1348 EXPORT_SYMBOL(raw3270_del_view);
1349 EXPORT_SYMBOL(raw3270_find_view);
1350 EXPORT_SYMBOL(raw3270_activate_view);
1351 EXPORT_SYMBOL(raw3270_deactivate_view);
1352 EXPORT_SYMBOL(raw3270_start);
1353 EXPORT_SYMBOL(raw3270_start_locked);
1354 EXPORT_SYMBOL(raw3270_start_irq);
1355 EXPORT_SYMBOL(raw3270_reset);
1356 EXPORT_SYMBOL(raw3270_register_notifier);
1357 EXPORT_SYMBOL(raw3270_unregister_notifier);
1358 EXPORT_SYMBOL(raw3270_wait_queue);
1359