xref: /kernel/linux/linux-5.10/drivers/s390/char/sclp.c (revision 8c2ecf20)
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. */
31static DEFINE_SPINLOCK(sclp_lock);
32
33/* Mask of events that we can send to the sclp interface. */
34static sccb_mask_t sclp_receive_mask;
35
36/* Mask of events that we can receive from the sclp interface. */
37static sccb_mask_t sclp_send_mask;
38
39/* List of registered event listeners and senders. */
40static struct list_head sclp_reg_list;
41
42/* List of queued requests. */
43static struct list_head sclp_req_queue;
44
45/* Data for read and and init requests. */
46static struct sclp_req sclp_read_req;
47static struct sclp_req sclp_init_req;
48static void *sclp_read_sccb;
49static struct init_sccb *sclp_init_sccb;
50
51/* Suspend request */
52static DECLARE_COMPLETION(sclp_request_queue_flushed);
53
54/* Number of console pages to allocate, used by sclp_con.c and sclp_vt220.c */
55int sclp_console_pages = SCLP_CONSOLE_PAGES;
56/* Flag to indicate if buffer pages are dropped on buffer full condition */
57int sclp_console_drop = 1;
58/* Number of times the console dropped buffer pages */
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/* Timer for request retries. */
93static struct timer_list sclp_request_timer;
94
95/* Timer for queued requests. */
96static struct timer_list sclp_queue_timer;
97
98/* Internal state: is a request active at the sclp? */
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/* Internal state: is a read request pending? */
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/* Internal state: is the driver currently serving requests? */
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/* Internal state: is an init mask request pending? */
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/* Internal state: is the driver suspended? */
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/* 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
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		/* 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. */
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/* Request timeout handler. Restart the request queue. If force_restart,
177 * force restart of running request. */
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			/* 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 */
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 * Returns expired request, if any, and removes it from the list.
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	/* 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;
240out:
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 */
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/* 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. */
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		/* 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. */
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		/* 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		}
329do_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
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/* Queue a new request. Return zero on success, non-zero otherwise. */
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	/* 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	}
389out:
390	spin_unlock_irqrestore(&sclp_lock, flags);
391	return rc;
392}
393
394EXPORT_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. */
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		/* 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. */
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/* Prepare read event data request. Called while sclp_lock is locked. */
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/* Search request list for request with matching sccb. Return request if found,
471 * NULL otherwise. Called while sclp_lock is locked. */
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/* Handler for external interruption. Perform request post-processing.
487 * Prepare read event data request if necessary. Start processing of next
488 * request on queue. */
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			/* 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. */
524static inline u64
525sclp_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. */
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	/* 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}
579EXPORT_SYMBOL(sclp_sync_wait);
580
581/* Dispatch changes in send and receive mask to registered listeners. */
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];	/* 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. */
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/* Calculate receive and send mask of currently registered listeners.
657 * Called while sclp_lock is locked. */
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/* Register event listener. Return 0 on success, non-zero otherwise. */
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	/* 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(&reg->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(&reg->list);
702		spin_unlock_irqrestore(&sclp_lock, flags);
703	}
704	return rc;
705}
706
707EXPORT_SYMBOL(sclp_register);
708
709/* Unregister event listener. */
710void
711sclp_unregister(struct sclp_register *reg)
712{
713	unsigned long flags;
714
715	spin_lock_irqsave(&sclp_lock, flags);
716	list_del(&reg->list);
717	spin_unlock_irqrestore(&sclp_lock, flags);
718	sclp_init_mask(1);
719}
720
721EXPORT_SYMBOL(sclp_unregister);
722
723/* Remove event buffers which are marked processed. Return the number of
724 * remaining event buffers. */
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/* Prepare init mask request. Called while sclp_lock is locked. */
753static 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/* Start init mask request. If calculate is non-zero, calculate the mask as
778 * requested by registered listeners. Use zero mask otherwise. Return 0 on
779 * success, non-zero otherwise. */
780static int
781sclp_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	/* Check if interface is in appropriate state */
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	/* Determine mask */
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		/* Prepare request */
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			/* Try again later */
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			/* Successful request */
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/* Deactivate SCLP interface. On success, new requests will be rejected,
849 * events will no longer be dispatched. Return 0 on success, non-zero
850 * otherwise. */
851int
852sclp_deactivate(void)
853{
854	unsigned long flags;
855	int rc;
856
857	spin_lock_irqsave(&sclp_lock, flags);
858	/* Deactivate can only be called when active */
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
875EXPORT_SYMBOL(sclp_deactivate);
876
877/* Reactivate SCLP interface after sclp_deactivate. On success, new
878 * requests will be accepted, events will be dispatched again. Return 0 on
879 * success, non-zero otherwise. */
880int
881sclp_reactivate(void)
882{
883	unsigned long flags;
884	int rc;
885
886	spin_lock_irqsave(&sclp_lock, flags);
887	/* Reactivate can only be called when inactive */
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
904EXPORT_SYMBOL(sclp_reactivate);
905
906/* Handler for external interruption used during initialization. Modify
907 * request state to done. */
908static 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	/* Is this the interrupt we are waiting for? */
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/* Initial init mask request timed out. Modify request state to failed. */
930static void
931sclp_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/* Perform a check of the SCLP interface. Return zero if the interface is
944 * available and there are no pending requests from a previous instance.
945 * Return non-zero otherwise. */
946static int
947sclp_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	/* Prepare init mask command */
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		/* Enable service-signal interruption - needs to happen
973		 * with IRQs enabled. */
974		irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
975		/* Wait for signal from interrupt or timeout */
976		sclp_sync_wait();
977		/* Disable service-signal interruption - needs to happen
978		 * with IRQs enabled. */
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/* Reboot event handler. Reset send and receive mask to prevent pending SCLP
1001 * events from interfering with rebooted system. */
1002static int
1003sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
1004{
1005	sclp_deactivate();
1006	return NOTIFY_DONE;
1007}
1008
1009static struct notifier_block sclp_reboot_notifier = {
1010	.notifier_call = sclp_reboot_event
1011};
1012
1013/*
1014 * Suspend/resume SCLP notifier implementation
1015 */
1016
1017static 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;
1038found:
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 * Susend/resume callbacks for platform device
1048 */
1049
1050static 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	/* Init supend data */
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
1078fail_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
1086static 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
1103static int sclp_thaw(struct device *dev)
1104{
1105	return sclp_undo_suspend(SCLP_PM_EVENT_THAW);
1106}
1107
1108static int sclp_restore(struct device *dev)
1109{
1110	return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
1111}
1112
1113static const struct dev_pm_ops sclp_pm_ops = {
1114	.freeze		= sclp_freeze,
1115	.thaw		= sclp_thaw,
1116	.restore	= sclp_restore,
1117};
1118
1119static ssize_t con_pages_show(struct device_driver *dev, char *buf)
1120{
1121	return sprintf(buf, "%i\n", sclp_console_pages);
1122}
1123
1124static DRIVER_ATTR_RO(con_pages);
1125
1126static ssize_t con_drop_show(struct device_driver *dev, char *buf)
1127{
1128	return sprintf(buf, "%i\n", sclp_console_drop);
1129}
1130
1131static DRIVER_ATTR_RO(con_drop);
1132
1133static ssize_t con_full_show(struct device_driver *dev, char *buf)
1134{
1135	return sprintf(buf, "%lu\n", sclp_console_full);
1136}
1137
1138static DRIVER_ATTR_RO(con_full);
1139
1140static 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};
1146static struct attribute_group sclp_drv_attr_group = {
1147	.attrs = sclp_drv_attrs,
1148};
1149static const struct attribute_group *sclp_drv_attr_groups[] = {
1150	&sclp_drv_attr_group,
1151	NULL,
1152};
1153
1154static struct platform_driver sclp_pdrv = {
1155	.driver = {
1156		.name	= "sclp",
1157		.pm	= &sclp_pm_ops,
1158		.groups = sclp_drv_attr_groups,
1159	},
1160};
1161
1162static struct platform_device *sclp_pdev;
1163
1164/* Initialize SCLP driver. Return zero if driver is operational, non-zero
1165 * otherwise. */
1166static int
1167sclp_init(void)
1168{
1169	unsigned long flags;
1170	int rc = 0;
1171
1172	spin_lock_irqsave(&sclp_lock, flags);
1173	/* Check for previous or running initialization */
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	/* Set up variables */
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	/* Check interface */
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	/* Register reboot handler */
1193	rc = register_reboot_notifier(&sclp_reboot_notifier);
1194	if (rc)
1195		goto fail_init_state_uninitialized;
1196	/* Register interrupt handler */
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	/* Enable service-signal external interruption - needs to happen with
1203	 * IRQs enabled. */
1204	irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
1205	sclp_init_mask(1);
1206	return 0;
1207
1208fail_unregister_reboot_notifier:
1209	unregister_reboot_notifier(&sclp_reboot_notifier);
1210fail_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);
1214fail_unlock:
1215	spin_unlock_irqrestore(&sclp_lock, flags);
1216	return rc;
1217}
1218
1219/*
1220 * SCLP panic notifier: If we are suspended, we thaw SCLP in order to be able
1221 * to print the panic message.
1222 */
1223static 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
1231static struct notifier_block sclp_on_panic_nb = {
1232	.notifier_call = sclp_panic_notify,
1233	.priority = SCLP_PANIC_PRIO,
1234};
1235
1236static __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
1256fail_platform_device_unregister:
1257	platform_device_unregister(sclp_pdev);
1258fail_platform_driver_unregister:
1259	platform_driver_unregister(&sclp_pdrv);
1260	return rc;
1261}
1262
1263arch_initcall(sclp_initcall);
1264