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