xref: /openbmc/linux/drivers/s390/cio/eadm_sch.c (revision e23feb16)
1 /*
2  * Driver for s390 eadm subchannels
3  *
4  * Copyright IBM Corp. 2012
5  * Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com>
6  */
7 
8 #include <linux/kernel_stat.h>
9 #include <linux/workqueue.h>
10 #include <linux/spinlock.h>
11 #include <linux/device.h>
12 #include <linux/module.h>
13 #include <linux/timer.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 
17 #include <asm/css_chars.h>
18 #include <asm/debug.h>
19 #include <asm/isc.h>
20 #include <asm/cio.h>
21 #include <asm/scsw.h>
22 #include <asm/eadm.h>
23 
24 #include "eadm_sch.h"
25 #include "ioasm.h"
26 #include "cio.h"
27 #include "css.h"
28 #include "orb.h"
29 
30 MODULE_DESCRIPTION("driver for s390 eadm subchannels");
31 MODULE_LICENSE("GPL");
32 
33 #define EADM_TIMEOUT (5 * HZ)
34 static DEFINE_SPINLOCK(list_lock);
35 static LIST_HEAD(eadm_list);
36 
37 static debug_info_t *eadm_debug;
38 
39 #define EADM_LOG(imp, txt) do {					\
40 		debug_text_event(eadm_debug, imp, txt);		\
41 	} while (0)
42 
43 static void EADM_LOG_HEX(int level, void *data, int length)
44 {
45 	if (level > eadm_debug->level)
46 		return;
47 	while (length > 0) {
48 		debug_event(eadm_debug, level, data, length);
49 		length -= eadm_debug->buf_size;
50 		data += eadm_debug->buf_size;
51 	}
52 }
53 
54 static void orb_init(union orb *orb)
55 {
56 	memset(orb, 0, sizeof(union orb));
57 	orb->eadm.compat1 = 1;
58 	orb->eadm.compat2 = 1;
59 	orb->eadm.fmt = 1;
60 	orb->eadm.x = 1;
61 }
62 
63 static int eadm_subchannel_start(struct subchannel *sch, struct aob *aob)
64 {
65 	union orb *orb = &get_eadm_private(sch)->orb;
66 	int cc;
67 
68 	orb_init(orb);
69 	orb->eadm.aob = (u32)__pa(aob);
70 	orb->eadm.intparm = (u32)(addr_t)sch;
71 	orb->eadm.key = PAGE_DEFAULT_KEY >> 4;
72 
73 	EADM_LOG(6, "start");
74 	EADM_LOG_HEX(6, &sch->schid, sizeof(sch->schid));
75 
76 	cc = ssch(sch->schid, orb);
77 	switch (cc) {
78 	case 0:
79 		sch->schib.scsw.eadm.actl |= SCSW_ACTL_START_PEND;
80 		break;
81 	case 1:		/* status pending */
82 	case 2:		/* busy */
83 		return -EBUSY;
84 	case 3:		/* not operational */
85 		return -ENODEV;
86 	}
87 	return 0;
88 }
89 
90 static int eadm_subchannel_clear(struct subchannel *sch)
91 {
92 	int cc;
93 
94 	cc = csch(sch->schid);
95 	if (cc)
96 		return -ENODEV;
97 
98 	sch->schib.scsw.eadm.actl |= SCSW_ACTL_CLEAR_PEND;
99 	return 0;
100 }
101 
102 static void eadm_subchannel_timeout(unsigned long data)
103 {
104 	struct subchannel *sch = (struct subchannel *) data;
105 
106 	spin_lock_irq(sch->lock);
107 	EADM_LOG(1, "timeout");
108 	EADM_LOG_HEX(1, &sch->schid, sizeof(sch->schid));
109 	if (eadm_subchannel_clear(sch))
110 		EADM_LOG(0, "clear failed");
111 	spin_unlock_irq(sch->lock);
112 }
113 
114 static void eadm_subchannel_set_timeout(struct subchannel *sch, int expires)
115 {
116 	struct eadm_private *private = get_eadm_private(sch);
117 
118 	if (expires == 0) {
119 		del_timer(&private->timer);
120 		return;
121 	}
122 	if (timer_pending(&private->timer)) {
123 		if (mod_timer(&private->timer, jiffies + expires))
124 			return;
125 	}
126 	private->timer.function = eadm_subchannel_timeout;
127 	private->timer.data = (unsigned long) sch;
128 	private->timer.expires = jiffies + expires;
129 	add_timer(&private->timer);
130 }
131 
132 static void eadm_subchannel_irq(struct subchannel *sch)
133 {
134 	struct eadm_private *private = get_eadm_private(sch);
135 	struct eadm_scsw *scsw = &sch->schib.scsw.eadm;
136 	struct irb *irb = (struct irb *)&S390_lowcore.irb;
137 	int error = 0;
138 
139 	EADM_LOG(6, "irq");
140 	EADM_LOG_HEX(6, irb, sizeof(*irb));
141 
142 	inc_irq_stat(IRQIO_ADM);
143 
144 	if ((scsw->stctl & (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))
145 	    && scsw->eswf == 1 && irb->esw.eadm.erw.r)
146 		error = -EIO;
147 
148 	if (scsw->fctl & SCSW_FCTL_CLEAR_FUNC)
149 		error = -ETIMEDOUT;
150 
151 	eadm_subchannel_set_timeout(sch, 0);
152 
153 	if (private->state != EADM_BUSY) {
154 		EADM_LOG(1, "irq unsol");
155 		EADM_LOG_HEX(1, irb, sizeof(*irb));
156 		private->state = EADM_NOT_OPER;
157 		css_sched_sch_todo(sch, SCH_TODO_EVAL);
158 		return;
159 	}
160 	scm_irq_handler((struct aob *)(unsigned long)scsw->aob, error);
161 	private->state = EADM_IDLE;
162 }
163 
164 static struct subchannel *eadm_get_idle_sch(void)
165 {
166 	struct eadm_private *private;
167 	struct subchannel *sch;
168 	unsigned long flags;
169 
170 	spin_lock_irqsave(&list_lock, flags);
171 	list_for_each_entry(private, &eadm_list, head) {
172 		sch = private->sch;
173 		spin_lock(sch->lock);
174 		if (private->state == EADM_IDLE) {
175 			private->state = EADM_BUSY;
176 			list_move_tail(&private->head, &eadm_list);
177 			spin_unlock(sch->lock);
178 			spin_unlock_irqrestore(&list_lock, flags);
179 
180 			return sch;
181 		}
182 		spin_unlock(sch->lock);
183 	}
184 	spin_unlock_irqrestore(&list_lock, flags);
185 
186 	return NULL;
187 }
188 
189 static int eadm_start_aob(struct aob *aob)
190 {
191 	struct eadm_private *private;
192 	struct subchannel *sch;
193 	unsigned long flags;
194 	int ret;
195 
196 	sch = eadm_get_idle_sch();
197 	if (!sch)
198 		return -EBUSY;
199 
200 	spin_lock_irqsave(sch->lock, flags);
201 	eadm_subchannel_set_timeout(sch, EADM_TIMEOUT);
202 	ret = eadm_subchannel_start(sch, aob);
203 	if (!ret)
204 		goto out_unlock;
205 
206 	/* Handle start subchannel failure. */
207 	eadm_subchannel_set_timeout(sch, 0);
208 	private = get_eadm_private(sch);
209 	private->state = EADM_NOT_OPER;
210 	css_sched_sch_todo(sch, SCH_TODO_EVAL);
211 
212 out_unlock:
213 	spin_unlock_irqrestore(sch->lock, flags);
214 
215 	return ret;
216 }
217 
218 static int eadm_subchannel_probe(struct subchannel *sch)
219 {
220 	struct eadm_private *private;
221 	int ret;
222 
223 	private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
224 	if (!private)
225 		return -ENOMEM;
226 
227 	INIT_LIST_HEAD(&private->head);
228 	init_timer(&private->timer);
229 
230 	spin_lock_irq(sch->lock);
231 	set_eadm_private(sch, private);
232 	private->state = EADM_IDLE;
233 	private->sch = sch;
234 	sch->isc = EADM_SCH_ISC;
235 	ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
236 	if (ret) {
237 		set_eadm_private(sch, NULL);
238 		spin_unlock_irq(sch->lock);
239 		kfree(private);
240 		goto out;
241 	}
242 	spin_unlock_irq(sch->lock);
243 
244 	spin_lock_irq(&list_lock);
245 	list_add(&private->head, &eadm_list);
246 	spin_unlock_irq(&list_lock);
247 
248 	if (dev_get_uevent_suppress(&sch->dev)) {
249 		dev_set_uevent_suppress(&sch->dev, 0);
250 		kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
251 	}
252 out:
253 	return ret;
254 }
255 
256 static void eadm_quiesce(struct subchannel *sch)
257 {
258 	int ret;
259 
260 	do {
261 		spin_lock_irq(sch->lock);
262 		ret = cio_disable_subchannel(sch);
263 		spin_unlock_irq(sch->lock);
264 	} while (ret == -EBUSY);
265 }
266 
267 static int eadm_subchannel_remove(struct subchannel *sch)
268 {
269 	struct eadm_private *private = get_eadm_private(sch);
270 
271 	spin_lock_irq(&list_lock);
272 	list_del(&private->head);
273 	spin_unlock_irq(&list_lock);
274 
275 	eadm_quiesce(sch);
276 
277 	spin_lock_irq(sch->lock);
278 	set_eadm_private(sch, NULL);
279 	spin_unlock_irq(sch->lock);
280 
281 	kfree(private);
282 
283 	return 0;
284 }
285 
286 static void eadm_subchannel_shutdown(struct subchannel *sch)
287 {
288 	eadm_quiesce(sch);
289 }
290 
291 static int eadm_subchannel_freeze(struct subchannel *sch)
292 {
293 	return cio_disable_subchannel(sch);
294 }
295 
296 static int eadm_subchannel_restore(struct subchannel *sch)
297 {
298 	return cio_enable_subchannel(sch, (u32)(unsigned long)sch);
299 }
300 
301 /**
302  * eadm_subchannel_sch_event - process subchannel event
303  * @sch: subchannel
304  * @process: non-zero if function is called in process context
305  *
306  * An unspecified event occurred for this subchannel. Adjust data according
307  * to the current operational state of the subchannel. Return zero when the
308  * event has been handled sufficiently or -EAGAIN when this function should
309  * be called again in process context.
310  */
311 static int eadm_subchannel_sch_event(struct subchannel *sch, int process)
312 {
313 	struct eadm_private *private;
314 	unsigned long flags;
315 	int ret = 0;
316 
317 	spin_lock_irqsave(sch->lock, flags);
318 	if (!device_is_registered(&sch->dev))
319 		goto out_unlock;
320 
321 	if (work_pending(&sch->todo_work))
322 		goto out_unlock;
323 
324 	if (cio_update_schib(sch)) {
325 		css_sched_sch_todo(sch, SCH_TODO_UNREG);
326 		goto out_unlock;
327 	}
328 	private = get_eadm_private(sch);
329 	if (private->state == EADM_NOT_OPER)
330 		private->state = EADM_IDLE;
331 
332 out_unlock:
333 	spin_unlock_irqrestore(sch->lock, flags);
334 
335 	return ret;
336 }
337 
338 static struct css_device_id eadm_subchannel_ids[] = {
339 	{ .match_flags = 0x1, .type = SUBCHANNEL_TYPE_ADM, },
340 	{ /* end of list */ },
341 };
342 MODULE_DEVICE_TABLE(css, eadm_subchannel_ids);
343 
344 static struct css_driver eadm_subchannel_driver = {
345 	.drv = {
346 		.name = "eadm_subchannel",
347 		.owner = THIS_MODULE,
348 	},
349 	.subchannel_type = eadm_subchannel_ids,
350 	.irq = eadm_subchannel_irq,
351 	.probe = eadm_subchannel_probe,
352 	.remove = eadm_subchannel_remove,
353 	.shutdown = eadm_subchannel_shutdown,
354 	.sch_event = eadm_subchannel_sch_event,
355 	.freeze = eadm_subchannel_freeze,
356 	.thaw = eadm_subchannel_restore,
357 	.restore = eadm_subchannel_restore,
358 };
359 
360 static struct eadm_ops eadm_ops = {
361 	.eadm_start = eadm_start_aob,
362 	.owner = THIS_MODULE,
363 };
364 
365 static int __init eadm_sch_init(void)
366 {
367 	int ret;
368 
369 	if (!css_general_characteristics.eadm)
370 		return -ENXIO;
371 
372 	eadm_debug = debug_register("eadm_log", 16, 1, 16);
373 	if (!eadm_debug)
374 		return -ENOMEM;
375 
376 	debug_register_view(eadm_debug, &debug_hex_ascii_view);
377 	debug_set_level(eadm_debug, 2);
378 
379 	isc_register(EADM_SCH_ISC);
380 	ret = css_driver_register(&eadm_subchannel_driver);
381 	if (ret)
382 		goto cleanup;
383 
384 	register_eadm_ops(&eadm_ops);
385 	return ret;
386 
387 cleanup:
388 	isc_unregister(EADM_SCH_ISC);
389 	debug_unregister(eadm_debug);
390 	return ret;
391 }
392 
393 static void __exit eadm_sch_exit(void)
394 {
395 	unregister_eadm_ops(&eadm_ops);
396 	css_driver_unregister(&eadm_subchannel_driver);
397 	isc_unregister(EADM_SCH_ISC);
398 	debug_unregister(eadm_debug);
399 }
400 module_init(eadm_sch_init);
401 module_exit(eadm_sch_exit);
402