This source file includes following definitions.
- sclp_suspend_req_cb
- sclp_setup_console_pages
- sclp_setup_console_drop
- __sclp_queue_read_req
- __sclp_set_request_timer
- sclp_request_timeout_restart
- sclp_request_timeout_normal
- sclp_request_timeout
- __sclp_req_queue_find_next_timeout
- __sclp_req_queue_remove_expired_req
- sclp_req_queue_timeout
- __sclp_start_request
- sclp_process_queue
- __sclp_can_add_request
- sclp_add_request
- sclp_dispatch_evbufs
- sclp_read_cb
- __sclp_make_read_req
- __sclp_find_req
- sclp_interrupt_handler
- sclp_tod_from_jiffies
- sclp_sync_wait
- sclp_dispatch_state_change
- sclp_state_change_cb
- __sclp_get_mask
- sclp_register
- sclp_unregister
- sclp_remove_processed
- __sclp_make_init_req
- sclp_init_mask
- sclp_deactivate
- sclp_reactivate
- sclp_check_handler
- sclp_check_timeout
- sclp_check_interface
- sclp_reboot_event
- sclp_pm_event
- sclp_freeze
- sclp_undo_suspend
- sclp_thaw
- sclp_restore
- con_pages_show
- con_drop_show
- con_full_show
- sclp_init
- sclp_panic_notify
- sclp_initcall
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
31 static DEFINE_SPINLOCK(sclp_lock);
32
33
34 static sccb_mask_t sclp_receive_mask;
35
36
37 static sccb_mask_t sclp_send_mask;
38
39
40 static struct list_head sclp_reg_list;
41
42
43 static struct list_head sclp_req_queue;
44
45
46 static struct sclp_req sclp_read_req;
47 static struct sclp_req sclp_init_req;
48 static void *sclp_read_sccb;
49 static struct init_sccb *sclp_init_sccb;
50
51
52 static DECLARE_COMPLETION(sclp_request_queue_flushed);
53
54
55 int sclp_console_pages = SCLP_CONSOLE_PAGES;
56
57 int sclp_console_drop = 1;
58
59 unsigned long sclp_console_full;
60
61 static void sclp_suspend_req_cb(struct sclp_req *req, void *data)
62 {
63 complete(&sclp_request_queue_flushed);
64 }
65
66 static 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
78 static 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
90 static struct sclp_req sclp_suspend_req;
91
92
93 static struct timer_list sclp_request_timer;
94
95
96 static struct timer_list sclp_queue_timer;
97
98
99 static 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
106 static 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
112 static 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
120 static 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
126 static 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
139 static void sclp_request_timeout(bool force_restart);
140 static void sclp_process_queue(void);
141 static void __sclp_make_read_req(void);
142 static int sclp_init_mask(int calculate);
143 static int sclp_init(void);
144
145 static 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
157 static 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
166 static void sclp_request_timeout_restart(struct timer_list *unused)
167 {
168 sclp_request_timeout(true);
169 }
170
171 static void sclp_request_timeout_normal(struct timer_list *unused)
172 {
173 sclp_request_timeout(false);
174 }
175
176
177
178 static 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
202 static 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
220 static 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;
240 out:
241 spin_unlock_irqrestore(&sclp_lock, flags);
242 return req;
243 }
244
245
246
247
248
249
250 static 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
271 static 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
301 static void
302 sclp_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 }
329 do_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
341 static 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
355 int
356 sclp_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 }
389 out:
390 spin_unlock_irqrestore(&sclp_lock, flags);
391 return rc;
392 }
393
394 EXPORT_SYMBOL(sclp_add_request);
395
396
397
398 static int
399 sclp_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
437 static void
438 sclp_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
453 static 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
472 static 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
489 static 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
524 static inline u64
525 sclp_tod_from_jiffies(unsigned long jiffies)
526 {
527 return (u64) (jiffies / HZ) << 32;
528 }
529
530
531
532 void
533 sclp_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 }
579 EXPORT_SYMBOL(sclp_sync_wait);
580
581
582 static void
583 sclp_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
612 struct 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
631 static void
632 sclp_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
651 static struct sclp_register sclp_state_change_event = {
652 .receive_mask = EVTYP_STATECHANGE_MASK,
653 .receiver_fn = sclp_state_change_cb
654 };
655
656
657
658 static 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
674 int
675 sclp_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
707 EXPORT_SYMBOL(sclp_register);
708
709
710 void
711 sclp_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
721 EXPORT_SYMBOL(sclp_unregister);
722
723
724
725 int
726 sclp_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
750 EXPORT_SYMBOL(sclp_remove_processed);
751
752
753 static inline void
754 __sclp_make_init_req(sccb_mask_t receive_mask, sccb_mask_t send_mask)
755 {
756 struct init_sccb *sccb = sclp_init_sccb;
757
758 clear_page(sccb);
759 memset(&sclp_init_req, 0, sizeof(struct sclp_req));
760 sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
761 sclp_init_req.status = SCLP_REQ_FILLED;
762 sclp_init_req.start_count = 0;
763 sclp_init_req.callback = NULL;
764 sclp_init_req.callback_data = NULL;
765 sclp_init_req.sccb = sccb;
766 sccb->header.length = sizeof(*sccb);
767 if (sclp_mask_compat_mode)
768 sccb->mask_length = SCLP_MASK_SIZE_COMPAT;
769 else
770 sccb->mask_length = sizeof(sccb_mask_t);
771 sccb_set_recv_mask(sccb, receive_mask);
772 sccb_set_send_mask(sccb, send_mask);
773 sccb_set_sclp_recv_mask(sccb, 0);
774 sccb_set_sclp_send_mask(sccb, 0);
775 }
776
777
778
779
780 static int
781 sclp_init_mask(int calculate)
782 {
783 unsigned long flags;
784 struct init_sccb *sccb = sclp_init_sccb;
785 sccb_mask_t receive_mask;
786 sccb_mask_t send_mask;
787 int retry;
788 int rc;
789 unsigned long wait;
790
791 spin_lock_irqsave(&sclp_lock, flags);
792
793 if (sclp_mask_state != sclp_mask_state_idle) {
794 spin_unlock_irqrestore(&sclp_lock, flags);
795 return -EBUSY;
796 }
797 if (sclp_activation_state == sclp_activation_state_inactive) {
798 spin_unlock_irqrestore(&sclp_lock, flags);
799 return -EINVAL;
800 }
801 sclp_mask_state = sclp_mask_state_initializing;
802
803 if (calculate)
804 __sclp_get_mask(&receive_mask, &send_mask);
805 else {
806 receive_mask = 0;
807 send_mask = 0;
808 }
809 rc = -EIO;
810 for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
811
812 __sclp_make_init_req(receive_mask, send_mask);
813 spin_unlock_irqrestore(&sclp_lock, flags);
814 if (sclp_add_request(&sclp_init_req)) {
815
816 wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
817 while (time_before(jiffies, wait))
818 sclp_sync_wait();
819 spin_lock_irqsave(&sclp_lock, flags);
820 continue;
821 }
822 while (sclp_init_req.status != SCLP_REQ_DONE &&
823 sclp_init_req.status != SCLP_REQ_FAILED)
824 sclp_sync_wait();
825 spin_lock_irqsave(&sclp_lock, flags);
826 if (sclp_init_req.status == SCLP_REQ_DONE &&
827 sccb->header.response_code == 0x20) {
828
829 if (calculate) {
830 sclp_receive_mask = sccb_get_sclp_recv_mask(sccb);
831 sclp_send_mask = sccb_get_sclp_send_mask(sccb);
832 } else {
833 sclp_receive_mask = 0;
834 sclp_send_mask = 0;
835 }
836 spin_unlock_irqrestore(&sclp_lock, flags);
837 sclp_dispatch_state_change();
838 spin_lock_irqsave(&sclp_lock, flags);
839 rc = 0;
840 break;
841 }
842 }
843 sclp_mask_state = sclp_mask_state_idle;
844 spin_unlock_irqrestore(&sclp_lock, flags);
845 return rc;
846 }
847
848
849
850
851 int
852 sclp_deactivate(void)
853 {
854 unsigned long flags;
855 int rc;
856
857 spin_lock_irqsave(&sclp_lock, flags);
858
859 if (sclp_activation_state != sclp_activation_state_active) {
860 spin_unlock_irqrestore(&sclp_lock, flags);
861 return -EINVAL;
862 }
863 sclp_activation_state = sclp_activation_state_deactivating;
864 spin_unlock_irqrestore(&sclp_lock, flags);
865 rc = sclp_init_mask(0);
866 spin_lock_irqsave(&sclp_lock, flags);
867 if (rc == 0)
868 sclp_activation_state = sclp_activation_state_inactive;
869 else
870 sclp_activation_state = sclp_activation_state_active;
871 spin_unlock_irqrestore(&sclp_lock, flags);
872 return rc;
873 }
874
875 EXPORT_SYMBOL(sclp_deactivate);
876
877
878
879
880 int
881 sclp_reactivate(void)
882 {
883 unsigned long flags;
884 int rc;
885
886 spin_lock_irqsave(&sclp_lock, flags);
887
888 if (sclp_activation_state != sclp_activation_state_inactive) {
889 spin_unlock_irqrestore(&sclp_lock, flags);
890 return -EINVAL;
891 }
892 sclp_activation_state = sclp_activation_state_activating;
893 spin_unlock_irqrestore(&sclp_lock, flags);
894 rc = sclp_init_mask(1);
895 spin_lock_irqsave(&sclp_lock, flags);
896 if (rc == 0)
897 sclp_activation_state = sclp_activation_state_active;
898 else
899 sclp_activation_state = sclp_activation_state_inactive;
900 spin_unlock_irqrestore(&sclp_lock, flags);
901 return rc;
902 }
903
904 EXPORT_SYMBOL(sclp_reactivate);
905
906
907
908 static void sclp_check_handler(struct ext_code ext_code,
909 unsigned int param32, unsigned long param64)
910 {
911 u32 finished_sccb;
912
913 inc_irq_stat(IRQEXT_SCP);
914 finished_sccb = param32 & 0xfffffff8;
915
916 if (finished_sccb == 0)
917 return;
918 if (finished_sccb != (u32) (addr_t) sclp_init_sccb)
919 panic("sclp: unsolicited interrupt for buffer at 0x%x\n",
920 finished_sccb);
921 spin_lock(&sclp_lock);
922 if (sclp_running_state == sclp_running_state_running) {
923 sclp_init_req.status = SCLP_REQ_DONE;
924 sclp_running_state = sclp_running_state_idle;
925 }
926 spin_unlock(&sclp_lock);
927 }
928
929
930 static void
931 sclp_check_timeout(struct timer_list *unused)
932 {
933 unsigned long flags;
934
935 spin_lock_irqsave(&sclp_lock, flags);
936 if (sclp_running_state == sclp_running_state_running) {
937 sclp_init_req.status = SCLP_REQ_FAILED;
938 sclp_running_state = sclp_running_state_idle;
939 }
940 spin_unlock_irqrestore(&sclp_lock, flags);
941 }
942
943
944
945
946 static int
947 sclp_check_interface(void)
948 {
949 struct init_sccb *sccb;
950 unsigned long flags;
951 int retry;
952 int rc;
953
954 spin_lock_irqsave(&sclp_lock, flags);
955
956 rc = register_external_irq(EXT_IRQ_SERVICE_SIG, sclp_check_handler);
957 if (rc) {
958 spin_unlock_irqrestore(&sclp_lock, flags);
959 return rc;
960 }
961 for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
962 __sclp_make_init_req(0, 0);
963 sccb = (struct init_sccb *) sclp_init_req.sccb;
964 rc = sclp_service_call(sclp_init_req.command, sccb);
965 if (rc == -EIO)
966 break;
967 sclp_init_req.status = SCLP_REQ_RUNNING;
968 sclp_running_state = sclp_running_state_running;
969 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
970 sclp_check_timeout);
971 spin_unlock_irqrestore(&sclp_lock, flags);
972
973
974 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
975
976 sclp_sync_wait();
977
978
979 irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL);
980 spin_lock_irqsave(&sclp_lock, flags);
981 del_timer(&sclp_request_timer);
982 rc = -EBUSY;
983 if (sclp_init_req.status == SCLP_REQ_DONE) {
984 if (sccb->header.response_code == 0x20) {
985 rc = 0;
986 break;
987 } else if (sccb->header.response_code == 0x74f0) {
988 if (!sclp_mask_compat_mode) {
989 sclp_mask_compat_mode = true;
990 retry = 0;
991 }
992 }
993 }
994 }
995 unregister_external_irq(EXT_IRQ_SERVICE_SIG, sclp_check_handler);
996 spin_unlock_irqrestore(&sclp_lock, flags);
997 return rc;
998 }
999
1000
1001
1002 static int
1003 sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
1004 {
1005 sclp_deactivate();
1006 return NOTIFY_DONE;
1007 }
1008
1009 static struct notifier_block sclp_reboot_notifier = {
1010 .notifier_call = sclp_reboot_event
1011 };
1012
1013
1014
1015
1016
1017 static void sclp_pm_event(enum sclp_pm_event sclp_pm_event, int rollback)
1018 {
1019 struct sclp_register *reg;
1020 unsigned long flags;
1021
1022 if (!rollback) {
1023 spin_lock_irqsave(&sclp_lock, flags);
1024 list_for_each_entry(reg, &sclp_reg_list, list)
1025 reg->pm_event_posted = 0;
1026 spin_unlock_irqrestore(&sclp_lock, flags);
1027 }
1028 do {
1029 spin_lock_irqsave(&sclp_lock, flags);
1030 list_for_each_entry(reg, &sclp_reg_list, list) {
1031 if (rollback && reg->pm_event_posted)
1032 goto found;
1033 if (!rollback && !reg->pm_event_posted)
1034 goto found;
1035 }
1036 spin_unlock_irqrestore(&sclp_lock, flags);
1037 return;
1038 found:
1039 spin_unlock_irqrestore(&sclp_lock, flags);
1040 if (reg->pm_event_fn)
1041 reg->pm_event_fn(reg, sclp_pm_event);
1042 reg->pm_event_posted = rollback ? 0 : 1;
1043 } while (1);
1044 }
1045
1046
1047
1048
1049
1050 static int sclp_freeze(struct device *dev)
1051 {
1052 unsigned long flags;
1053 int rc;
1054
1055 sclp_pm_event(SCLP_PM_EVENT_FREEZE, 0);
1056
1057 spin_lock_irqsave(&sclp_lock, flags);
1058 sclp_suspend_state = sclp_suspend_state_suspended;
1059 spin_unlock_irqrestore(&sclp_lock, flags);
1060
1061
1062 memset(&sclp_suspend_req, 0, sizeof(sclp_suspend_req));
1063 sclp_suspend_req.callback = sclp_suspend_req_cb;
1064 sclp_suspend_req.status = SCLP_REQ_FILLED;
1065 init_completion(&sclp_request_queue_flushed);
1066
1067 rc = sclp_add_request(&sclp_suspend_req);
1068 if (rc == 0)
1069 wait_for_completion(&sclp_request_queue_flushed);
1070 else if (rc != -ENODATA)
1071 goto fail_thaw;
1072
1073 rc = sclp_deactivate();
1074 if (rc)
1075 goto fail_thaw;
1076 return 0;
1077
1078 fail_thaw:
1079 spin_lock_irqsave(&sclp_lock, flags);
1080 sclp_suspend_state = sclp_suspend_state_running;
1081 spin_unlock_irqrestore(&sclp_lock, flags);
1082 sclp_pm_event(SCLP_PM_EVENT_THAW, 1);
1083 return rc;
1084 }
1085
1086 static int sclp_undo_suspend(enum sclp_pm_event event)
1087 {
1088 unsigned long flags;
1089 int rc;
1090
1091 rc = sclp_reactivate();
1092 if (rc)
1093 return rc;
1094
1095 spin_lock_irqsave(&sclp_lock, flags);
1096 sclp_suspend_state = sclp_suspend_state_running;
1097 spin_unlock_irqrestore(&sclp_lock, flags);
1098
1099 sclp_pm_event(event, 0);
1100 return 0;
1101 }
1102
1103 static int sclp_thaw(struct device *dev)
1104 {
1105 return sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1106 }
1107
1108 static int sclp_restore(struct device *dev)
1109 {
1110 return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
1111 }
1112
1113 static const struct dev_pm_ops sclp_pm_ops = {
1114 .freeze = sclp_freeze,
1115 .thaw = sclp_thaw,
1116 .restore = sclp_restore,
1117 };
1118
1119 static ssize_t con_pages_show(struct device_driver *dev, char *buf)
1120 {
1121 return sprintf(buf, "%i\n", sclp_console_pages);
1122 }
1123
1124 static DRIVER_ATTR_RO(con_pages);
1125
1126 static ssize_t con_drop_show(struct device_driver *dev, char *buf)
1127 {
1128 return sprintf(buf, "%i\n", sclp_console_drop);
1129 }
1130
1131 static DRIVER_ATTR_RO(con_drop);
1132
1133 static ssize_t con_full_show(struct device_driver *dev, char *buf)
1134 {
1135 return sprintf(buf, "%lu\n", sclp_console_full);
1136 }
1137
1138 static DRIVER_ATTR_RO(con_full);
1139
1140 static struct attribute *sclp_drv_attrs[] = {
1141 &driver_attr_con_pages.attr,
1142 &driver_attr_con_drop.attr,
1143 &driver_attr_con_full.attr,
1144 NULL,
1145 };
1146 static struct attribute_group sclp_drv_attr_group = {
1147 .attrs = sclp_drv_attrs,
1148 };
1149 static const struct attribute_group *sclp_drv_attr_groups[] = {
1150 &sclp_drv_attr_group,
1151 NULL,
1152 };
1153
1154 static struct platform_driver sclp_pdrv = {
1155 .driver = {
1156 .name = "sclp",
1157 .pm = &sclp_pm_ops,
1158 .groups = sclp_drv_attr_groups,
1159 },
1160 };
1161
1162 static struct platform_device *sclp_pdev;
1163
1164
1165
1166 static int
1167 sclp_init(void)
1168 {
1169 unsigned long flags;
1170 int rc = 0;
1171
1172 spin_lock_irqsave(&sclp_lock, flags);
1173
1174 if (sclp_init_state != sclp_init_state_uninitialized)
1175 goto fail_unlock;
1176 sclp_init_state = sclp_init_state_initializing;
1177 sclp_read_sccb = (void *) __get_free_page(GFP_ATOMIC | GFP_DMA);
1178 sclp_init_sccb = (void *) __get_free_page(GFP_ATOMIC | GFP_DMA);
1179 BUG_ON(!sclp_read_sccb || !sclp_init_sccb);
1180
1181 INIT_LIST_HEAD(&sclp_req_queue);
1182 INIT_LIST_HEAD(&sclp_reg_list);
1183 list_add(&sclp_state_change_event.list, &sclp_reg_list);
1184 timer_setup(&sclp_request_timer, NULL, 0);
1185 timer_setup(&sclp_queue_timer, sclp_req_queue_timeout, 0);
1186
1187 spin_unlock_irqrestore(&sclp_lock, flags);
1188 rc = sclp_check_interface();
1189 spin_lock_irqsave(&sclp_lock, flags);
1190 if (rc)
1191 goto fail_init_state_uninitialized;
1192
1193 rc = register_reboot_notifier(&sclp_reboot_notifier);
1194 if (rc)
1195 goto fail_init_state_uninitialized;
1196
1197 rc = register_external_irq(EXT_IRQ_SERVICE_SIG, sclp_interrupt_handler);
1198 if (rc)
1199 goto fail_unregister_reboot_notifier;
1200 sclp_init_state = sclp_init_state_initialized;
1201 spin_unlock_irqrestore(&sclp_lock, flags);
1202
1203
1204 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
1205 sclp_init_mask(1);
1206 return 0;
1207
1208 fail_unregister_reboot_notifier:
1209 unregister_reboot_notifier(&sclp_reboot_notifier);
1210 fail_init_state_uninitialized:
1211 sclp_init_state = sclp_init_state_uninitialized;
1212 free_page((unsigned long) sclp_read_sccb);
1213 free_page((unsigned long) sclp_init_sccb);
1214 fail_unlock:
1215 spin_unlock_irqrestore(&sclp_lock, flags);
1216 return rc;
1217 }
1218
1219
1220
1221
1222
1223 static int sclp_panic_notify(struct notifier_block *self,
1224 unsigned long event, void *data)
1225 {
1226 if (sclp_suspend_state == sclp_suspend_state_suspended)
1227 sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1228 return NOTIFY_OK;
1229 }
1230
1231 static struct notifier_block sclp_on_panic_nb = {
1232 .notifier_call = sclp_panic_notify,
1233 .priority = SCLP_PANIC_PRIO,
1234 };
1235
1236 static __init int sclp_initcall(void)
1237 {
1238 int rc;
1239
1240 rc = platform_driver_register(&sclp_pdrv);
1241 if (rc)
1242 return rc;
1243
1244 sclp_pdev = platform_device_register_simple("sclp", -1, NULL, 0);
1245 rc = PTR_ERR_OR_ZERO(sclp_pdev);
1246 if (rc)
1247 goto fail_platform_driver_unregister;
1248
1249 rc = atomic_notifier_chain_register(&panic_notifier_list,
1250 &sclp_on_panic_nb);
1251 if (rc)
1252 goto fail_platform_device_unregister;
1253
1254 return sclp_init();
1255
1256 fail_platform_device_unregister:
1257 platform_device_unregister(sclp_pdev);
1258 fail_platform_driver_unregister:
1259 platform_driver_unregister(&sclp_pdrv);
1260 return rc;
1261 }
1262
1263 arch_initcall(sclp_initcall);