1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/err.h>
12#include <linux/spinlock.h>
13#include <linux/interrupt.h>
14#include <linux/timer.h>
15#include <linux/reboot.h>
16#include <linux/jiffies.h>
17#include <linux/init.h>
18#include <linux/suspend.h>
19#include <linux/completion.h>
20#include <linux/platform_device.h>
21#include <asm/types.h>
22#include <asm/s390_ext.h>
23
24#include "sclp.h"
25
26#define SCLP_HEADER "sclp: "
27
28
29static ext_int_info_t ext_int_info_hwc;
30
31
32static DEFINE_SPINLOCK(sclp_lock);
33
34
35static sccb_mask_t sclp_receive_mask;
36
37
38static sccb_mask_t sclp_send_mask;
39
40
41static struct list_head sclp_reg_list;
42
43
44static struct list_head sclp_req_queue;
45
46
47static struct sclp_req sclp_read_req;
48static struct sclp_req sclp_init_req;
49static char sclp_read_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
50static char sclp_init_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
51
52
53static DECLARE_COMPLETION(sclp_request_queue_flushed);
54
55static void sclp_suspend_req_cb(struct sclp_req *req, void *data)
56{
57 complete(&sclp_request_queue_flushed);
58}
59
60static struct sclp_req sclp_suspend_req;
61
62
63static struct timer_list sclp_request_timer;
64
65
66static volatile enum sclp_init_state_t {
67 sclp_init_state_uninitialized,
68 sclp_init_state_initializing,
69 sclp_init_state_initialized
70} sclp_init_state = sclp_init_state_uninitialized;
71
72
73static volatile enum sclp_running_state_t {
74 sclp_running_state_idle,
75 sclp_running_state_running,
76 sclp_running_state_reset_pending
77} sclp_running_state = sclp_running_state_idle;
78
79
80static volatile enum sclp_reading_state_t {
81 sclp_reading_state_idle,
82 sclp_reading_state_reading
83} sclp_reading_state = sclp_reading_state_idle;
84
85
86static volatile enum sclp_activation_state_t {
87 sclp_activation_state_active,
88 sclp_activation_state_deactivating,
89 sclp_activation_state_inactive,
90 sclp_activation_state_activating
91} sclp_activation_state = sclp_activation_state_active;
92
93
94static volatile enum sclp_mask_state_t {
95 sclp_mask_state_idle,
96 sclp_mask_state_initializing
97} sclp_mask_state = sclp_mask_state_idle;
98
99
100static enum sclp_suspend_state_t {
101 sclp_suspend_state_running,
102 sclp_suspend_state_suspended,
103} sclp_suspend_state = sclp_suspend_state_running;
104
105
106#define SCLP_INIT_RETRY 3
107#define SCLP_MASK_RETRY 3
108
109
110#define SCLP_BUSY_INTERVAL 10
111#define SCLP_RETRY_INTERVAL 30
112
113static void sclp_process_queue(void);
114static void __sclp_make_read_req(void);
115static int sclp_init_mask(int calculate);
116static int sclp_init(void);
117
118
119int
120sclp_service_call(sclp_cmdw_t command, void *sccb)
121{
122 int cc;
123
124 asm volatile(
125 " .insn rre,0xb2200000,%1,%2\n"
126 " ipm %0\n"
127 " srl %0,28"
128 : "=&d" (cc) : "d" (command), "a" (__pa(sccb))
129 : "cc", "memory");
130 if (cc == 3)
131 return -EIO;
132 if (cc == 2)
133 return -EBUSY;
134 return 0;
135}
136
137
138static void
139__sclp_queue_read_req(void)
140{
141 if (sclp_reading_state == sclp_reading_state_idle) {
142 sclp_reading_state = sclp_reading_state_reading;
143 __sclp_make_read_req();
144
145 list_add(&sclp_read_req.list, &sclp_req_queue);
146 }
147}
148
149
150static inline void
151__sclp_set_request_timer(unsigned long time, void (*function)(unsigned long),
152 unsigned long data)
153{
154 del_timer(&sclp_request_timer);
155 sclp_request_timer.function = function;
156 sclp_request_timer.data = data;
157 sclp_request_timer.expires = jiffies + time;
158 add_timer(&sclp_request_timer);
159}
160
161
162
163static void
164sclp_request_timeout(unsigned long data)
165{
166 unsigned long flags;
167
168 spin_lock_irqsave(&sclp_lock, flags);
169 if (data) {
170 if (sclp_running_state == sclp_running_state_running) {
171
172
173 __sclp_queue_read_req();
174 sclp_running_state = sclp_running_state_idle;
175 }
176 } else {
177 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
178 sclp_request_timeout, 0);
179 }
180 spin_unlock_irqrestore(&sclp_lock, flags);
181 sclp_process_queue();
182}
183
184
185
186
187static int
188__sclp_start_request(struct sclp_req *req)
189{
190 int rc;
191
192 if (sclp_running_state != sclp_running_state_idle)
193 return 0;
194 del_timer(&sclp_request_timer);
195 rc = sclp_service_call(req->command, req->sccb);
196 req->start_count++;
197
198 if (rc == 0) {
199
200 req->status = SCLP_REQ_RUNNING;
201 sclp_running_state = sclp_running_state_running;
202 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
203 sclp_request_timeout, 1);
204 return 0;
205 } else if (rc == -EBUSY) {
206
207 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
208 sclp_request_timeout, 0);
209 return 0;
210 }
211
212 req->status = SCLP_REQ_FAILED;
213 return rc;
214}
215
216
217static void
218sclp_process_queue(void)
219{
220 struct sclp_req *req;
221 int rc;
222 unsigned long flags;
223
224 spin_lock_irqsave(&sclp_lock, flags);
225 if (sclp_running_state != sclp_running_state_idle) {
226 spin_unlock_irqrestore(&sclp_lock, flags);
227 return;
228 }
229 del_timer(&sclp_request_timer);
230 while (!list_empty(&sclp_req_queue)) {
231 req = list_entry(sclp_req_queue.next, struct sclp_req, list);
232 if (!req->sccb)
233 goto do_post;
234 rc = __sclp_start_request(req);
235 if (rc == 0)
236 break;
237
238 if (req->start_count > 1) {
239
240
241 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
242 sclp_request_timeout, 0);
243 break;
244 }
245do_post:
246
247 list_del(&req->list);
248 if (req->callback) {
249 spin_unlock_irqrestore(&sclp_lock, flags);
250 req->callback(req, req->callback_data);
251 spin_lock_irqsave(&sclp_lock, flags);
252 }
253 }
254 spin_unlock_irqrestore(&sclp_lock, flags);
255}
256
257static int __sclp_can_add_request(struct sclp_req *req)
258{
259 if (req == &sclp_suspend_req || req == &sclp_init_req)
260 return 1;
261 if (sclp_suspend_state != sclp_suspend_state_running)
262 return 0;
263 if (sclp_init_state != sclp_init_state_initialized)
264 return 0;
265 if (sclp_activation_state != sclp_activation_state_active)
266 return 0;
267 return 1;
268}
269
270
271int
272sclp_add_request(struct sclp_req *req)
273{
274 unsigned long flags;
275 int rc;
276
277 spin_lock_irqsave(&sclp_lock, flags);
278 if (!__sclp_can_add_request(req)) {
279 spin_unlock_irqrestore(&sclp_lock, flags);
280 return -EIO;
281 }
282 req->status = SCLP_REQ_QUEUED;
283 req->start_count = 0;
284 list_add_tail(&req->list, &sclp_req_queue);
285 rc = 0;
286
287 if (sclp_running_state == sclp_running_state_idle &&
288 req->list.prev == &sclp_req_queue) {
289 if (!req->sccb) {
290 list_del(&req->list);
291 rc = -ENODATA;
292 goto out;
293 }
294 rc = __sclp_start_request(req);
295 if (rc)
296 list_del(&req->list);
297 }
298out:
299 spin_unlock_irqrestore(&sclp_lock, flags);
300 return rc;
301}
302
303EXPORT_SYMBOL(sclp_add_request);
304
305
306
307static int
308sclp_dispatch_evbufs(struct sccb_header *sccb)
309{
310 unsigned long flags;
311 struct evbuf_header *evbuf;
312 struct list_head *l;
313 struct sclp_register *reg;
314 int offset;
315 int rc;
316
317 spin_lock_irqsave(&sclp_lock, flags);
318 rc = 0;
319 for (offset = sizeof(struct sccb_header); offset < sccb->length;
320 offset += evbuf->length) {
321 evbuf = (struct evbuf_header *) ((addr_t) sccb + offset);
322
323 if (evbuf->length == 0)
324 break;
325
326 reg = NULL;
327 list_for_each(l, &sclp_reg_list) {
328 reg = list_entry(l, struct sclp_register, list);
329 if (reg->receive_mask & (1 << (32 - evbuf->type)))
330 break;
331 else
332 reg = NULL;
333 }
334 if (reg && reg->receiver_fn) {
335 spin_unlock_irqrestore(&sclp_lock, flags);
336 reg->receiver_fn(evbuf);
337 spin_lock_irqsave(&sclp_lock, flags);
338 } else if (reg == NULL)
339 rc = -ENOSYS;
340 }
341 spin_unlock_irqrestore(&sclp_lock, flags);
342 return rc;
343}
344
345
346static void
347sclp_read_cb(struct sclp_req *req, void *data)
348{
349 unsigned long flags;
350 struct sccb_header *sccb;
351
352 sccb = (struct sccb_header *) req->sccb;
353 if (req->status == SCLP_REQ_DONE && (sccb->response_code == 0x20 ||
354 sccb->response_code == 0x220))
355 sclp_dispatch_evbufs(sccb);
356 spin_lock_irqsave(&sclp_lock, flags);
357 sclp_reading_state = sclp_reading_state_idle;
358 spin_unlock_irqrestore(&sclp_lock, flags);
359}
360
361
362static void __sclp_make_read_req(void)
363{
364 struct sccb_header *sccb;
365
366 sccb = (struct sccb_header *) sclp_read_sccb;
367 clear_page(sccb);
368 memset(&sclp_read_req, 0, sizeof(struct sclp_req));
369 sclp_read_req.command = SCLP_CMDW_READ_EVENT_DATA;
370 sclp_read_req.status = SCLP_REQ_QUEUED;
371 sclp_read_req.start_count = 0;
372 sclp_read_req.callback = sclp_read_cb;
373 sclp_read_req.sccb = sccb;
374 sccb->length = PAGE_SIZE;
375 sccb->function_code = 0;
376 sccb->control_mask[2] = 0x80;
377}
378
379
380
381static inline struct sclp_req *
382__sclp_find_req(u32 sccb)
383{
384 struct list_head *l;
385 struct sclp_req *req;
386
387 list_for_each(l, &sclp_req_queue) {
388 req = list_entry(l, struct sclp_req, list);
389 if (sccb == (u32) (addr_t) req->sccb)
390 return req;
391 }
392 return NULL;
393}
394
395
396
397
398static void
399sclp_interrupt_handler(__u16 code)
400{
401 struct sclp_req *req;
402 u32 finished_sccb;
403 u32 evbuf_pending;
404
405 spin_lock(&sclp_lock);
406 finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
407 evbuf_pending = S390_lowcore.ext_params & 0x3;
408 if (finished_sccb) {
409 del_timer(&sclp_request_timer);
410 sclp_running_state = sclp_running_state_reset_pending;
411 req = __sclp_find_req(finished_sccb);
412 if (req) {
413
414 list_del(&req->list);
415 req->status = SCLP_REQ_DONE;
416 if (req->callback) {
417 spin_unlock(&sclp_lock);
418 req->callback(req, req->callback_data);
419 spin_lock(&sclp_lock);
420 }
421 }
422 sclp_running_state = sclp_running_state_idle;
423 }
424 if (evbuf_pending &&
425 sclp_activation_state == sclp_activation_state_active)
426 __sclp_queue_read_req();
427 spin_unlock(&sclp_lock);
428 sclp_process_queue();
429}
430
431
432static inline u64
433sclp_tod_from_jiffies(unsigned long jiffies)
434{
435 return (u64) (jiffies / HZ) << 32;
436}
437
438
439
440void
441sclp_sync_wait(void)
442{
443 unsigned long long old_tick;
444 unsigned long flags;
445 unsigned long cr0, cr0_sync;
446 u64 timeout;
447 int irq_context;
448
449
450
451 timeout = 0;
452 if (timer_pending(&sclp_request_timer)) {
453
454 timeout = get_clock() +
455 sclp_tod_from_jiffies(sclp_request_timer.expires -
456 jiffies);
457 }
458 local_irq_save(flags);
459
460 irq_context = in_interrupt();
461 if (!irq_context)
462 local_bh_disable();
463
464 old_tick = local_tick_disable();
465 trace_hardirqs_on();
466 __ctl_store(cr0, 0, 0);
467 cr0_sync = cr0;
468 cr0_sync &= 0xffff00a0;
469 cr0_sync |= 0x00000200;
470 __ctl_load(cr0_sync, 0, 0);
471 __raw_local_irq_stosm(0x01);
472
473 while (sclp_running_state != sclp_running_state_idle) {
474
475 if (timer_pending(&sclp_request_timer) &&
476 get_clock() > timeout &&
477 del_timer(&sclp_request_timer))
478 sclp_request_timer.function(sclp_request_timer.data);
479 cpu_relax();
480 }
481 local_irq_disable();
482 __ctl_load(cr0, 0, 0);
483 if (!irq_context)
484 _local_bh_enable();
485 local_tick_enable(old_tick);
486 local_irq_restore(flags);
487}
488EXPORT_SYMBOL(sclp_sync_wait);
489
490
491static void
492sclp_dispatch_state_change(void)
493{
494 struct list_head *l;
495 struct sclp_register *reg;
496 unsigned long flags;
497 sccb_mask_t receive_mask;
498 sccb_mask_t send_mask;
499
500 do {
501 spin_lock_irqsave(&sclp_lock, flags);
502 reg = NULL;
503 list_for_each(l, &sclp_reg_list) {
504 reg = list_entry(l, struct sclp_register, list);
505 receive_mask = reg->send_mask & sclp_receive_mask;
506 send_mask = reg->receive_mask & sclp_send_mask;
507 if (reg->sclp_receive_mask != receive_mask ||
508 reg->sclp_send_mask != send_mask) {
509 reg->sclp_receive_mask = receive_mask;
510 reg->sclp_send_mask = send_mask;
511 break;
512 } else
513 reg = NULL;
514 }
515 spin_unlock_irqrestore(&sclp_lock, flags);
516 if (reg && reg->state_change_fn)
517 reg->state_change_fn(reg);
518 } while (reg);
519}
520
521struct sclp_statechangebuf {
522 struct evbuf_header header;
523 u8 validity_sclp_active_facility_mask : 1;
524 u8 validity_sclp_receive_mask : 1;
525 u8 validity_sclp_send_mask : 1;
526 u8 validity_read_data_function_mask : 1;
527 u16 _zeros : 12;
528 u16 mask_length;
529 u64 sclp_active_facility_mask;
530 sccb_mask_t sclp_receive_mask;
531 sccb_mask_t sclp_send_mask;
532 u32 read_data_function_mask;
533} __attribute__((packed));
534
535
536
537static void
538sclp_state_change_cb(struct evbuf_header *evbuf)
539{
540 unsigned long flags;
541 struct sclp_statechangebuf *scbuf;
542
543 scbuf = (struct sclp_statechangebuf *) evbuf;
544 if (scbuf->mask_length != sizeof(sccb_mask_t))
545 return;
546 spin_lock_irqsave(&sclp_lock, flags);
547 if (scbuf->validity_sclp_receive_mask)
548 sclp_receive_mask = scbuf->sclp_receive_mask;
549 if (scbuf->validity_sclp_send_mask)
550 sclp_send_mask = scbuf->sclp_send_mask;
551 spin_unlock_irqrestore(&sclp_lock, flags);
552 if (scbuf->validity_sclp_active_facility_mask)
553 sclp_facilities = scbuf->sclp_active_facility_mask;
554 sclp_dispatch_state_change();
555}
556
557static struct sclp_register sclp_state_change_event = {
558 .receive_mask = EVTYP_STATECHANGE_MASK,
559 .receiver_fn = sclp_state_change_cb
560};
561
562
563
564static inline void
565__sclp_get_mask(sccb_mask_t *receive_mask, sccb_mask_t *send_mask)
566{
567 struct list_head *l;
568 struct sclp_register *t;
569
570 *receive_mask = 0;
571 *send_mask = 0;
572 list_for_each(l, &sclp_reg_list) {
573 t = list_entry(l, struct sclp_register, list);
574 *receive_mask |= t->receive_mask;
575 *send_mask |= t->send_mask;
576 }
577}
578
579
580int
581sclp_register(struct sclp_register *reg)
582{
583 unsigned long flags;
584 sccb_mask_t receive_mask;
585 sccb_mask_t send_mask;
586 int rc;
587
588 rc = sclp_init();
589 if (rc)
590 return rc;
591 spin_lock_irqsave(&sclp_lock, flags);
592
593 __sclp_get_mask(&receive_mask, &send_mask);
594 if (reg->receive_mask & receive_mask || reg->send_mask & send_mask) {
595 spin_unlock_irqrestore(&sclp_lock, flags);
596 return -EBUSY;
597 }
598
599 reg->sclp_receive_mask = 0;
600 reg->sclp_send_mask = 0;
601 reg->pm_event_posted = 0;
602 list_add(®->list, &sclp_reg_list);
603 spin_unlock_irqrestore(&sclp_lock, flags);
604 rc = sclp_init_mask(1);
605 if (rc) {
606 spin_lock_irqsave(&sclp_lock, flags);
607 list_del(®->list);
608 spin_unlock_irqrestore(&sclp_lock, flags);
609 }
610 return rc;
611}
612
613EXPORT_SYMBOL(sclp_register);
614
615
616void
617sclp_unregister(struct sclp_register *reg)
618{
619 unsigned long flags;
620
621 spin_lock_irqsave(&sclp_lock, flags);
622 list_del(®->list);
623 spin_unlock_irqrestore(&sclp_lock, flags);
624 sclp_init_mask(1);
625}
626
627EXPORT_SYMBOL(sclp_unregister);
628
629
630
631int
632sclp_remove_processed(struct sccb_header *sccb)
633{
634 struct evbuf_header *evbuf;
635 int unprocessed;
636 u16 remaining;
637
638 evbuf = (struct evbuf_header *) (sccb + 1);
639 unprocessed = 0;
640 remaining = sccb->length - sizeof(struct sccb_header);
641 while (remaining > 0) {
642 remaining -= evbuf->length;
643 if (evbuf->flags & 0x80) {
644 sccb->length -= evbuf->length;
645 memcpy(evbuf, (void *) ((addr_t) evbuf + evbuf->length),
646 remaining);
647 } else {
648 unprocessed++;
649 evbuf = (struct evbuf_header *)
650 ((addr_t) evbuf + evbuf->length);
651 }
652 }
653 return unprocessed;
654}
655
656EXPORT_SYMBOL(sclp_remove_processed);
657
658struct init_sccb {
659 struct sccb_header header;
660 u16 _reserved;
661 u16 mask_length;
662 sccb_mask_t receive_mask;
663 sccb_mask_t send_mask;
664 sccb_mask_t sclp_receive_mask;
665 sccb_mask_t sclp_send_mask;
666} __attribute__((packed));
667
668
669static inline void
670__sclp_make_init_req(u32 receive_mask, u32 send_mask)
671{
672 struct init_sccb *sccb;
673
674 sccb = (struct init_sccb *) sclp_init_sccb;
675 clear_page(sccb);
676 memset(&sclp_init_req, 0, sizeof(struct sclp_req));
677 sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
678 sclp_init_req.status = SCLP_REQ_FILLED;
679 sclp_init_req.start_count = 0;
680 sclp_init_req.callback = NULL;
681 sclp_init_req.callback_data = NULL;
682 sclp_init_req.sccb = sccb;
683 sccb->header.length = sizeof(struct init_sccb);
684 sccb->mask_length = sizeof(sccb_mask_t);
685 sccb->receive_mask = receive_mask;
686 sccb->send_mask = send_mask;
687 sccb->sclp_receive_mask = 0;
688 sccb->sclp_send_mask = 0;
689}
690
691
692
693
694static int
695sclp_init_mask(int calculate)
696{
697 unsigned long flags;
698 struct init_sccb *sccb = (struct init_sccb *) sclp_init_sccb;
699 sccb_mask_t receive_mask;
700 sccb_mask_t send_mask;
701 int retry;
702 int rc;
703 unsigned long wait;
704
705 spin_lock_irqsave(&sclp_lock, flags);
706
707 if (sclp_mask_state != sclp_mask_state_idle) {
708 spin_unlock_irqrestore(&sclp_lock, flags);
709 return -EBUSY;
710 }
711 if (sclp_activation_state == sclp_activation_state_inactive) {
712 spin_unlock_irqrestore(&sclp_lock, flags);
713 return -EINVAL;
714 }
715 sclp_mask_state = sclp_mask_state_initializing;
716
717 if (calculate)
718 __sclp_get_mask(&receive_mask, &send_mask);
719 else {
720 receive_mask = 0;
721 send_mask = 0;
722 }
723 rc = -EIO;
724 for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
725
726 __sclp_make_init_req(receive_mask, send_mask);
727 spin_unlock_irqrestore(&sclp_lock, flags);
728 if (sclp_add_request(&sclp_init_req)) {
729
730 wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
731 while (time_before(jiffies, wait))
732 sclp_sync_wait();
733 spin_lock_irqsave(&sclp_lock, flags);
734 continue;
735 }
736 while (sclp_init_req.status != SCLP_REQ_DONE &&
737 sclp_init_req.status != SCLP_REQ_FAILED)
738 sclp_sync_wait();
739 spin_lock_irqsave(&sclp_lock, flags);
740 if (sclp_init_req.status == SCLP_REQ_DONE &&
741 sccb->header.response_code == 0x20) {
742
743 if (calculate) {
744 sclp_receive_mask = sccb->sclp_receive_mask;
745 sclp_send_mask = sccb->sclp_send_mask;
746 } else {
747 sclp_receive_mask = 0;
748 sclp_send_mask = 0;
749 }
750 spin_unlock_irqrestore(&sclp_lock, flags);
751 sclp_dispatch_state_change();
752 spin_lock_irqsave(&sclp_lock, flags);
753 rc = 0;
754 break;
755 }
756 }
757 sclp_mask_state = sclp_mask_state_idle;
758 spin_unlock_irqrestore(&sclp_lock, flags);
759 return rc;
760}
761
762
763
764
765int
766sclp_deactivate(void)
767{
768 unsigned long flags;
769 int rc;
770
771 spin_lock_irqsave(&sclp_lock, flags);
772
773 if (sclp_activation_state != sclp_activation_state_active) {
774 spin_unlock_irqrestore(&sclp_lock, flags);
775 return -EINVAL;
776 }
777 sclp_activation_state = sclp_activation_state_deactivating;
778 spin_unlock_irqrestore(&sclp_lock, flags);
779 rc = sclp_init_mask(0);
780 spin_lock_irqsave(&sclp_lock, flags);
781 if (rc == 0)
782 sclp_activation_state = sclp_activation_state_inactive;
783 else
784 sclp_activation_state = sclp_activation_state_active;
785 spin_unlock_irqrestore(&sclp_lock, flags);
786 return rc;
787}
788
789EXPORT_SYMBOL(sclp_deactivate);
790
791
792
793
794int
795sclp_reactivate(void)
796{
797 unsigned long flags;
798 int rc;
799
800 spin_lock_irqsave(&sclp_lock, flags);
801
802 if (sclp_activation_state != sclp_activation_state_inactive) {
803 spin_unlock_irqrestore(&sclp_lock, flags);
804 return -EINVAL;
805 }
806 sclp_activation_state = sclp_activation_state_activating;
807 spin_unlock_irqrestore(&sclp_lock, flags);
808 rc = sclp_init_mask(1);
809 spin_lock_irqsave(&sclp_lock, flags);
810 if (rc == 0)
811 sclp_activation_state = sclp_activation_state_active;
812 else
813 sclp_activation_state = sclp_activation_state_inactive;
814 spin_unlock_irqrestore(&sclp_lock, flags);
815 return rc;
816}
817
818EXPORT_SYMBOL(sclp_reactivate);
819
820
821
822static void
823sclp_check_handler(__u16 code)
824{
825 u32 finished_sccb;
826
827 finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
828
829 if (finished_sccb == 0)
830 return;
831 if (finished_sccb != (u32) (addr_t) sclp_init_sccb)
832 panic("sclp: unsolicited interrupt for buffer at 0x%x\n",
833 finished_sccb);
834 spin_lock(&sclp_lock);
835 if (sclp_running_state == sclp_running_state_running) {
836 sclp_init_req.status = SCLP_REQ_DONE;
837 sclp_running_state = sclp_running_state_idle;
838 }
839 spin_unlock(&sclp_lock);
840}
841
842
843static void
844sclp_check_timeout(unsigned long data)
845{
846 unsigned long flags;
847
848 spin_lock_irqsave(&sclp_lock, flags);
849 if (sclp_running_state == sclp_running_state_running) {
850 sclp_init_req.status = SCLP_REQ_FAILED;
851 sclp_running_state = sclp_running_state_idle;
852 }
853 spin_unlock_irqrestore(&sclp_lock, flags);
854}
855
856
857
858
859static int
860sclp_check_interface(void)
861{
862 struct init_sccb *sccb;
863 unsigned long flags;
864 int retry;
865 int rc;
866
867 spin_lock_irqsave(&sclp_lock, flags);
868
869 rc = register_early_external_interrupt(0x2401, sclp_check_handler,
870 &ext_int_info_hwc);
871 if (rc) {
872 spin_unlock_irqrestore(&sclp_lock, flags);
873 return rc;
874 }
875 for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
876 __sclp_make_init_req(0, 0);
877 sccb = (struct init_sccb *) sclp_init_req.sccb;
878 rc = sclp_service_call(sclp_init_req.command, sccb);
879 if (rc == -EIO)
880 break;
881 sclp_init_req.status = SCLP_REQ_RUNNING;
882 sclp_running_state = sclp_running_state_running;
883 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
884 sclp_check_timeout, 0);
885 spin_unlock_irqrestore(&sclp_lock, flags);
886
887
888 ctl_set_bit(0, 9);
889
890 sclp_sync_wait();
891
892
893 ctl_clear_bit(0,9);
894 spin_lock_irqsave(&sclp_lock, flags);
895 del_timer(&sclp_request_timer);
896 if (sclp_init_req.status == SCLP_REQ_DONE &&
897 sccb->header.response_code == 0x20) {
898 rc = 0;
899 break;
900 } else
901 rc = -EBUSY;
902 }
903 unregister_early_external_interrupt(0x2401, sclp_check_handler,
904 &ext_int_info_hwc);
905 spin_unlock_irqrestore(&sclp_lock, flags);
906 return rc;
907}
908
909
910
911static int
912sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
913{
914 sclp_deactivate();
915 return NOTIFY_DONE;
916}
917
918static struct notifier_block sclp_reboot_notifier = {
919 .notifier_call = sclp_reboot_event
920};
921
922
923
924
925
926static void sclp_pm_event(enum sclp_pm_event sclp_pm_event, int rollback)
927{
928 struct sclp_register *reg;
929 unsigned long flags;
930
931 if (!rollback) {
932 spin_lock_irqsave(&sclp_lock, flags);
933 list_for_each_entry(reg, &sclp_reg_list, list)
934 reg->pm_event_posted = 0;
935 spin_unlock_irqrestore(&sclp_lock, flags);
936 }
937 do {
938 spin_lock_irqsave(&sclp_lock, flags);
939 list_for_each_entry(reg, &sclp_reg_list, list) {
940 if (rollback && reg->pm_event_posted)
941 goto found;
942 if (!rollback && !reg->pm_event_posted)
943 goto found;
944 }
945 spin_unlock_irqrestore(&sclp_lock, flags);
946 return;
947found:
948 spin_unlock_irqrestore(&sclp_lock, flags);
949 if (reg->pm_event_fn)
950 reg->pm_event_fn(reg, sclp_pm_event);
951 reg->pm_event_posted = rollback ? 0 : 1;
952 } while (1);
953}
954
955
956
957
958
959static int sclp_freeze(struct device *dev)
960{
961 unsigned long flags;
962 int rc;
963
964 sclp_pm_event(SCLP_PM_EVENT_FREEZE, 0);
965
966 spin_lock_irqsave(&sclp_lock, flags);
967 sclp_suspend_state = sclp_suspend_state_suspended;
968 spin_unlock_irqrestore(&sclp_lock, flags);
969
970
971 memset(&sclp_suspend_req, 0, sizeof(sclp_suspend_req));
972 sclp_suspend_req.callback = sclp_suspend_req_cb;
973 sclp_suspend_req.status = SCLP_REQ_FILLED;
974 init_completion(&sclp_request_queue_flushed);
975
976 rc = sclp_add_request(&sclp_suspend_req);
977 if (rc == 0)
978 wait_for_completion(&sclp_request_queue_flushed);
979 else if (rc != -ENODATA)
980 goto fail_thaw;
981
982 rc = sclp_deactivate();
983 if (rc)
984 goto fail_thaw;
985 return 0;
986
987fail_thaw:
988 spin_lock_irqsave(&sclp_lock, flags);
989 sclp_suspend_state = sclp_suspend_state_running;
990 spin_unlock_irqrestore(&sclp_lock, flags);
991 sclp_pm_event(SCLP_PM_EVENT_THAW, 1);
992 return rc;
993}
994
995static int sclp_undo_suspend(enum sclp_pm_event event)
996{
997 unsigned long flags;
998 int rc;
999
1000 rc = sclp_reactivate();
1001 if (rc)
1002 return rc;
1003
1004 spin_lock_irqsave(&sclp_lock, flags);
1005 sclp_suspend_state = sclp_suspend_state_running;
1006 spin_unlock_irqrestore(&sclp_lock, flags);
1007
1008 sclp_pm_event(event, 0);
1009 return 0;
1010}
1011
1012static int sclp_thaw(struct device *dev)
1013{
1014 return sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1015}
1016
1017static int sclp_restore(struct device *dev)
1018{
1019 return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
1020}
1021
1022static struct dev_pm_ops sclp_pm_ops = {
1023 .freeze = sclp_freeze,
1024 .thaw = sclp_thaw,
1025 .restore = sclp_restore,
1026};
1027
1028static struct platform_driver sclp_pdrv = {
1029 .driver = {
1030 .name = "sclp",
1031 .owner = THIS_MODULE,
1032 .pm = &sclp_pm_ops,
1033 },
1034};
1035
1036static struct platform_device *sclp_pdev;
1037
1038
1039
1040static int
1041sclp_init(void)
1042{
1043 unsigned long flags;
1044 int rc = 0;
1045
1046 spin_lock_irqsave(&sclp_lock, flags);
1047
1048 if (sclp_init_state != sclp_init_state_uninitialized)
1049 goto fail_unlock;
1050 sclp_init_state = sclp_init_state_initializing;
1051
1052 INIT_LIST_HEAD(&sclp_req_queue);
1053 INIT_LIST_HEAD(&sclp_reg_list);
1054 list_add(&sclp_state_change_event.list, &sclp_reg_list);
1055 init_timer(&sclp_request_timer);
1056
1057 spin_unlock_irqrestore(&sclp_lock, flags);
1058 rc = sclp_check_interface();
1059 spin_lock_irqsave(&sclp_lock, flags);
1060 if (rc)
1061 goto fail_init_state_uninitialized;
1062
1063 rc = register_reboot_notifier(&sclp_reboot_notifier);
1064 if (rc)
1065 goto fail_init_state_uninitialized;
1066
1067 rc = register_early_external_interrupt(0x2401, sclp_interrupt_handler,
1068 &ext_int_info_hwc);
1069 if (rc)
1070 goto fail_unregister_reboot_notifier;
1071 sclp_init_state = sclp_init_state_initialized;
1072 spin_unlock_irqrestore(&sclp_lock, flags);
1073
1074
1075 ctl_set_bit(0, 9);
1076 sclp_init_mask(1);
1077 return 0;
1078
1079fail_unregister_reboot_notifier:
1080 unregister_reboot_notifier(&sclp_reboot_notifier);
1081fail_init_state_uninitialized:
1082 sclp_init_state = sclp_init_state_uninitialized;
1083fail_unlock:
1084 spin_unlock_irqrestore(&sclp_lock, flags);
1085 return rc;
1086}
1087
1088
1089
1090
1091
1092static int sclp_panic_notify(struct notifier_block *self,
1093 unsigned long event, void *data)
1094{
1095 if (sclp_suspend_state == sclp_suspend_state_suspended)
1096 sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1097 return NOTIFY_OK;
1098}
1099
1100static struct notifier_block sclp_on_panic_nb = {
1101 .notifier_call = sclp_panic_notify,
1102 .priority = SCLP_PANIC_PRIO,
1103};
1104
1105static __init int sclp_initcall(void)
1106{
1107 int rc;
1108
1109 rc = platform_driver_register(&sclp_pdrv);
1110 if (rc)
1111 return rc;
1112 sclp_pdev = platform_device_register_simple("sclp", -1, NULL, 0);
1113 rc = IS_ERR(sclp_pdev) ? PTR_ERR(sclp_pdev) : 0;
1114 if (rc)
1115 goto fail_platform_driver_unregister;
1116 rc = atomic_notifier_chain_register(&panic_notifier_list,
1117 &sclp_on_panic_nb);
1118 if (rc)
1119 goto fail_platform_device_unregister;
1120
1121 return sclp_init();
1122
1123fail_platform_device_unregister:
1124 platform_device_unregister(sclp_pdev);
1125fail_platform_driver_unregister:
1126 platform_driver_unregister(&sclp_pdrv);
1127 return rc;
1128}
1129
1130arch_initcall(sclp_initcall);
1131