1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * core function to access sclp interface
4 *
5 * Copyright IBM Corp. 1999, 2009
6 *
7 * Author(s): Martin Peschke <mpeschke@de.ibm.com>
8 * Martin Schwidefsky <schwidefsky@de.ibm.com>
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 /* Lock to protect internal data consistency. */
31 static DEFINE_SPINLOCK(sclp_lock);
32
33 /* Mask of events that we can send to the sclp interface. */
34 static sccb_mask_t sclp_receive_mask;
35
36 /* Mask of events that we can receive from the sclp interface. */
37 static sccb_mask_t sclp_send_mask;
38
39 /* List of registered event listeners and senders. */
40 static struct list_head sclp_reg_list;
41
42 /* List of queued requests. */
43 static struct list_head sclp_req_queue;
44
45 /* Data for read and and init requests. */
46 static struct sclp_req sclp_read_req;
47 static struct sclp_req sclp_init_req;
48 static char sclp_read_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
49 static char sclp_init_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
50
51 /* Suspend request */
52 static DECLARE_COMPLETION(sclp_request_queue_flushed);
53
54 /* Number of console pages to allocate, used by sclp_con.c and sclp_vt220.c */
55 int sclp_console_pages = SCLP_CONSOLE_PAGES;
56 /* Flag to indicate if buffer pages are dropped on buffer full condition */
57 int sclp_console_drop = 1;
58 /* Number of times the console dropped buffer pages */
59 unsigned long sclp_console_full;
60
sclp_suspend_req_cb(struct sclp_req * req,void * data)61 static void sclp_suspend_req_cb(struct sclp_req *req, void *data)
62 {
63 complete(&sclp_request_queue_flushed);
64 }
65
sclp_setup_console_pages(char * str)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
sclp_setup_console_drop(char * str)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 /* Timer for request retries. */
93 static struct timer_list sclp_request_timer;
94
95 /* Timer for queued requests. */
96 static struct timer_list sclp_queue_timer;
97
98 /* Internal state: is a request active at the sclp? */
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 /* Internal state: is a read request pending? */
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 /* Internal state: is the driver currently serving requests? */
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 /* Internal state: is an init mask request pending? */
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 /* Internal state: is the driver suspended? */
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 /* Maximum retry counts */
132 #define SCLP_INIT_RETRY 3
133 #define SCLP_MASK_RETRY 3
134
135 /* Timeout intervals in seconds.*/
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
__sclp_queue_read_req(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 /* Add request to head of queue */
152 list_add(&sclp_read_req.list, &sclp_req_queue);
153 }
154 }
155
156 /* Set up request retry timer. Called while sclp_lock is locked. */
157 static inline void
__sclp_set_request_timer(unsigned long time,void (* cb)(struct timer_list *))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
sclp_request_timeout_restart(struct timer_list * unused)166 static void sclp_request_timeout_restart(struct timer_list *unused)
167 {
168 sclp_request_timeout(true);
169 }
170
sclp_request_timeout_normal(struct timer_list * unused)171 static void sclp_request_timeout_normal(struct timer_list *unused)
172 {
173 sclp_request_timeout(false);
174 }
175
176 /* Request timeout handler. Restart the request queue. If force_restart,
177 * force restart of running request. */
sclp_request_timeout(bool force_restart)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 /* Break running state and queue NOP read event request
186 * to get a defined interface state. */
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 * Returns the expire value in jiffies of the next pending request timeout,
200 * if any. Needs to be called with sclp_lock.
201 */
__sclp_req_queue_find_next_timeout(void)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 * Returns expired request, if any, and removes it from the list.
219 */
__sclp_req_queue_remove_expired_req(void)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 /* Don't need list_for_each_safe because we break out after list_del */
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 * Timeout handler for queued requests. Removes request from list and
247 * invokes callback. This timer can be set per request in situations where
248 * waiting too long would be harmful to the system, e.g. during SE reboot.
249 */
sclp_req_queue_timeout(struct timer_list * unused)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 /* Try to start a request. Return zero if the request was successfully
269 * started or if it will be started at a later time. Return non-zero otherwise.
270 * Called while sclp_lock is locked. */
271 static int
__sclp_start_request(struct sclp_req * req)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 /* Successfully started request */
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 /* Try again later */
291 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
292 sclp_request_timeout_normal);
293 return 0;
294 }
295 /* Request failed */
296 req->status = SCLP_REQ_FAILED;
297 return rc;
298 }
299
300 /* Try to start queued requests. */
301 static void
sclp_process_queue(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 /* Request failed */
322 if (req->start_count > 1) {
323 /* Cannot abort already submitted request - could still
324 * be active at the SCLP */
325 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
326 sclp_request_timeout_normal);
327 break;
328 }
329 do_post:
330 /* Post-processing for aborted request */
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
__sclp_can_add_request(struct sclp_req * req)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 /* Queue a new request. Return zero on success, non-zero otherwise. */
355 int
sclp_add_request(struct sclp_req * req)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 /* Start if request is first in list */
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 /* Dispatch events found in request buffer to registered listeners. Return 0
397 * if all events were dispatched, non-zero otherwise. */
398 static int
sclp_dispatch_evbufs(struct sccb_header * sccb)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 /* Check for malformed hardware response */
414 if (evbuf->length == 0)
415 break;
416 /* Search for event handler */
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 /* Read event data request callback. */
437 static void
sclp_read_cb(struct sclp_req * req,void * data)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 /* Prepare read event data request. Called while sclp_lock is locked. */
__sclp_make_read_req(void)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 /* Search request list for request with matching sccb. Return request if found,
471 * NULL otherwise. Called while sclp_lock is locked. */
472 static inline struct sclp_req *
__sclp_find_req(u32 sccb)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 /* Handler for external interruption. Perform request post-processing.
487 * Prepare read event data request if necessary. Start processing of next
488 * request on queue. */
sclp_interrupt_handler(struct ext_code ext_code,unsigned int param32,unsigned long param64)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 /* Request post-processing */
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 /* Convert interval in jiffies to TOD ticks. */
524 static inline u64
sclp_tod_from_jiffies(unsigned long jiffies)525 sclp_tod_from_jiffies(unsigned long jiffies)
526 {
527 return (u64) (jiffies / HZ) << 32;
528 }
529
530 /* Wait until a currently running request finished. Note: while this function
531 * is running, no timers are served on the calling CPU. */
532 void
sclp_sync_wait(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 /* We'll be disabling timer interrupts, so we need a custom timeout
542 * mechanism */
543 timeout = 0;
544 if (timer_pending(&sclp_request_timer)) {
545 /* Get timeout TOD value */
546 timeout = get_tod_clock_fast() +
547 sclp_tod_from_jiffies(sclp_request_timer.expires -
548 jiffies);
549 }
550 local_irq_save(flags);
551 /* Prevent bottom half from executing once we force interrupts open */
552 irq_context = in_interrupt();
553 if (!irq_context)
554 local_bh_disable();
555 /* Enable service-signal interruption, disable timer interrupts */
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 /* Loop until driver state indicates finished request */
564 while (sclp_running_state != sclp_running_state_idle) {
565 /* Check for expired request timer */
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 /* Dispatch changes in send and receive mask to registered listeners. */
582 static void
sclp_dispatch_state_change(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]; /* variable length */
622 /*
623 * u8 sclp_receive_mask[mask_length];
624 * u8 sclp_send_mask[mask_length];
625 * u32 read_data_function_mask;
626 */
627 } __attribute__((packed));
628
629
630 /* State change event callback. Inform listeners of changes. */
631 static void
sclp_state_change_cb(struct evbuf_header * evbuf)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 /* Calculate receive and send mask of currently registered listeners.
657 * Called while sclp_lock is locked. */
658 static inline void
__sclp_get_mask(sccb_mask_t * receive_mask,sccb_mask_t * send_mask)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 /* Register event listener. Return 0 on success, non-zero otherwise. */
674 int
sclp_register(struct sclp_register * reg)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 /* Check event mask for collisions */
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 /* Trigger initial state change callback */
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 /* Unregister event listener. */
710 void
sclp_unregister(struct sclp_register * reg)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 /* Remove event buffers which are marked processed. Return the number of
724 * remaining event buffers. */
725 int
sclp_remove_processed(struct sccb_header * sccb)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 /* Prepare init mask request. Called while sclp_lock is locked. */
753 static inline void
__sclp_make_init_req(sccb_mask_t receive_mask,sccb_mask_t send_mask)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 /* Start init mask request. If calculate is non-zero, calculate the mask as
779 * requested by registered listeners. Use zero mask otherwise. Return 0 on
780 * success, non-zero otherwise. */
781 static int
sclp_init_mask(int calculate)782 sclp_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 /* Check if interface is in appropriate state */
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 /* Determine mask */
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 /* Prepare request */
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 /* Try again later */
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 /* Successful request */
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 /* Deactivate SCLP interface. On success, new requests will be rejected,
850 * events will no longer be dispatched. Return 0 on success, non-zero
851 * otherwise. */
852 int
sclp_deactivate(void)853 sclp_deactivate(void)
854 {
855 unsigned long flags;
856 int rc;
857
858 spin_lock_irqsave(&sclp_lock, flags);
859 /* Deactivate can only be called when active */
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
876 EXPORT_SYMBOL(sclp_deactivate);
877
878 /* Reactivate SCLP interface after sclp_deactivate. On success, new
879 * requests will be accepted, events will be dispatched again. Return 0 on
880 * success, non-zero otherwise. */
881 int
sclp_reactivate(void)882 sclp_reactivate(void)
883 {
884 unsigned long flags;
885 int rc;
886
887 spin_lock_irqsave(&sclp_lock, flags);
888 /* Reactivate can only be called when inactive */
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
905 EXPORT_SYMBOL(sclp_reactivate);
906
907 /* Handler for external interruption used during initialization. Modify
908 * request state to done. */
sclp_check_handler(struct ext_code ext_code,unsigned int param32,unsigned long param64)909 static 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 /* Is this the interrupt we are waiting for? */
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 /* Initial init mask request timed out. Modify request state to failed. */
931 static void
sclp_check_timeout(struct timer_list * unused)932 sclp_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 /* Perform a check of the SCLP interface. Return zero if the interface is
945 * available and there are no pending requests from a previous instance.
946 * Return non-zero otherwise. */
947 static int
sclp_check_interface(void)948 sclp_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 /* Prepare init mask command */
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 /* Enable service-signal interruption - needs to happen
974 * with IRQs enabled. */
975 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
976 /* Wait for signal from interrupt or timeout */
977 sclp_sync_wait();
978 /* Disable service-signal interruption - needs to happen
979 * with IRQs enabled. */
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 /* Reboot event handler. Reset send and receive mask to prevent pending SCLP
1002 * events from interfering with rebooted system. */
1003 static int
sclp_reboot_event(struct notifier_block * this,unsigned long event,void * ptr)1004 sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
1005 {
1006 sclp_deactivate();
1007 return NOTIFY_DONE;
1008 }
1009
1010 static struct notifier_block sclp_reboot_notifier = {
1011 .notifier_call = sclp_reboot_event
1012 };
1013
1014 /*
1015 * Suspend/resume SCLP notifier implementation
1016 */
1017
sclp_pm_event(enum sclp_pm_event sclp_pm_event,int rollback)1018 static 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;
1039 found:
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 * Susend/resume callbacks for platform device
1049 */
1050
sclp_freeze(struct device * dev)1051 static 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 /* Init supend data */
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
1079 fail_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
sclp_undo_suspend(enum sclp_pm_event event)1087 static 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
sclp_thaw(struct device * dev)1104 static int sclp_thaw(struct device *dev)
1105 {
1106 return sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1107 }
1108
sclp_restore(struct device * dev)1109 static int sclp_restore(struct device *dev)
1110 {
1111 return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
1112 }
1113
1114 static const struct dev_pm_ops sclp_pm_ops = {
1115 .freeze = sclp_freeze,
1116 .thaw = sclp_thaw,
1117 .restore = sclp_restore,
1118 };
1119
con_pages_show(struct device_driver * dev,char * buf)1120 static ssize_t con_pages_show(struct device_driver *dev, char *buf)
1121 {
1122 return sprintf(buf, "%i\n", sclp_console_pages);
1123 }
1124
1125 static DRIVER_ATTR_RO(con_pages);
1126
con_drop_show(struct device_driver * dev,char * buf)1127 static ssize_t con_drop_show(struct device_driver *dev, char *buf)
1128 {
1129 return sprintf(buf, "%i\n", sclp_console_drop);
1130 }
1131
1132 static DRIVER_ATTR_RO(con_drop);
1133
con_full_show(struct device_driver * dev,char * buf)1134 static ssize_t con_full_show(struct device_driver *dev, char *buf)
1135 {
1136 return sprintf(buf, "%lu\n", sclp_console_full);
1137 }
1138
1139 static DRIVER_ATTR_RO(con_full);
1140
1141 static 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 };
1147 static struct attribute_group sclp_drv_attr_group = {
1148 .attrs = sclp_drv_attrs,
1149 };
1150 static const struct attribute_group *sclp_drv_attr_groups[] = {
1151 &sclp_drv_attr_group,
1152 NULL,
1153 };
1154
1155 static struct platform_driver sclp_pdrv = {
1156 .driver = {
1157 .name = "sclp",
1158 .pm = &sclp_pm_ops,
1159 .groups = sclp_drv_attr_groups,
1160 },
1161 };
1162
1163 static struct platform_device *sclp_pdev;
1164
1165 /* Initialize SCLP driver. Return zero if driver is operational, non-zero
1166 * otherwise. */
1167 static int
sclp_init(void)1168 sclp_init(void)
1169 {
1170 unsigned long flags;
1171 int rc = 0;
1172
1173 spin_lock_irqsave(&sclp_lock, flags);
1174 /* Check for previous or running initialization */
1175 if (sclp_init_state != sclp_init_state_uninitialized)
1176 goto fail_unlock;
1177 sclp_init_state = sclp_init_state_initializing;
1178 /* Set up variables */
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 /* Check interface */
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 /* Register reboot handler */
1191 rc = register_reboot_notifier(&sclp_reboot_notifier);
1192 if (rc)
1193 goto fail_init_state_uninitialized;
1194 /* Register interrupt handler */
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 /* Enable service-signal external interruption - needs to happen with
1201 * IRQs enabled. */
1202 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
1203 sclp_init_mask(1);
1204 return 0;
1205
1206 fail_unregister_reboot_notifier:
1207 unregister_reboot_notifier(&sclp_reboot_notifier);
1208 fail_init_state_uninitialized:
1209 sclp_init_state = sclp_init_state_uninitialized;
1210 fail_unlock:
1211 spin_unlock_irqrestore(&sclp_lock, flags);
1212 return rc;
1213 }
1214
1215 /*
1216 * SCLP panic notifier: If we are suspended, we thaw SCLP in order to be able
1217 * to print the panic message.
1218 */
sclp_panic_notify(struct notifier_block * self,unsigned long event,void * data)1219 static 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
1227 static struct notifier_block sclp_on_panic_nb = {
1228 .notifier_call = sclp_panic_notify,
1229 .priority = SCLP_PANIC_PRIO,
1230 };
1231
sclp_initcall(void)1232 static __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
1252 fail_platform_device_unregister:
1253 platform_device_unregister(sclp_pdev);
1254 fail_platform_driver_unregister:
1255 platform_driver_unregister(&sclp_pdrv);
1256 return rc;
1257 }
1258
1259 arch_initcall(sclp_initcall);
1260