blob: fa62e69440578375fb8028721a6e2c8c0a52ad96 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/char/sclp.c
3 * core function to access sclp interface
4 *
5 * S390 version
6 * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
8 * Martin Schwidefsky <schwidefsky@de.ibm.com>
9 */
10
11#include <linux/module.h>
12#include <linux/err.h>
13#include <linux/spinlock.h>
14#include <linux/interrupt.h>
15#include <linux/timer.h>
16#include <linux/reboot.h>
17#include <linux/jiffies.h>
Peter Oberparleiterb3d00c32007-04-27 16:01:51 +020018#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <asm/types.h>
20#include <asm/s390_ext.h>
21
22#include "sclp.h"
23
24#define SCLP_HEADER "sclp: "
25
26/* Structure for register_early_external_interrupt. */
27static ext_int_info_t ext_int_info_hwc;
28
29/* Lock to protect internal data consistency. */
30static DEFINE_SPINLOCK(sclp_lock);
31
32/* Mask of events that we can receive from the sclp interface. */
33static sccb_mask_t sclp_receive_mask;
34
35/* Mask of events that we can send to the sclp interface. */
36static sccb_mask_t sclp_send_mask;
37
38/* List of registered event listeners and senders. */
39static struct list_head sclp_reg_list;
40
41/* List of queued requests. */
42static struct list_head sclp_req_queue;
43
44/* Data for read and and init requests. */
45static struct sclp_req sclp_read_req;
46static struct sclp_req sclp_init_req;
47static char sclp_read_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
48static char sclp_init_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
49
50/* Timer for request retries. */
51static struct timer_list sclp_request_timer;
52
53/* Internal state: is the driver initialized? */
54static volatile enum sclp_init_state_t {
55 sclp_init_state_uninitialized,
56 sclp_init_state_initializing,
57 sclp_init_state_initialized
58} sclp_init_state = sclp_init_state_uninitialized;
59
60/* Internal state: is a request active at the sclp? */
61static volatile enum sclp_running_state_t {
62 sclp_running_state_idle,
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +010063 sclp_running_state_running,
64 sclp_running_state_reset_pending
Linus Torvalds1da177e2005-04-16 15:20:36 -070065} sclp_running_state = sclp_running_state_idle;
66
67/* Internal state: is a read request pending? */
68static volatile enum sclp_reading_state_t {
69 sclp_reading_state_idle,
70 sclp_reading_state_reading
71} sclp_reading_state = sclp_reading_state_idle;
72
73/* Internal state: is the driver currently serving requests? */
74static volatile enum sclp_activation_state_t {
75 sclp_activation_state_active,
76 sclp_activation_state_deactivating,
77 sclp_activation_state_inactive,
78 sclp_activation_state_activating
79} sclp_activation_state = sclp_activation_state_active;
80
81/* Internal state: is an init mask request pending? */
82static volatile enum sclp_mask_state_t {
83 sclp_mask_state_idle,
84 sclp_mask_state_initializing
85} sclp_mask_state = sclp_mask_state_idle;
86
87/* Maximum retry counts */
88#define SCLP_INIT_RETRY 3
89#define SCLP_MASK_RETRY 3
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91/* Timeout intervals in seconds.*/
Peter Oberparleiter25fab9e2006-02-11 17:55:59 -080092#define SCLP_BUSY_INTERVAL 10
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +010093#define SCLP_RETRY_INTERVAL 30
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95static void sclp_process_queue(void);
96static int sclp_init_mask(int calculate);
97static int sclp_init(void);
98
99/* Perform service call. Return 0 on success, non-zero otherwise. */
Heiko Carstensab14de62007-02-05 21:18:37 +0100100int
101sclp_service_call(sclp_cmdw_t command, void *sccb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
103 int cc;
104
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200105 asm volatile(
106 " .insn rre,0xb2200000,%1,%2\n" /* servc %1,%2 */
107 " ipm %0\n"
108 " srl %0,28"
109 : "=&d" (cc) : "d" (command), "a" (__pa(sccb))
110 : "cc", "memory");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 if (cc == 3)
112 return -EIO;
113 if (cc == 2)
114 return -EBUSY;
115 return 0;
116}
117
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100118static inline void __sclp_make_read_req(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100120static void
121__sclp_queue_read_req(void)
122{
123 if (sclp_reading_state == sclp_reading_state_idle) {
124 sclp_reading_state = sclp_reading_state_reading;
125 __sclp_make_read_req();
126 /* Add request to head of queue */
127 list_add(&sclp_read_req.list, &sclp_req_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
131/* Set up request retry timer. Called while sclp_lock is locked. */
132static inline void
133__sclp_set_request_timer(unsigned long time, void (*function)(unsigned long),
134 unsigned long data)
135{
136 del_timer(&sclp_request_timer);
137 sclp_request_timer.function = function;
138 sclp_request_timer.data = data;
139 sclp_request_timer.expires = jiffies + time;
140 add_timer(&sclp_request_timer);
141}
142
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100143/* Request timeout handler. Restart the request queue. If DATA is non-zero,
144 * force restart of running request. */
145static void
146sclp_request_timeout(unsigned long data)
147{
148 unsigned long flags;
149
150 spin_lock_irqsave(&sclp_lock, flags);
151 if (data) {
152 if (sclp_running_state == sclp_running_state_running) {
153 /* Break running state and queue NOP read event request
154 * to get a defined interface state. */
155 __sclp_queue_read_req();
156 sclp_running_state = sclp_running_state_idle;
157 }
158 } else {
159 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
160 sclp_request_timeout, 0);
161 }
162 spin_unlock_irqrestore(&sclp_lock, flags);
163 sclp_process_queue();
164}
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166/* Try to start a request. Return zero if the request was successfully
167 * started or if it will be started at a later time. Return non-zero otherwise.
168 * Called while sclp_lock is locked. */
169static int
170__sclp_start_request(struct sclp_req *req)
171{
172 int rc;
173
174 if (sclp_running_state != sclp_running_state_idle)
175 return 0;
176 del_timer(&sclp_request_timer);
Heiko Carstensab14de62007-02-05 21:18:37 +0100177 rc = sclp_service_call(req->command, req->sccb);
Peter Oberparleiter25fab9e2006-02-11 17:55:59 -0800178 req->start_count++;
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 if (rc == 0) {
181 /* Sucessfully started request */
182 req->status = SCLP_REQ_RUNNING;
183 sclp_running_state = sclp_running_state_running;
184 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
185 sclp_request_timeout, 1);
186 return 0;
187 } else if (rc == -EBUSY) {
188 /* Try again later */
189 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
190 sclp_request_timeout, 0);
191 return 0;
192 }
193 /* Request failed */
194 req->status = SCLP_REQ_FAILED;
195 return rc;
196}
197
198/* Try to start queued requests. */
199static void
200sclp_process_queue(void)
201{
202 struct sclp_req *req;
203 int rc;
204 unsigned long flags;
205
206 spin_lock_irqsave(&sclp_lock, flags);
207 if (sclp_running_state != sclp_running_state_idle) {
208 spin_unlock_irqrestore(&sclp_lock, flags);
209 return;
210 }
211 del_timer(&sclp_request_timer);
212 while (!list_empty(&sclp_req_queue)) {
213 req = list_entry(sclp_req_queue.next, struct sclp_req, list);
214 rc = __sclp_start_request(req);
215 if (rc == 0)
216 break;
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100217 /* Request failed */
218 if (req->start_count > 1) {
219 /* Cannot abort already submitted request - could still
220 * be active at the SCLP */
221 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
222 sclp_request_timeout, 0);
223 break;
224 }
225 /* Post-processing for aborted request */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 list_del(&req->list);
227 if (req->callback) {
228 spin_unlock_irqrestore(&sclp_lock, flags);
229 req->callback(req, req->callback_data);
230 spin_lock_irqsave(&sclp_lock, flags);
231 }
232 }
233 spin_unlock_irqrestore(&sclp_lock, flags);
234}
235
236/* Queue a new request. Return zero on success, non-zero otherwise. */
237int
238sclp_add_request(struct sclp_req *req)
239{
240 unsigned long flags;
241 int rc;
242
243 spin_lock_irqsave(&sclp_lock, flags);
244 if ((sclp_init_state != sclp_init_state_initialized ||
245 sclp_activation_state != sclp_activation_state_active) &&
246 req != &sclp_init_req) {
247 spin_unlock_irqrestore(&sclp_lock, flags);
248 return -EIO;
249 }
250 req->status = SCLP_REQ_QUEUED;
251 req->start_count = 0;
252 list_add_tail(&req->list, &sclp_req_queue);
253 rc = 0;
254 /* Start if request is first in list */
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100255 if (sclp_running_state == sclp_running_state_idle &&
256 req->list.prev == &sclp_req_queue) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 rc = __sclp_start_request(req);
258 if (rc)
259 list_del(&req->list);
260 }
261 spin_unlock_irqrestore(&sclp_lock, flags);
262 return rc;
263}
264
265EXPORT_SYMBOL(sclp_add_request);
266
267/* Dispatch events found in request buffer to registered listeners. Return 0
268 * if all events were dispatched, non-zero otherwise. */
269static int
270sclp_dispatch_evbufs(struct sccb_header *sccb)
271{
272 unsigned long flags;
273 struct evbuf_header *evbuf;
274 struct list_head *l;
275 struct sclp_register *reg;
276 int offset;
277 int rc;
278
279 spin_lock_irqsave(&sclp_lock, flags);
280 rc = 0;
281 for (offset = sizeof(struct sccb_header); offset < sccb->length;
282 offset += evbuf->length) {
283 /* Search for event handler */
284 evbuf = (struct evbuf_header *) ((addr_t) sccb + offset);
285 reg = NULL;
286 list_for_each(l, &sclp_reg_list) {
287 reg = list_entry(l, struct sclp_register, list);
288 if (reg->receive_mask & (1 << (32 - evbuf->type)))
289 break;
290 else
291 reg = NULL;
292 }
293 if (reg && reg->receiver_fn) {
294 spin_unlock_irqrestore(&sclp_lock, flags);
295 reg->receiver_fn(evbuf);
296 spin_lock_irqsave(&sclp_lock, flags);
297 } else if (reg == NULL)
298 rc = -ENOSYS;
299 }
300 spin_unlock_irqrestore(&sclp_lock, flags);
301 return rc;
302}
303
304/* Read event data request callback. */
305static void
306sclp_read_cb(struct sclp_req *req, void *data)
307{
308 unsigned long flags;
309 struct sccb_header *sccb;
310
311 sccb = (struct sccb_header *) req->sccb;
312 if (req->status == SCLP_REQ_DONE && (sccb->response_code == 0x20 ||
313 sccb->response_code == 0x220))
314 sclp_dispatch_evbufs(sccb);
315 spin_lock_irqsave(&sclp_lock, flags);
316 sclp_reading_state = sclp_reading_state_idle;
317 spin_unlock_irqrestore(&sclp_lock, flags);
318}
319
320/* Prepare read event data request. Called while sclp_lock is locked. */
321static inline void
322__sclp_make_read_req(void)
323{
324 struct sccb_header *sccb;
325
326 sccb = (struct sccb_header *) sclp_read_sccb;
327 clear_page(sccb);
328 memset(&sclp_read_req, 0, sizeof(struct sclp_req));
Heiko Carstensab14de62007-02-05 21:18:37 +0100329 sclp_read_req.command = SCLP_CMDW_READ_EVENT_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 sclp_read_req.status = SCLP_REQ_QUEUED;
331 sclp_read_req.start_count = 0;
332 sclp_read_req.callback = sclp_read_cb;
333 sclp_read_req.sccb = sccb;
334 sccb->length = PAGE_SIZE;
335 sccb->function_code = 0;
336 sccb->control_mask[2] = 0x80;
337}
338
339/* Search request list for request with matching sccb. Return request if found,
340 * NULL otherwise. Called while sclp_lock is locked. */
341static inline struct sclp_req *
342__sclp_find_req(u32 sccb)
343{
344 struct list_head *l;
345 struct sclp_req *req;
346
347 list_for_each(l, &sclp_req_queue) {
348 req = list_entry(l, struct sclp_req, list);
349 if (sccb == (u32) (addr_t) req->sccb)
350 return req;
351 }
352 return NULL;
353}
354
355/* Handler for external interruption. Perform request post-processing.
356 * Prepare read event data request if necessary. Start processing of next
357 * request on queue. */
358static void
Heiko Carstens5a489b92006-10-06 16:38:35 +0200359sclp_interrupt_handler(__u16 code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 struct sclp_req *req;
362 u32 finished_sccb;
363 u32 evbuf_pending;
364
365 spin_lock(&sclp_lock);
366 finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
367 evbuf_pending = S390_lowcore.ext_params & 0x3;
368 if (finished_sccb) {
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100369 del_timer(&sclp_request_timer);
370 sclp_running_state = sclp_running_state_reset_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 req = __sclp_find_req(finished_sccb);
372 if (req) {
373 /* Request post-processing */
374 list_del(&req->list);
375 req->status = SCLP_REQ_DONE;
376 if (req->callback) {
377 spin_unlock(&sclp_lock);
378 req->callback(req, req->callback_data);
379 spin_lock(&sclp_lock);
380 }
381 }
382 sclp_running_state = sclp_running_state_idle;
383 }
384 if (evbuf_pending && sclp_receive_mask != 0 &&
Peter Oberparleiterdbd8ae62007-02-05 21:17:00 +0100385 sclp_activation_state == sclp_activation_state_active)
386 __sclp_queue_read_req();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 spin_unlock(&sclp_lock);
388 sclp_process_queue();
389}
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391/* Convert interval in jiffies to TOD ticks. */
392static inline u64
393sclp_tod_from_jiffies(unsigned long jiffies)
394{
395 return (u64) (jiffies / HZ) << 32;
396}
397
398/* Wait until a currently running request finished. Note: while this function
399 * is running, no timers are served on the calling CPU. */
400void
401sclp_sync_wait(void)
402{
Heiko Carstens1f194a42006-07-03 00:24:46 -0700403 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 unsigned long cr0, cr0_sync;
405 u64 timeout;
Heiko Carstensc59d7442007-02-05 21:17:16 +0100406 int irq_context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
408 /* We'll be disabling timer interrupts, so we need a custom timeout
409 * mechanism */
410 timeout = 0;
411 if (timer_pending(&sclp_request_timer)) {
412 /* Get timeout TOD value */
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200413 timeout = get_clock() +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 sclp_tod_from_jiffies(sclp_request_timer.expires -
415 jiffies);
416 }
Heiko Carstens1f194a42006-07-03 00:24:46 -0700417 local_irq_save(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 /* Prevent bottom half from executing once we force interrupts open */
Heiko Carstensc59d7442007-02-05 21:17:16 +0100419 irq_context = in_interrupt();
420 if (!irq_context)
421 local_bh_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 /* Enable service-signal interruption, disable timer interrupts */
Heiko Carstens1f194a42006-07-03 00:24:46 -0700423 trace_hardirqs_on();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 __ctl_store(cr0, 0, 0);
425 cr0_sync = cr0;
426 cr0_sync |= 0x00000200;
427 cr0_sync &= 0xFFFFF3AC;
428 __ctl_load(cr0_sync, 0, 0);
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200429 __raw_local_irq_stosm(0x01);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 /* Loop until driver state indicates finished request */
431 while (sclp_running_state != sclp_running_state_idle) {
432 /* Check for expired request timer */
433 if (timer_pending(&sclp_request_timer) &&
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200434 get_clock() > timeout &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 del_timer(&sclp_request_timer))
436 sclp_request_timer.function(sclp_request_timer.data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 cpu_relax();
438 }
Heiko Carstens1f194a42006-07-03 00:24:46 -0700439 local_irq_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 __ctl_load(cr0, 0, 0);
Heiko Carstensc59d7442007-02-05 21:17:16 +0100441 if (!irq_context)
442 _local_bh_enable();
Heiko Carstens1f194a42006-07-03 00:24:46 -0700443 local_irq_restore(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
446EXPORT_SYMBOL(sclp_sync_wait);
447
448/* Dispatch changes in send and receive mask to registered listeners. */
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100449static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450sclp_dispatch_state_change(void)
451{
452 struct list_head *l;
453 struct sclp_register *reg;
454 unsigned long flags;
455 sccb_mask_t receive_mask;
456 sccb_mask_t send_mask;
457
458 do {
459 spin_lock_irqsave(&sclp_lock, flags);
460 reg = NULL;
461 list_for_each(l, &sclp_reg_list) {
462 reg = list_entry(l, struct sclp_register, list);
463 receive_mask = reg->receive_mask & sclp_receive_mask;
464 send_mask = reg->send_mask & sclp_send_mask;
465 if (reg->sclp_receive_mask != receive_mask ||
466 reg->sclp_send_mask != send_mask) {
467 reg->sclp_receive_mask = receive_mask;
468 reg->sclp_send_mask = send_mask;
469 break;
470 } else
471 reg = NULL;
472 }
473 spin_unlock_irqrestore(&sclp_lock, flags);
474 if (reg && reg->state_change_fn)
475 reg->state_change_fn(reg);
476 } while (reg);
477}
478
479struct sclp_statechangebuf {
480 struct evbuf_header header;
481 u8 validity_sclp_active_facility_mask : 1;
482 u8 validity_sclp_receive_mask : 1;
483 u8 validity_sclp_send_mask : 1;
484 u8 validity_read_data_function_mask : 1;
485 u16 _zeros : 12;
486 u16 mask_length;
487 u64 sclp_active_facility_mask;
488 sccb_mask_t sclp_receive_mask;
489 sccb_mask_t sclp_send_mask;
490 u32 read_data_function_mask;
491} __attribute__((packed));
492
493
494/* State change event callback. Inform listeners of changes. */
495static void
496sclp_state_change_cb(struct evbuf_header *evbuf)
497{
498 unsigned long flags;
499 struct sclp_statechangebuf *scbuf;
500
501 scbuf = (struct sclp_statechangebuf *) evbuf;
502 if (scbuf->mask_length != sizeof(sccb_mask_t))
503 return;
504 spin_lock_irqsave(&sclp_lock, flags);
505 if (scbuf->validity_sclp_receive_mask)
506 sclp_receive_mask = scbuf->sclp_receive_mask;
507 if (scbuf->validity_sclp_send_mask)
508 sclp_send_mask = scbuf->sclp_send_mask;
509 spin_unlock_irqrestore(&sclp_lock, flags);
510 sclp_dispatch_state_change();
511}
512
513static struct sclp_register sclp_state_change_event = {
Stefan Haberland6d4740c2007-04-27 16:01:53 +0200514 .receive_mask = EVTYP_STATECHANGE_MASK,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 .receiver_fn = sclp_state_change_cb
516};
517
518/* Calculate receive and send mask of currently registered listeners.
519 * Called while sclp_lock is locked. */
520static inline void
521__sclp_get_mask(sccb_mask_t *receive_mask, sccb_mask_t *send_mask)
522{
523 struct list_head *l;
524 struct sclp_register *t;
525
526 *receive_mask = 0;
527 *send_mask = 0;
528 list_for_each(l, &sclp_reg_list) {
529 t = list_entry(l, struct sclp_register, list);
530 *receive_mask |= t->receive_mask;
531 *send_mask |= t->send_mask;
532 }
533}
534
535/* Register event listener. Return 0 on success, non-zero otherwise. */
536int
537sclp_register(struct sclp_register *reg)
538{
539 unsigned long flags;
540 sccb_mask_t receive_mask;
541 sccb_mask_t send_mask;
542 int rc;
543
544 rc = sclp_init();
545 if (rc)
546 return rc;
547 spin_lock_irqsave(&sclp_lock, flags);
548 /* Check event mask for collisions */
549 __sclp_get_mask(&receive_mask, &send_mask);
550 if (reg->receive_mask & receive_mask || reg->send_mask & send_mask) {
551 spin_unlock_irqrestore(&sclp_lock, flags);
552 return -EBUSY;
553 }
554 /* Trigger initial state change callback */
555 reg->sclp_receive_mask = 0;
556 reg->sclp_send_mask = 0;
557 list_add(&reg->list, &sclp_reg_list);
558 spin_unlock_irqrestore(&sclp_lock, flags);
559 rc = sclp_init_mask(1);
560 if (rc) {
561 spin_lock_irqsave(&sclp_lock, flags);
562 list_del(&reg->list);
563 spin_unlock_irqrestore(&sclp_lock, flags);
564 }
565 return rc;
566}
567
568EXPORT_SYMBOL(sclp_register);
569
570/* Unregister event listener. */
571void
572sclp_unregister(struct sclp_register *reg)
573{
574 unsigned long flags;
575
576 spin_lock_irqsave(&sclp_lock, flags);
577 list_del(&reg->list);
578 spin_unlock_irqrestore(&sclp_lock, flags);
579 sclp_init_mask(1);
580}
581
582EXPORT_SYMBOL(sclp_unregister);
583
584/* Remove event buffers which are marked processed. Return the number of
585 * remaining event buffers. */
586int
587sclp_remove_processed(struct sccb_header *sccb)
588{
589 struct evbuf_header *evbuf;
590 int unprocessed;
591 u16 remaining;
592
593 evbuf = (struct evbuf_header *) (sccb + 1);
594 unprocessed = 0;
595 remaining = sccb->length - sizeof(struct sccb_header);
596 while (remaining > 0) {
597 remaining -= evbuf->length;
598 if (evbuf->flags & 0x80) {
599 sccb->length -= evbuf->length;
600 memcpy(evbuf, (void *) ((addr_t) evbuf + evbuf->length),
601 remaining);
602 } else {
603 unprocessed++;
604 evbuf = (struct evbuf_header *)
605 ((addr_t) evbuf + evbuf->length);
606 }
607 }
608 return unprocessed;
609}
610
611EXPORT_SYMBOL(sclp_remove_processed);
612
613struct init_sccb {
614 struct sccb_header header;
615 u16 _reserved;
616 u16 mask_length;
617 sccb_mask_t receive_mask;
618 sccb_mask_t send_mask;
619 sccb_mask_t sclp_send_mask;
620 sccb_mask_t sclp_receive_mask;
621} __attribute__((packed));
622
623/* Prepare init mask request. Called while sclp_lock is locked. */
624static inline void
625__sclp_make_init_req(u32 receive_mask, u32 send_mask)
626{
627 struct init_sccb *sccb;
628
629 sccb = (struct init_sccb *) sclp_init_sccb;
630 clear_page(sccb);
631 memset(&sclp_init_req, 0, sizeof(struct sclp_req));
Heiko Carstensab14de62007-02-05 21:18:37 +0100632 sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 sclp_init_req.status = SCLP_REQ_FILLED;
634 sclp_init_req.start_count = 0;
635 sclp_init_req.callback = NULL;
636 sclp_init_req.callback_data = NULL;
637 sclp_init_req.sccb = sccb;
638 sccb->header.length = sizeof(struct init_sccb);
639 sccb->mask_length = sizeof(sccb_mask_t);
640 sccb->receive_mask = receive_mask;
641 sccb->send_mask = send_mask;
642 sccb->sclp_receive_mask = 0;
643 sccb->sclp_send_mask = 0;
644}
645
646/* Start init mask request. If calculate is non-zero, calculate the mask as
647 * requested by registered listeners. Use zero mask otherwise. Return 0 on
648 * success, non-zero otherwise. */
649static int
650sclp_init_mask(int calculate)
651{
652 unsigned long flags;
653 struct init_sccb *sccb = (struct init_sccb *) sclp_init_sccb;
654 sccb_mask_t receive_mask;
655 sccb_mask_t send_mask;
656 int retry;
657 int rc;
658 unsigned long wait;
659
660 spin_lock_irqsave(&sclp_lock, flags);
661 /* Check if interface is in appropriate state */
662 if (sclp_mask_state != sclp_mask_state_idle) {
663 spin_unlock_irqrestore(&sclp_lock, flags);
664 return -EBUSY;
665 }
666 if (sclp_activation_state == sclp_activation_state_inactive) {
667 spin_unlock_irqrestore(&sclp_lock, flags);
668 return -EINVAL;
669 }
670 sclp_mask_state = sclp_mask_state_initializing;
671 /* Determine mask */
672 if (calculate)
673 __sclp_get_mask(&receive_mask, &send_mask);
674 else {
675 receive_mask = 0;
676 send_mask = 0;
677 }
678 rc = -EIO;
679 for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
680 /* Prepare request */
681 __sclp_make_init_req(receive_mask, send_mask);
682 spin_unlock_irqrestore(&sclp_lock, flags);
683 if (sclp_add_request(&sclp_init_req)) {
684 /* Try again later */
685 wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
686 while (time_before(jiffies, wait))
687 sclp_sync_wait();
688 spin_lock_irqsave(&sclp_lock, flags);
689 continue;
690 }
691 while (sclp_init_req.status != SCLP_REQ_DONE &&
692 sclp_init_req.status != SCLP_REQ_FAILED)
693 sclp_sync_wait();
694 spin_lock_irqsave(&sclp_lock, flags);
695 if (sclp_init_req.status == SCLP_REQ_DONE &&
696 sccb->header.response_code == 0x20) {
697 /* Successful request */
698 if (calculate) {
699 sclp_receive_mask = sccb->sclp_receive_mask;
700 sclp_send_mask = sccb->sclp_send_mask;
701 } else {
702 sclp_receive_mask = 0;
703 sclp_send_mask = 0;
704 }
705 spin_unlock_irqrestore(&sclp_lock, flags);
706 sclp_dispatch_state_change();
707 spin_lock_irqsave(&sclp_lock, flags);
708 rc = 0;
709 break;
710 }
711 }
712 sclp_mask_state = sclp_mask_state_idle;
713 spin_unlock_irqrestore(&sclp_lock, flags);
714 return rc;
715}
716
717/* Deactivate SCLP interface. On success, new requests will be rejected,
718 * events will no longer be dispatched. Return 0 on success, non-zero
719 * otherwise. */
720int
721sclp_deactivate(void)
722{
723 unsigned long flags;
724 int rc;
725
726 spin_lock_irqsave(&sclp_lock, flags);
727 /* Deactivate can only be called when active */
728 if (sclp_activation_state != sclp_activation_state_active) {
729 spin_unlock_irqrestore(&sclp_lock, flags);
730 return -EINVAL;
731 }
732 sclp_activation_state = sclp_activation_state_deactivating;
733 spin_unlock_irqrestore(&sclp_lock, flags);
734 rc = sclp_init_mask(0);
735 spin_lock_irqsave(&sclp_lock, flags);
736 if (rc == 0)
737 sclp_activation_state = sclp_activation_state_inactive;
738 else
739 sclp_activation_state = sclp_activation_state_active;
740 spin_unlock_irqrestore(&sclp_lock, flags);
741 return rc;
742}
743
744EXPORT_SYMBOL(sclp_deactivate);
745
746/* Reactivate SCLP interface after sclp_deactivate. On success, new
747 * requests will be accepted, events will be dispatched again. Return 0 on
748 * success, non-zero otherwise. */
749int
750sclp_reactivate(void)
751{
752 unsigned long flags;
753 int rc;
754
755 spin_lock_irqsave(&sclp_lock, flags);
756 /* Reactivate can only be called when inactive */
757 if (sclp_activation_state != sclp_activation_state_inactive) {
758 spin_unlock_irqrestore(&sclp_lock, flags);
759 return -EINVAL;
760 }
761 sclp_activation_state = sclp_activation_state_activating;
762 spin_unlock_irqrestore(&sclp_lock, flags);
763 rc = sclp_init_mask(1);
764 spin_lock_irqsave(&sclp_lock, flags);
765 if (rc == 0)
766 sclp_activation_state = sclp_activation_state_active;
767 else
768 sclp_activation_state = sclp_activation_state_inactive;
769 spin_unlock_irqrestore(&sclp_lock, flags);
770 return rc;
771}
772
773EXPORT_SYMBOL(sclp_reactivate);
774
775/* Handler for external interruption used during initialization. Modify
776 * request state to done. */
777static void
Heiko Carstens5a489b92006-10-06 16:38:35 +0200778sclp_check_handler(__u16 code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779{
780 u32 finished_sccb;
781
782 finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
783 /* Is this the interrupt we are waiting for? */
784 if (finished_sccb == 0)
785 return;
786 if (finished_sccb != (u32) (addr_t) sclp_init_sccb) {
787 printk(KERN_WARNING SCLP_HEADER "unsolicited interrupt "
788 "for buffer at 0x%x\n", finished_sccb);
789 return;
790 }
791 spin_lock(&sclp_lock);
792 if (sclp_running_state == sclp_running_state_running) {
793 sclp_init_req.status = SCLP_REQ_DONE;
794 sclp_running_state = sclp_running_state_idle;
795 }
796 spin_unlock(&sclp_lock);
797}
798
799/* Initial init mask request timed out. Modify request state to failed. */
800static void
801sclp_check_timeout(unsigned long data)
802{
803 unsigned long flags;
804
805 spin_lock_irqsave(&sclp_lock, flags);
806 if (sclp_running_state == sclp_running_state_running) {
807 sclp_init_req.status = SCLP_REQ_FAILED;
808 sclp_running_state = sclp_running_state_idle;
809 }
810 spin_unlock_irqrestore(&sclp_lock, flags);
811}
812
813/* Perform a check of the SCLP interface. Return zero if the interface is
814 * available and there are no pending requests from a previous instance.
815 * Return non-zero otherwise. */
816static int
817sclp_check_interface(void)
818{
819 struct init_sccb *sccb;
820 unsigned long flags;
821 int retry;
822 int rc;
823
824 spin_lock_irqsave(&sclp_lock, flags);
825 /* Prepare init mask command */
826 rc = register_early_external_interrupt(0x2401, sclp_check_handler,
827 &ext_int_info_hwc);
828 if (rc) {
829 spin_unlock_irqrestore(&sclp_lock, flags);
830 return rc;
831 }
832 for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
833 __sclp_make_init_req(0, 0);
834 sccb = (struct init_sccb *) sclp_init_req.sccb;
Heiko Carstensab14de62007-02-05 21:18:37 +0100835 rc = sclp_service_call(sclp_init_req.command, sccb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 if (rc == -EIO)
837 break;
838 sclp_init_req.status = SCLP_REQ_RUNNING;
839 sclp_running_state = sclp_running_state_running;
840 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
841 sclp_check_timeout, 0);
842 spin_unlock_irqrestore(&sclp_lock, flags);
843 /* Enable service-signal interruption - needs to happen
844 * with IRQs enabled. */
845 ctl_set_bit(0, 9);
846 /* Wait for signal from interrupt or timeout */
847 sclp_sync_wait();
848 /* Disable service-signal interruption - needs to happen
849 * with IRQs enabled. */
850 ctl_clear_bit(0,9);
851 spin_lock_irqsave(&sclp_lock, flags);
852 del_timer(&sclp_request_timer);
853 if (sclp_init_req.status == SCLP_REQ_DONE &&
854 sccb->header.response_code == 0x20) {
855 rc = 0;
856 break;
857 } else
858 rc = -EBUSY;
859 }
860 unregister_early_external_interrupt(0x2401, sclp_check_handler,
861 &ext_int_info_hwc);
862 spin_unlock_irqrestore(&sclp_lock, flags);
863 return rc;
864}
865
866/* Reboot event handler. Reset send and receive mask to prevent pending SCLP
867 * events from interfering with rebooted system. */
868static int
869sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
870{
871 sclp_deactivate();
872 return NOTIFY_DONE;
873}
874
875static struct notifier_block sclp_reboot_notifier = {
876 .notifier_call = sclp_reboot_event
877};
878
879/* Initialize SCLP driver. Return zero if driver is operational, non-zero
880 * otherwise. */
881static int
882sclp_init(void)
883{
884 unsigned long flags;
885 int rc;
886
887 if (!MACHINE_HAS_SCLP)
888 return -ENODEV;
889 spin_lock_irqsave(&sclp_lock, flags);
890 /* Check for previous or running initialization */
891 if (sclp_init_state != sclp_init_state_uninitialized) {
892 spin_unlock_irqrestore(&sclp_lock, flags);
893 return 0;
894 }
895 sclp_init_state = sclp_init_state_initializing;
896 /* Set up variables */
897 INIT_LIST_HEAD(&sclp_req_queue);
898 INIT_LIST_HEAD(&sclp_reg_list);
899 list_add(&sclp_state_change_event.list, &sclp_reg_list);
900 init_timer(&sclp_request_timer);
901 /* Check interface */
902 spin_unlock_irqrestore(&sclp_lock, flags);
903 rc = sclp_check_interface();
904 spin_lock_irqsave(&sclp_lock, flags);
905 if (rc) {
906 sclp_init_state = sclp_init_state_uninitialized;
907 spin_unlock_irqrestore(&sclp_lock, flags);
908 return rc;
909 }
910 /* Register reboot handler */
911 rc = register_reboot_notifier(&sclp_reboot_notifier);
912 if (rc) {
913 sclp_init_state = sclp_init_state_uninitialized;
914 spin_unlock_irqrestore(&sclp_lock, flags);
915 return rc;
916 }
917 /* Register interrupt handler */
918 rc = register_early_external_interrupt(0x2401, sclp_interrupt_handler,
919 &ext_int_info_hwc);
920 if (rc) {
921 unregister_reboot_notifier(&sclp_reboot_notifier);
922 sclp_init_state = sclp_init_state_uninitialized;
923 spin_unlock_irqrestore(&sclp_lock, flags);
924 return rc;
925 }
926 sclp_init_state = sclp_init_state_initialized;
927 spin_unlock_irqrestore(&sclp_lock, flags);
928 /* Enable service-signal external interruption - needs to happen with
929 * IRQs enabled. */
930 ctl_set_bit(0, 9);
931 sclp_init_mask(1);
932 return 0;
933}
Peter Oberparleiterb3d00c32007-04-27 16:01:51 +0200934
935static __init int sclp_initcall(void)
936{
937 return sclp_init();
938}
939
940arch_initcall(sclp_initcall);