2 * drivers/s390/char/sclp.c
3 * core function to access sclp interface
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>
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>
18 #include <linux/init.h>
19 #include <asm/types.h>
20 #include <asm/s390_ext.h>
24 #define SCLP_HEADER "sclp: "
26 /* Structure for register_early_external_interrupt. */
27 static ext_int_info_t ext_int_info_hwc
;
29 /* Lock to protect internal data consistency. */
30 static DEFINE_SPINLOCK(sclp_lock
);
32 /* Mask of events that we can send to the sclp interface. */
33 static sccb_mask_t sclp_receive_mask
;
35 /* Mask of events that we can receive from the sclp interface. */
36 static sccb_mask_t sclp_send_mask
;
38 /* List of registered event listeners and senders. */
39 static struct list_head sclp_reg_list
;
41 /* List of queued requests. */
42 static struct list_head sclp_req_queue
;
44 /* Data for read and and init requests. */
45 static struct sclp_req sclp_read_req
;
46 static struct sclp_req sclp_init_req
;
47 static char sclp_read_sccb
[PAGE_SIZE
] __attribute__((__aligned__(PAGE_SIZE
)));
48 static char sclp_init_sccb
[PAGE_SIZE
] __attribute__((__aligned__(PAGE_SIZE
)));
50 /* Timer for request retries. */
51 static struct timer_list sclp_request_timer
;
53 /* Internal state: is the driver initialized? */
54 static 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
;
60 /* Internal state: is a request active at the sclp? */
61 static volatile enum sclp_running_state_t
{
62 sclp_running_state_idle
,
63 sclp_running_state_running
,
64 sclp_running_state_reset_pending
65 } sclp_running_state
= sclp_running_state_idle
;
67 /* Internal state: is a read request pending? */
68 static volatile enum sclp_reading_state_t
{
69 sclp_reading_state_idle
,
70 sclp_reading_state_reading
71 } sclp_reading_state
= sclp_reading_state_idle
;
73 /* Internal state: is the driver currently serving requests? */
74 static 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
;
81 /* Internal state: is an init mask request pending? */
82 static volatile enum sclp_mask_state_t
{
84 sclp_mask_state_initializing
85 } sclp_mask_state
= sclp_mask_state_idle
;
87 /* Maximum retry counts */
88 #define SCLP_INIT_RETRY 3
89 #define SCLP_MASK_RETRY 3
91 /* Timeout intervals in seconds.*/
92 #define SCLP_BUSY_INTERVAL 10
93 #define SCLP_RETRY_INTERVAL 30
95 static void sclp_process_queue(void);
96 static void __sclp_make_read_req(void);
97 static int sclp_init_mask(int calculate
);
98 static int sclp_init(void);
100 /* Perform service call. Return 0 on success, non-zero otherwise. */
102 sclp_service_call(sclp_cmdw_t command
, void *sccb
)
107 " .insn rre,0xb2200000,%1,%2\n" /* servc %1,%2 */
110 : "=&d" (cc
) : "d" (command
), "a" (__pa(sccb
))
121 __sclp_queue_read_req(void)
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
);
131 /* Set up request retry timer. Called while sclp_lock is locked. */
133 __sclp_set_request_timer(unsigned long time
, void (*function
)(unsigned long),
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
);
143 /* Request timeout handler. Restart the request queue. If DATA is non-zero,
144 * force restart of running request. */
146 sclp_request_timeout(unsigned long data
)
150 spin_lock_irqsave(&sclp_lock
, flags
);
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
;
159 __sclp_set_request_timer(SCLP_BUSY_INTERVAL
* HZ
,
160 sclp_request_timeout
, 0);
162 spin_unlock_irqrestore(&sclp_lock
, flags
);
163 sclp_process_queue();
166 /* 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. */
170 __sclp_start_request(struct sclp_req
*req
)
174 if (sclp_running_state
!= sclp_running_state_idle
)
176 del_timer(&sclp_request_timer
);
177 rc
= sclp_service_call(req
->command
, req
->sccb
);
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);
187 } else if (rc
== -EBUSY
) {
188 /* Try again later */
189 __sclp_set_request_timer(SCLP_BUSY_INTERVAL
* HZ
,
190 sclp_request_timeout
, 0);
194 req
->status
= SCLP_REQ_FAILED
;
198 /* Try to start queued requests. */
200 sclp_process_queue(void)
202 struct sclp_req
*req
;
206 spin_lock_irqsave(&sclp_lock
, flags
);
207 if (sclp_running_state
!= sclp_running_state_idle
) {
208 spin_unlock_irqrestore(&sclp_lock
, flags
);
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
);
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);
225 /* Post-processing for aborted request */
226 list_del(&req
->list
);
228 spin_unlock_irqrestore(&sclp_lock
, flags
);
229 req
->callback(req
, req
->callback_data
);
230 spin_lock_irqsave(&sclp_lock
, flags
);
233 spin_unlock_irqrestore(&sclp_lock
, flags
);
236 /* Queue a new request. Return zero on success, non-zero otherwise. */
238 sclp_add_request(struct sclp_req
*req
)
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
);
250 req
->status
= SCLP_REQ_QUEUED
;
251 req
->start_count
= 0;
252 list_add_tail(&req
->list
, &sclp_req_queue
);
254 /* Start if request is first in list */
255 if (sclp_running_state
== sclp_running_state_idle
&&
256 req
->list
.prev
== &sclp_req_queue
) {
257 rc
= __sclp_start_request(req
);
259 list_del(&req
->list
);
261 spin_unlock_irqrestore(&sclp_lock
, flags
);
265 EXPORT_SYMBOL(sclp_add_request
);
267 /* Dispatch events found in request buffer to registered listeners. Return 0
268 * if all events were dispatched, non-zero otherwise. */
270 sclp_dispatch_evbufs(struct sccb_header
*sccb
)
273 struct evbuf_header
*evbuf
;
275 struct sclp_register
*reg
;
279 spin_lock_irqsave(&sclp_lock
, flags
);
281 for (offset
= sizeof(struct sccb_header
); offset
< sccb
->length
;
282 offset
+= evbuf
->length
) {
283 evbuf
= (struct evbuf_header
*) ((addr_t
) sccb
+ offset
);
284 /* Check for malformed hardware response */
285 if (evbuf
->length
== 0)
287 /* Search for event handler */
289 list_for_each(l
, &sclp_reg_list
) {
290 reg
= list_entry(l
, struct sclp_register
, list
);
291 if (reg
->receive_mask
& (1 << (32 - evbuf
->type
)))
296 if (reg
&& reg
->receiver_fn
) {
297 spin_unlock_irqrestore(&sclp_lock
, flags
);
298 reg
->receiver_fn(evbuf
);
299 spin_lock_irqsave(&sclp_lock
, flags
);
300 } else if (reg
== NULL
)
303 spin_unlock_irqrestore(&sclp_lock
, flags
);
307 /* Read event data request callback. */
309 sclp_read_cb(struct sclp_req
*req
, void *data
)
312 struct sccb_header
*sccb
;
314 sccb
= (struct sccb_header
*) req
->sccb
;
315 if (req
->status
== SCLP_REQ_DONE
&& (sccb
->response_code
== 0x20 ||
316 sccb
->response_code
== 0x220))
317 sclp_dispatch_evbufs(sccb
);
318 spin_lock_irqsave(&sclp_lock
, flags
);
319 sclp_reading_state
= sclp_reading_state_idle
;
320 spin_unlock_irqrestore(&sclp_lock
, flags
);
323 /* Prepare read event data request. Called while sclp_lock is locked. */
324 static void __sclp_make_read_req(void)
326 struct sccb_header
*sccb
;
328 sccb
= (struct sccb_header
*) sclp_read_sccb
;
330 memset(&sclp_read_req
, 0, sizeof(struct sclp_req
));
331 sclp_read_req
.command
= SCLP_CMDW_READ_EVENT_DATA
;
332 sclp_read_req
.status
= SCLP_REQ_QUEUED
;
333 sclp_read_req
.start_count
= 0;
334 sclp_read_req
.callback
= sclp_read_cb
;
335 sclp_read_req
.sccb
= sccb
;
336 sccb
->length
= PAGE_SIZE
;
337 sccb
->function_code
= 0;
338 sccb
->control_mask
[2] = 0x80;
341 /* Search request list for request with matching sccb. Return request if found,
342 * NULL otherwise. Called while sclp_lock is locked. */
343 static inline struct sclp_req
*
344 __sclp_find_req(u32 sccb
)
347 struct sclp_req
*req
;
349 list_for_each(l
, &sclp_req_queue
) {
350 req
= list_entry(l
, struct sclp_req
, list
);
351 if (sccb
== (u32
) (addr_t
) req
->sccb
)
357 /* Handler for external interruption. Perform request post-processing.
358 * Prepare read event data request if necessary. Start processing of next
359 * request on queue. */
361 sclp_interrupt_handler(__u16 code
)
363 struct sclp_req
*req
;
367 spin_lock(&sclp_lock
);
368 finished_sccb
= S390_lowcore
.ext_params
& 0xfffffff8;
369 evbuf_pending
= S390_lowcore
.ext_params
& 0x3;
371 del_timer(&sclp_request_timer
);
372 sclp_running_state
= sclp_running_state_reset_pending
;
373 req
= __sclp_find_req(finished_sccb
);
375 /* Request post-processing */
376 list_del(&req
->list
);
377 req
->status
= SCLP_REQ_DONE
;
379 spin_unlock(&sclp_lock
);
380 req
->callback(req
, req
->callback_data
);
381 spin_lock(&sclp_lock
);
384 sclp_running_state
= sclp_running_state_idle
;
387 sclp_activation_state
== sclp_activation_state_active
)
388 __sclp_queue_read_req();
389 spin_unlock(&sclp_lock
);
390 sclp_process_queue();
393 /* Convert interval in jiffies to TOD ticks. */
395 sclp_tod_from_jiffies(unsigned long jiffies
)
397 return (u64
) (jiffies
/ HZ
) << 32;
400 /* Wait until a currently running request finished. Note: while this function
401 * is running, no timers are served on the calling CPU. */
405 unsigned long long old_tick
;
407 unsigned long cr0
, cr0_sync
;
411 /* We'll be disabling timer interrupts, so we need a custom timeout
414 if (timer_pending(&sclp_request_timer
)) {
415 /* Get timeout TOD value */
416 timeout
= get_clock() +
417 sclp_tod_from_jiffies(sclp_request_timer
.expires
-
420 local_irq_save(flags
);
421 /* Prevent bottom half from executing once we force interrupts open */
422 irq_context
= in_interrupt();
425 /* Enable service-signal interruption, disable timer interrupts */
426 old_tick
= local_tick_disable();
428 __ctl_store(cr0
, 0, 0);
430 cr0_sync
&= 0xffff00a0;
431 cr0_sync
|= 0x00000200;
432 __ctl_load(cr0_sync
, 0, 0);
433 __raw_local_irq_stosm(0x01);
434 /* Loop until driver state indicates finished request */
435 while (sclp_running_state
!= sclp_running_state_idle
) {
436 /* Check for expired request timer */
437 if (timer_pending(&sclp_request_timer
) &&
438 get_clock() > timeout
&&
439 del_timer(&sclp_request_timer
))
440 sclp_request_timer
.function(sclp_request_timer
.data
);
444 __ctl_load(cr0
, 0, 0);
447 local_tick_enable(old_tick
);
448 local_irq_restore(flags
);
450 EXPORT_SYMBOL(sclp_sync_wait
);
452 /* Dispatch changes in send and receive mask to registered listeners. */
454 sclp_dispatch_state_change(void)
457 struct sclp_register
*reg
;
459 sccb_mask_t receive_mask
;
460 sccb_mask_t send_mask
;
463 spin_lock_irqsave(&sclp_lock
, flags
);
465 list_for_each(l
, &sclp_reg_list
) {
466 reg
= list_entry(l
, struct sclp_register
, list
);
467 receive_mask
= reg
->send_mask
& sclp_receive_mask
;
468 send_mask
= reg
->receive_mask
& sclp_send_mask
;
469 if (reg
->sclp_receive_mask
!= receive_mask
||
470 reg
->sclp_send_mask
!= send_mask
) {
471 reg
->sclp_receive_mask
= receive_mask
;
472 reg
->sclp_send_mask
= send_mask
;
477 spin_unlock_irqrestore(&sclp_lock
, flags
);
478 if (reg
&& reg
->state_change_fn
)
479 reg
->state_change_fn(reg
);
483 struct sclp_statechangebuf
{
484 struct evbuf_header header
;
485 u8 validity_sclp_active_facility_mask
: 1;
486 u8 validity_sclp_receive_mask
: 1;
487 u8 validity_sclp_send_mask
: 1;
488 u8 validity_read_data_function_mask
: 1;
491 u64 sclp_active_facility_mask
;
492 sccb_mask_t sclp_receive_mask
;
493 sccb_mask_t sclp_send_mask
;
494 u32 read_data_function_mask
;
495 } __attribute__((packed
));
498 /* State change event callback. Inform listeners of changes. */
500 sclp_state_change_cb(struct evbuf_header
*evbuf
)
503 struct sclp_statechangebuf
*scbuf
;
505 scbuf
= (struct sclp_statechangebuf
*) evbuf
;
506 if (scbuf
->mask_length
!= sizeof(sccb_mask_t
))
508 spin_lock_irqsave(&sclp_lock
, flags
);
509 if (scbuf
->validity_sclp_receive_mask
)
510 sclp_receive_mask
= scbuf
->sclp_receive_mask
;
511 if (scbuf
->validity_sclp_send_mask
)
512 sclp_send_mask
= scbuf
->sclp_send_mask
;
513 spin_unlock_irqrestore(&sclp_lock
, flags
);
514 if (scbuf
->validity_sclp_active_facility_mask
)
515 sclp_facilities
= scbuf
->sclp_active_facility_mask
;
516 sclp_dispatch_state_change();
519 static struct sclp_register sclp_state_change_event
= {
520 .receive_mask
= EVTYP_STATECHANGE_MASK
,
521 .receiver_fn
= sclp_state_change_cb
524 /* Calculate receive and send mask of currently registered listeners.
525 * Called while sclp_lock is locked. */
527 __sclp_get_mask(sccb_mask_t
*receive_mask
, sccb_mask_t
*send_mask
)
530 struct sclp_register
*t
;
534 list_for_each(l
, &sclp_reg_list
) {
535 t
= list_entry(l
, struct sclp_register
, list
);
536 *receive_mask
|= t
->receive_mask
;
537 *send_mask
|= t
->send_mask
;
541 /* Register event listener. Return 0 on success, non-zero otherwise. */
543 sclp_register(struct sclp_register
*reg
)
546 sccb_mask_t receive_mask
;
547 sccb_mask_t send_mask
;
553 spin_lock_irqsave(&sclp_lock
, flags
);
554 /* Check event mask for collisions */
555 __sclp_get_mask(&receive_mask
, &send_mask
);
556 if (reg
->receive_mask
& receive_mask
|| reg
->send_mask
& send_mask
) {
557 spin_unlock_irqrestore(&sclp_lock
, flags
);
560 /* Trigger initial state change callback */
561 reg
->sclp_receive_mask
= 0;
562 reg
->sclp_send_mask
= 0;
563 list_add(®
->list
, &sclp_reg_list
);
564 spin_unlock_irqrestore(&sclp_lock
, flags
);
565 rc
= sclp_init_mask(1);
567 spin_lock_irqsave(&sclp_lock
, flags
);
568 list_del(®
->list
);
569 spin_unlock_irqrestore(&sclp_lock
, flags
);
574 EXPORT_SYMBOL(sclp_register
);
576 /* Unregister event listener. */
578 sclp_unregister(struct sclp_register
*reg
)
582 spin_lock_irqsave(&sclp_lock
, flags
);
583 list_del(®
->list
);
584 spin_unlock_irqrestore(&sclp_lock
, flags
);
588 EXPORT_SYMBOL(sclp_unregister
);
590 /* Remove event buffers which are marked processed. Return the number of
591 * remaining event buffers. */
593 sclp_remove_processed(struct sccb_header
*sccb
)
595 struct evbuf_header
*evbuf
;
599 evbuf
= (struct evbuf_header
*) (sccb
+ 1);
601 remaining
= sccb
->length
- sizeof(struct sccb_header
);
602 while (remaining
> 0) {
603 remaining
-= evbuf
->length
;
604 if (evbuf
->flags
& 0x80) {
605 sccb
->length
-= evbuf
->length
;
606 memcpy(evbuf
, (void *) ((addr_t
) evbuf
+ evbuf
->length
),
610 evbuf
= (struct evbuf_header
*)
611 ((addr_t
) evbuf
+ evbuf
->length
);
617 EXPORT_SYMBOL(sclp_remove_processed
);
620 struct sccb_header header
;
623 sccb_mask_t receive_mask
;
624 sccb_mask_t send_mask
;
625 sccb_mask_t sclp_receive_mask
;
626 sccb_mask_t sclp_send_mask
;
627 } __attribute__((packed
));
629 /* Prepare init mask request. Called while sclp_lock is locked. */
631 __sclp_make_init_req(u32 receive_mask
, u32 send_mask
)
633 struct init_sccb
*sccb
;
635 sccb
= (struct init_sccb
*) sclp_init_sccb
;
637 memset(&sclp_init_req
, 0, sizeof(struct sclp_req
));
638 sclp_init_req
.command
= SCLP_CMDW_WRITE_EVENT_MASK
;
639 sclp_init_req
.status
= SCLP_REQ_FILLED
;
640 sclp_init_req
.start_count
= 0;
641 sclp_init_req
.callback
= NULL
;
642 sclp_init_req
.callback_data
= NULL
;
643 sclp_init_req
.sccb
= sccb
;
644 sccb
->header
.length
= sizeof(struct init_sccb
);
645 sccb
->mask_length
= sizeof(sccb_mask_t
);
646 sccb
->receive_mask
= receive_mask
;
647 sccb
->send_mask
= send_mask
;
648 sccb
->sclp_receive_mask
= 0;
649 sccb
->sclp_send_mask
= 0;
652 /* Start init mask request. If calculate is non-zero, calculate the mask as
653 * requested by registered listeners. Use zero mask otherwise. Return 0 on
654 * success, non-zero otherwise. */
656 sclp_init_mask(int calculate
)
659 struct init_sccb
*sccb
= (struct init_sccb
*) sclp_init_sccb
;
660 sccb_mask_t receive_mask
;
661 sccb_mask_t send_mask
;
666 spin_lock_irqsave(&sclp_lock
, flags
);
667 /* Check if interface is in appropriate state */
668 if (sclp_mask_state
!= sclp_mask_state_idle
) {
669 spin_unlock_irqrestore(&sclp_lock
, flags
);
672 if (sclp_activation_state
== sclp_activation_state_inactive
) {
673 spin_unlock_irqrestore(&sclp_lock
, flags
);
676 sclp_mask_state
= sclp_mask_state_initializing
;
679 __sclp_get_mask(&receive_mask
, &send_mask
);
685 for (retry
= 0; retry
<= SCLP_MASK_RETRY
; retry
++) {
686 /* Prepare request */
687 __sclp_make_init_req(receive_mask
, send_mask
);
688 spin_unlock_irqrestore(&sclp_lock
, flags
);
689 if (sclp_add_request(&sclp_init_req
)) {
690 /* Try again later */
691 wait
= jiffies
+ SCLP_BUSY_INTERVAL
* HZ
;
692 while (time_before(jiffies
, wait
))
694 spin_lock_irqsave(&sclp_lock
, flags
);
697 while (sclp_init_req
.status
!= SCLP_REQ_DONE
&&
698 sclp_init_req
.status
!= SCLP_REQ_FAILED
)
700 spin_lock_irqsave(&sclp_lock
, flags
);
701 if (sclp_init_req
.status
== SCLP_REQ_DONE
&&
702 sccb
->header
.response_code
== 0x20) {
703 /* Successful request */
705 sclp_receive_mask
= sccb
->sclp_receive_mask
;
706 sclp_send_mask
= sccb
->sclp_send_mask
;
708 sclp_receive_mask
= 0;
711 spin_unlock_irqrestore(&sclp_lock
, flags
);
712 sclp_dispatch_state_change();
713 spin_lock_irqsave(&sclp_lock
, flags
);
718 sclp_mask_state
= sclp_mask_state_idle
;
719 spin_unlock_irqrestore(&sclp_lock
, flags
);
723 /* Deactivate SCLP interface. On success, new requests will be rejected,
724 * events will no longer be dispatched. Return 0 on success, non-zero
727 sclp_deactivate(void)
732 spin_lock_irqsave(&sclp_lock
, flags
);
733 /* Deactivate can only be called when active */
734 if (sclp_activation_state
!= sclp_activation_state_active
) {
735 spin_unlock_irqrestore(&sclp_lock
, flags
);
738 sclp_activation_state
= sclp_activation_state_deactivating
;
739 spin_unlock_irqrestore(&sclp_lock
, flags
);
740 rc
= sclp_init_mask(0);
741 spin_lock_irqsave(&sclp_lock
, flags
);
743 sclp_activation_state
= sclp_activation_state_inactive
;
745 sclp_activation_state
= sclp_activation_state_active
;
746 spin_unlock_irqrestore(&sclp_lock
, flags
);
750 EXPORT_SYMBOL(sclp_deactivate
);
752 /* Reactivate SCLP interface after sclp_deactivate. On success, new
753 * requests will be accepted, events will be dispatched again. Return 0 on
754 * success, non-zero otherwise. */
756 sclp_reactivate(void)
761 spin_lock_irqsave(&sclp_lock
, flags
);
762 /* Reactivate can only be called when inactive */
763 if (sclp_activation_state
!= sclp_activation_state_inactive
) {
764 spin_unlock_irqrestore(&sclp_lock
, flags
);
767 sclp_activation_state
= sclp_activation_state_activating
;
768 spin_unlock_irqrestore(&sclp_lock
, flags
);
769 rc
= sclp_init_mask(1);
770 spin_lock_irqsave(&sclp_lock
, flags
);
772 sclp_activation_state
= sclp_activation_state_active
;
774 sclp_activation_state
= sclp_activation_state_inactive
;
775 spin_unlock_irqrestore(&sclp_lock
, flags
);
779 EXPORT_SYMBOL(sclp_reactivate
);
781 /* Handler for external interruption used during initialization. Modify
782 * request state to done. */
784 sclp_check_handler(__u16 code
)
788 finished_sccb
= S390_lowcore
.ext_params
& 0xfffffff8;
789 /* Is this the interrupt we are waiting for? */
790 if (finished_sccb
== 0)
792 if (finished_sccb
!= (u32
) (addr_t
) sclp_init_sccb
)
793 panic("sclp: unsolicited interrupt for buffer at 0x%x\n",
795 spin_lock(&sclp_lock
);
796 if (sclp_running_state
== sclp_running_state_running
) {
797 sclp_init_req
.status
= SCLP_REQ_DONE
;
798 sclp_running_state
= sclp_running_state_idle
;
800 spin_unlock(&sclp_lock
);
803 /* Initial init mask request timed out. Modify request state to failed. */
805 sclp_check_timeout(unsigned long data
)
809 spin_lock_irqsave(&sclp_lock
, flags
);
810 if (sclp_running_state
== sclp_running_state_running
) {
811 sclp_init_req
.status
= SCLP_REQ_FAILED
;
812 sclp_running_state
= sclp_running_state_idle
;
814 spin_unlock_irqrestore(&sclp_lock
, flags
);
817 /* Perform a check of the SCLP interface. Return zero if the interface is
818 * available and there are no pending requests from a previous instance.
819 * Return non-zero otherwise. */
821 sclp_check_interface(void)
823 struct init_sccb
*sccb
;
828 spin_lock_irqsave(&sclp_lock
, flags
);
829 /* Prepare init mask command */
830 rc
= register_early_external_interrupt(0x2401, sclp_check_handler
,
833 spin_unlock_irqrestore(&sclp_lock
, flags
);
836 for (retry
= 0; retry
<= SCLP_INIT_RETRY
; retry
++) {
837 __sclp_make_init_req(0, 0);
838 sccb
= (struct init_sccb
*) sclp_init_req
.sccb
;
839 rc
= sclp_service_call(sclp_init_req
.command
, sccb
);
842 sclp_init_req
.status
= SCLP_REQ_RUNNING
;
843 sclp_running_state
= sclp_running_state_running
;
844 __sclp_set_request_timer(SCLP_RETRY_INTERVAL
* HZ
,
845 sclp_check_timeout
, 0);
846 spin_unlock_irqrestore(&sclp_lock
, flags
);
847 /* Enable service-signal interruption - needs to happen
848 * with IRQs enabled. */
850 /* Wait for signal from interrupt or timeout */
852 /* Disable service-signal interruption - needs to happen
853 * with IRQs enabled. */
855 spin_lock_irqsave(&sclp_lock
, flags
);
856 del_timer(&sclp_request_timer
);
857 if (sclp_init_req
.status
== SCLP_REQ_DONE
&&
858 sccb
->header
.response_code
== 0x20) {
864 unregister_early_external_interrupt(0x2401, sclp_check_handler
,
866 spin_unlock_irqrestore(&sclp_lock
, flags
);
870 /* Reboot event handler. Reset send and receive mask to prevent pending SCLP
871 * events from interfering with rebooted system. */
873 sclp_reboot_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
879 static struct notifier_block sclp_reboot_notifier
= {
880 .notifier_call
= sclp_reboot_event
883 /* Initialize SCLP driver. Return zero if driver is operational, non-zero
891 spin_lock_irqsave(&sclp_lock
, flags
);
892 /* Check for previous or running initialization */
893 if (sclp_init_state
!= sclp_init_state_uninitialized
) {
894 spin_unlock_irqrestore(&sclp_lock
, flags
);
897 sclp_init_state
= sclp_init_state_initializing
;
898 /* Set up variables */
899 INIT_LIST_HEAD(&sclp_req_queue
);
900 INIT_LIST_HEAD(&sclp_reg_list
);
901 list_add(&sclp_state_change_event
.list
, &sclp_reg_list
);
902 init_timer(&sclp_request_timer
);
903 /* Check interface */
904 spin_unlock_irqrestore(&sclp_lock
, flags
);
905 rc
= sclp_check_interface();
906 spin_lock_irqsave(&sclp_lock
, flags
);
908 sclp_init_state
= sclp_init_state_uninitialized
;
909 spin_unlock_irqrestore(&sclp_lock
, flags
);
912 /* Register reboot handler */
913 rc
= register_reboot_notifier(&sclp_reboot_notifier
);
915 sclp_init_state
= sclp_init_state_uninitialized
;
916 spin_unlock_irqrestore(&sclp_lock
, flags
);
919 /* Register interrupt handler */
920 rc
= register_early_external_interrupt(0x2401, sclp_interrupt_handler
,
923 unregister_reboot_notifier(&sclp_reboot_notifier
);
924 sclp_init_state
= sclp_init_state_uninitialized
;
925 spin_unlock_irqrestore(&sclp_lock
, flags
);
928 sclp_init_state
= sclp_init_state_initialized
;
929 spin_unlock_irqrestore(&sclp_lock
, flags
);
930 /* Enable service-signal external interruption - needs to happen with
937 static __init
int sclp_initcall(void)
942 arch_initcall(sclp_initcall
);