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