1 /*
2 * S/390 common I/O routines -- low level i/o calls
3 *
4 * Copyright IBM Corp. 1999, 2008
5 * Author(s): Ingo Adlung (adlung@de.ibm.com)
6 * Cornelia Huck (cornelia.huck@de.ibm.com)
7 * Arnd Bergmann (arndb@de.ibm.com)
8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 */
10
11 #define KMSG_COMPONENT "cio"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
14 #include <linux/ftrace.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <linux/device.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/interrupt.h>
21 #include <linux/irq.h>
22 #include <asm/cio.h>
23 #include <asm/delay.h>
24 #include <asm/irq.h>
25 #include <asm/irq_regs.h>
26 #include <asm/setup.h>
27 #include <asm/reset.h>
28 #include <asm/ipl.h>
29 #include <asm/chpid.h>
30 #include <asm/airq.h>
31 #include <asm/isc.h>
32 #include <linux/cputime.h>
33 #include <asm/fcx.h>
34 #include <asm/nmi.h>
35 #include <asm/crw.h>
36 #include "cio.h"
37 #include "css.h"
38 #include "chsc.h"
39 #include "ioasm.h"
40 #include "io_sch.h"
41 #include "blacklist.h"
42 #include "cio_debug.h"
43 #include "chp.h"
44
45 debug_info_t *cio_debug_msg_id;
46 debug_info_t *cio_debug_trace_id;
47 debug_info_t *cio_debug_crw_id;
48
49 DEFINE_PER_CPU_ALIGNED(struct irb, cio_irb);
50 EXPORT_PER_CPU_SYMBOL(cio_irb);
51
52 /*
53 * Function: cio_debug_init
54 * Initializes three debug logs for common I/O:
55 * - cio_msg logs generic cio messages
56 * - cio_trace logs the calling of different functions
57 * - cio_crw logs machine check related cio messages
58 */
cio_debug_init(void)59 static int __init cio_debug_init(void)
60 {
61 cio_debug_msg_id = debug_register("cio_msg", 16, 1, 11 * sizeof(long));
62 if (!cio_debug_msg_id)
63 goto out_unregister;
64 debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
65 debug_set_level(cio_debug_msg_id, 2);
66 cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
67 if (!cio_debug_trace_id)
68 goto out_unregister;
69 debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
70 debug_set_level(cio_debug_trace_id, 2);
71 cio_debug_crw_id = debug_register("cio_crw", 8, 1, 8 * sizeof(long));
72 if (!cio_debug_crw_id)
73 goto out_unregister;
74 debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
75 debug_set_level(cio_debug_crw_id, 4);
76 return 0;
77
78 out_unregister:
79 if (cio_debug_msg_id)
80 debug_unregister(cio_debug_msg_id);
81 if (cio_debug_trace_id)
82 debug_unregister(cio_debug_trace_id);
83 if (cio_debug_crw_id)
84 debug_unregister(cio_debug_crw_id);
85 return -1;
86 }
87
88 arch_initcall (cio_debug_init);
89
cio_set_options(struct subchannel * sch,int flags)90 int cio_set_options(struct subchannel *sch, int flags)
91 {
92 struct io_subchannel_private *priv = to_io_private(sch);
93
94 priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
95 priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
96 priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
97 return 0;
98 }
99
100 static int
cio_start_handle_notoper(struct subchannel * sch,__u8 lpm)101 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
102 {
103 char dbf_text[15];
104
105 if (lpm != 0)
106 sch->lpm &= ~lpm;
107 else
108 sch->lpm = 0;
109
110 CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
111 "subchannel 0.%x.%04x!\n", sch->schid.ssid,
112 sch->schid.sch_no);
113
114 if (cio_update_schib(sch))
115 return -ENODEV;
116
117 sprintf(dbf_text, "no%s", dev_name(&sch->dev));
118 CIO_TRACE_EVENT(0, dbf_text);
119 CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
120
121 return (sch->lpm ? -EACCES : -ENODEV);
122 }
123
124 int
cio_start_key(struct subchannel * sch,struct ccw1 * cpa,__u8 lpm,__u8 key)125 cio_start_key (struct subchannel *sch, /* subchannel structure */
126 struct ccw1 * cpa, /* logical channel prog addr */
127 __u8 lpm, /* logical path mask */
128 __u8 key) /* storage key */
129 {
130 struct io_subchannel_private *priv = to_io_private(sch);
131 union orb *orb = &priv->orb;
132 int ccode;
133
134 CIO_TRACE_EVENT(5, "stIO");
135 CIO_TRACE_EVENT(5, dev_name(&sch->dev));
136
137 memset(orb, 0, sizeof(union orb));
138 /* sch is always under 2G. */
139 orb->cmd.intparm = (u32)(addr_t)sch;
140 orb->cmd.fmt = 1;
141
142 orb->cmd.pfch = priv->options.prefetch == 0;
143 orb->cmd.spnd = priv->options.suspend;
144 orb->cmd.ssic = priv->options.suspend && priv->options.inter;
145 orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
146 #ifdef CONFIG_64BIT
147 /*
148 * for 64 bit we always support 64 bit IDAWs with 4k page size only
149 */
150 orb->cmd.c64 = 1;
151 orb->cmd.i2k = 0;
152 #endif
153 orb->cmd.key = key >> 4;
154 /* issue "Start Subchannel" */
155 orb->cmd.cpa = (__u32) __pa(cpa);
156 ccode = ssch(sch->schid, orb);
157
158 /* process condition code */
159 CIO_HEX_EVENT(5, &ccode, sizeof(ccode));
160
161 switch (ccode) {
162 case 0:
163 /*
164 * initialize device status information
165 */
166 sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
167 return 0;
168 case 1: /* status pending */
169 case 2: /* busy */
170 return -EBUSY;
171 case 3: /* device/path not operational */
172 return cio_start_handle_notoper(sch, lpm);
173 default:
174 return ccode;
175 }
176 }
177
178 int
cio_start(struct subchannel * sch,struct ccw1 * cpa,__u8 lpm)179 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
180 {
181 return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
182 }
183
184 /*
185 * resume suspended I/O operation
186 */
187 int
cio_resume(struct subchannel * sch)188 cio_resume (struct subchannel *sch)
189 {
190 int ccode;
191
192 CIO_TRACE_EVENT(4, "resIO");
193 CIO_TRACE_EVENT(4, dev_name(&sch->dev));
194
195 ccode = rsch (sch->schid);
196
197 CIO_HEX_EVENT(4, &ccode, sizeof(ccode));
198
199 switch (ccode) {
200 case 0:
201 sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
202 return 0;
203 case 1:
204 return -EBUSY;
205 case 2:
206 return -EINVAL;
207 default:
208 /*
209 * useless to wait for request completion
210 * as device is no longer operational !
211 */
212 return -ENODEV;
213 }
214 }
215
216 /*
217 * halt I/O operation
218 */
219 int
cio_halt(struct subchannel * sch)220 cio_halt(struct subchannel *sch)
221 {
222 int ccode;
223
224 if (!sch)
225 return -ENODEV;
226
227 CIO_TRACE_EVENT(2, "haltIO");
228 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
229
230 /*
231 * Issue "Halt subchannel" and process condition code
232 */
233 ccode = hsch (sch->schid);
234
235 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
236
237 switch (ccode) {
238 case 0:
239 sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
240 return 0;
241 case 1: /* status pending */
242 case 2: /* busy */
243 return -EBUSY;
244 default: /* device not operational */
245 return -ENODEV;
246 }
247 }
248
249 /*
250 * Clear I/O operation
251 */
252 int
cio_clear(struct subchannel * sch)253 cio_clear(struct subchannel *sch)
254 {
255 int ccode;
256
257 if (!sch)
258 return -ENODEV;
259
260 CIO_TRACE_EVENT(2, "clearIO");
261 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
262
263 /*
264 * Issue "Clear subchannel" and process condition code
265 */
266 ccode = csch (sch->schid);
267
268 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
269
270 switch (ccode) {
271 case 0:
272 sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
273 return 0;
274 default: /* device not operational */
275 return -ENODEV;
276 }
277 }
278
279 /*
280 * Function: cio_cancel
281 * Issues a "Cancel Subchannel" on the specified subchannel
282 * Note: We don't need any fancy intparms and flags here
283 * since xsch is executed synchronously.
284 * Only for common I/O internal use as for now.
285 */
286 int
cio_cancel(struct subchannel * sch)287 cio_cancel (struct subchannel *sch)
288 {
289 int ccode;
290
291 if (!sch)
292 return -ENODEV;
293
294 CIO_TRACE_EVENT(2, "cancelIO");
295 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
296
297 ccode = xsch (sch->schid);
298
299 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
300
301 switch (ccode) {
302 case 0: /* success */
303 /* Update information in scsw. */
304 if (cio_update_schib(sch))
305 return -ENODEV;
306 return 0;
307 case 1: /* status pending */
308 return -EBUSY;
309 case 2: /* not applicable */
310 return -EINVAL;
311 default: /* not oper */
312 return -ENODEV;
313 }
314 }
315
316
cio_apply_config(struct subchannel * sch,struct schib * schib)317 static void cio_apply_config(struct subchannel *sch, struct schib *schib)
318 {
319 schib->pmcw.intparm = sch->config.intparm;
320 schib->pmcw.mbi = sch->config.mbi;
321 schib->pmcw.isc = sch->config.isc;
322 schib->pmcw.ena = sch->config.ena;
323 schib->pmcw.mme = sch->config.mme;
324 schib->pmcw.mp = sch->config.mp;
325 schib->pmcw.csense = sch->config.csense;
326 schib->pmcw.mbfc = sch->config.mbfc;
327 if (sch->config.mbfc)
328 schib->mba = sch->config.mba;
329 }
330
cio_check_config(struct subchannel * sch,struct schib * schib)331 static int cio_check_config(struct subchannel *sch, struct schib *schib)
332 {
333 return (schib->pmcw.intparm == sch->config.intparm) &&
334 (schib->pmcw.mbi == sch->config.mbi) &&
335 (schib->pmcw.isc == sch->config.isc) &&
336 (schib->pmcw.ena == sch->config.ena) &&
337 (schib->pmcw.mme == sch->config.mme) &&
338 (schib->pmcw.mp == sch->config.mp) &&
339 (schib->pmcw.csense == sch->config.csense) &&
340 (schib->pmcw.mbfc == sch->config.mbfc) &&
341 (!sch->config.mbfc || (schib->mba == sch->config.mba));
342 }
343
344 /*
345 * cio_commit_config - apply configuration to the subchannel
346 */
cio_commit_config(struct subchannel * sch)347 int cio_commit_config(struct subchannel *sch)
348 {
349 int ccode, retry, ret = 0;
350 struct schib schib;
351 struct irb irb;
352
353 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
354 return -ENODEV;
355
356 for (retry = 0; retry < 5; retry++) {
357 /* copy desired changes to local schib */
358 cio_apply_config(sch, &schib);
359 ccode = msch_err(sch->schid, &schib);
360 if (ccode < 0) /* -EIO if msch gets a program check. */
361 return ccode;
362 switch (ccode) {
363 case 0: /* successful */
364 if (stsch_err(sch->schid, &schib) ||
365 !css_sch_is_valid(&schib))
366 return -ENODEV;
367 if (cio_check_config(sch, &schib)) {
368 /* commit changes from local schib */
369 memcpy(&sch->schib, &schib, sizeof(schib));
370 return 0;
371 }
372 ret = -EAGAIN;
373 break;
374 case 1: /* status pending */
375 ret = -EBUSY;
376 if (tsch(sch->schid, &irb))
377 return ret;
378 break;
379 case 2: /* busy */
380 udelay(100); /* allow for recovery */
381 ret = -EBUSY;
382 break;
383 case 3: /* not operational */
384 return -ENODEV;
385 }
386 }
387 return ret;
388 }
389
390 /**
391 * cio_update_schib - Perform stsch and update schib if subchannel is valid.
392 * @sch: subchannel on which to perform stsch
393 * Return zero on success, -ENODEV otherwise.
394 */
cio_update_schib(struct subchannel * sch)395 int cio_update_schib(struct subchannel *sch)
396 {
397 struct schib schib;
398
399 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
400 return -ENODEV;
401
402 memcpy(&sch->schib, &schib, sizeof(schib));
403 return 0;
404 }
405 EXPORT_SYMBOL_GPL(cio_update_schib);
406
407 /**
408 * cio_enable_subchannel - enable a subchannel.
409 * @sch: subchannel to be enabled
410 * @intparm: interruption parameter to set
411 */
cio_enable_subchannel(struct subchannel * sch,u32 intparm)412 int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
413 {
414 int ret;
415
416 CIO_TRACE_EVENT(2, "ensch");
417 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
418
419 if (sch_is_pseudo_sch(sch))
420 return -EINVAL;
421 if (cio_update_schib(sch))
422 return -ENODEV;
423
424 sch->config.ena = 1;
425 sch->config.isc = sch->isc;
426 sch->config.intparm = intparm;
427
428 ret = cio_commit_config(sch);
429 if (ret == -EIO) {
430 /*
431 * Got a program check in msch. Try without
432 * the concurrent sense bit the next time.
433 */
434 sch->config.csense = 0;
435 ret = cio_commit_config(sch);
436 }
437 CIO_HEX_EVENT(2, &ret, sizeof(ret));
438 return ret;
439 }
440 EXPORT_SYMBOL_GPL(cio_enable_subchannel);
441
442 /**
443 * cio_disable_subchannel - disable a subchannel.
444 * @sch: subchannel to disable
445 */
cio_disable_subchannel(struct subchannel * sch)446 int cio_disable_subchannel(struct subchannel *sch)
447 {
448 int ret;
449
450 CIO_TRACE_EVENT(2, "dissch");
451 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
452
453 if (sch_is_pseudo_sch(sch))
454 return 0;
455 if (cio_update_schib(sch))
456 return -ENODEV;
457
458 sch->config.ena = 0;
459 ret = cio_commit_config(sch);
460
461 CIO_HEX_EVENT(2, &ret, sizeof(ret));
462 return ret;
463 }
464 EXPORT_SYMBOL_GPL(cio_disable_subchannel);
465
cio_check_devno_blacklisted(struct subchannel * sch)466 static int cio_check_devno_blacklisted(struct subchannel *sch)
467 {
468 if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
469 /*
470 * This device must not be known to Linux. So we simply
471 * say that there is no device and return ENODEV.
472 */
473 CIO_MSG_EVENT(6, "Blacklisted device detected "
474 "at devno %04X, subchannel set %x\n",
475 sch->schib.pmcw.dev, sch->schid.ssid);
476 return -ENODEV;
477 }
478 return 0;
479 }
480
cio_validate_io_subchannel(struct subchannel * sch)481 static int cio_validate_io_subchannel(struct subchannel *sch)
482 {
483 /* Initialization for io subchannels. */
484 if (!css_sch_is_valid(&sch->schib))
485 return -ENODEV;
486
487 /* Devno is valid. */
488 return cio_check_devno_blacklisted(sch);
489 }
490
cio_validate_msg_subchannel(struct subchannel * sch)491 static int cio_validate_msg_subchannel(struct subchannel *sch)
492 {
493 /* Initialization for message subchannels. */
494 if (!css_sch_is_valid(&sch->schib))
495 return -ENODEV;
496
497 /* Devno is valid. */
498 return cio_check_devno_blacklisted(sch);
499 }
500
501 /**
502 * cio_validate_subchannel - basic validation of subchannel
503 * @sch: subchannel structure to be filled out
504 * @schid: subchannel id
505 *
506 * Find out subchannel type and initialize struct subchannel.
507 * Return codes:
508 * 0 on success
509 * -ENXIO for non-defined subchannels
510 * -ENODEV for invalid subchannels or blacklisted devices
511 * -EIO for subchannels in an invalid subchannel set
512 */
cio_validate_subchannel(struct subchannel * sch,struct subchannel_id schid)513 int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
514 {
515 char dbf_txt[15];
516 int ccode;
517 int err;
518
519 sprintf(dbf_txt, "valsch%x", schid.sch_no);
520 CIO_TRACE_EVENT(4, dbf_txt);
521
522 /*
523 * The first subchannel that is not-operational (ccode==3)
524 * indicates that there aren't any more devices available.
525 * If stsch gets an exception, it means the current subchannel set
526 * is not valid.
527 */
528 ccode = stsch_err(schid, &sch->schib);
529 if (ccode) {
530 err = (ccode == 3) ? -ENXIO : ccode;
531 goto out;
532 }
533 sch->st = sch->schib.pmcw.st;
534 sch->schid = schid;
535
536 switch (sch->st) {
537 case SUBCHANNEL_TYPE_IO:
538 err = cio_validate_io_subchannel(sch);
539 break;
540 case SUBCHANNEL_TYPE_MSG:
541 err = cio_validate_msg_subchannel(sch);
542 break;
543 default:
544 err = 0;
545 }
546 if (err)
547 goto out;
548
549 CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
550 sch->schid.ssid, sch->schid.sch_no, sch->st);
551 out:
552 return err;
553 }
554
555 /*
556 * do_cio_interrupt() handles all normal I/O device IRQ's
557 */
do_cio_interrupt(int irq,void * dummy)558 static irqreturn_t do_cio_interrupt(int irq, void *dummy)
559 {
560 struct tpi_info *tpi_info;
561 struct subchannel *sch;
562 struct irb *irb;
563
564 set_cpu_flag(CIF_NOHZ_DELAY);
565 tpi_info = (struct tpi_info *) &get_irq_regs()->int_code;
566 irb = this_cpu_ptr(&cio_irb);
567 sch = (struct subchannel *)(unsigned long) tpi_info->intparm;
568 if (!sch) {
569 /* Clear pending interrupt condition. */
570 inc_irq_stat(IRQIO_CIO);
571 tsch(tpi_info->schid, irb);
572 return IRQ_HANDLED;
573 }
574 spin_lock(sch->lock);
575 /* Store interrupt response block to lowcore. */
576 if (tsch(tpi_info->schid, irb) == 0) {
577 /* Keep subchannel information word up to date. */
578 memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw));
579 /* Call interrupt handler if there is one. */
580 if (sch->driver && sch->driver->irq)
581 sch->driver->irq(sch);
582 else
583 inc_irq_stat(IRQIO_CIO);
584 } else
585 inc_irq_stat(IRQIO_CIO);
586 spin_unlock(sch->lock);
587
588 return IRQ_HANDLED;
589 }
590
591 static struct irqaction io_interrupt = {
592 .name = "IO",
593 .handler = do_cio_interrupt,
594 };
595
init_cio_interrupts(void)596 void __init init_cio_interrupts(void)
597 {
598 irq_set_chip_and_handler(IO_INTERRUPT,
599 &dummy_irq_chip, handle_percpu_irq);
600 setup_irq(IO_INTERRUPT, &io_interrupt);
601 }
602
603 #ifdef CONFIG_CCW_CONSOLE
604 static struct subchannel *console_sch;
605 static struct lock_class_key console_sch_key;
606
607 /*
608 * Use cio_tsch to update the subchannel status and call the interrupt handler
609 * if status had been pending. Called with the subchannel's lock held.
610 */
cio_tsch(struct subchannel * sch)611 void cio_tsch(struct subchannel *sch)
612 {
613 struct irb *irb;
614 int irq_context;
615
616 irb = this_cpu_ptr(&cio_irb);
617 /* Store interrupt response block to lowcore. */
618 if (tsch(sch->schid, irb) != 0)
619 /* Not status pending or not operational. */
620 return;
621 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
622 /* Call interrupt handler with updated status. */
623 irq_context = in_interrupt();
624 if (!irq_context) {
625 local_bh_disable();
626 irq_enter();
627 }
628 kstat_incr_irq_this_cpu(IO_INTERRUPT);
629 if (sch->driver && sch->driver->irq)
630 sch->driver->irq(sch);
631 else
632 inc_irq_stat(IRQIO_CIO);
633 if (!irq_context) {
634 irq_exit();
635 _local_bh_enable();
636 }
637 }
638
cio_test_for_console(struct subchannel_id schid,void * data)639 static int cio_test_for_console(struct subchannel_id schid, void *data)
640 {
641 struct schib schib;
642
643 if (stsch_err(schid, &schib) != 0)
644 return -ENXIO;
645 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
646 (schib.pmcw.dev == console_devno)) {
647 console_irq = schid.sch_no;
648 return 1; /* found */
649 }
650 return 0;
651 }
652
cio_get_console_sch_no(void)653 static int cio_get_console_sch_no(void)
654 {
655 struct subchannel_id schid;
656 struct schib schib;
657
658 init_subchannel_id(&schid);
659 if (console_irq != -1) {
660 /* VM provided us with the irq number of the console. */
661 schid.sch_no = console_irq;
662 if (stsch_err(schid, &schib) != 0 ||
663 (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv)
664 return -1;
665 console_devno = schib.pmcw.dev;
666 } else if (console_devno != -1) {
667 /* At least the console device number is known. */
668 for_each_subchannel(cio_test_for_console, NULL);
669 }
670 return console_irq;
671 }
672
cio_probe_console(void)673 struct subchannel *cio_probe_console(void)
674 {
675 struct subchannel_id schid;
676 struct subchannel *sch;
677 int sch_no, ret;
678
679 sch_no = cio_get_console_sch_no();
680 if (sch_no == -1) {
681 pr_warning("No CCW console was found\n");
682 return ERR_PTR(-ENODEV);
683 }
684 init_subchannel_id(&schid);
685 schid.sch_no = sch_no;
686 sch = css_alloc_subchannel(schid);
687 if (IS_ERR(sch))
688 return sch;
689
690 lockdep_set_class(sch->lock, &console_sch_key);
691 isc_register(CONSOLE_ISC);
692 sch->config.isc = CONSOLE_ISC;
693 sch->config.intparm = (u32)(addr_t)sch;
694 ret = cio_commit_config(sch);
695 if (ret) {
696 isc_unregister(CONSOLE_ISC);
697 put_device(&sch->dev);
698 return ERR_PTR(ret);
699 }
700 console_sch = sch;
701 return sch;
702 }
703
cio_is_console(struct subchannel_id schid)704 int cio_is_console(struct subchannel_id schid)
705 {
706 if (!console_sch)
707 return 0;
708 return schid_equal(&schid, &console_sch->schid);
709 }
710
cio_register_early_subchannels(void)711 void cio_register_early_subchannels(void)
712 {
713 int ret;
714
715 if (!console_sch)
716 return;
717
718 ret = css_register_subchannel(console_sch);
719 if (ret)
720 put_device(&console_sch->dev);
721 }
722 #endif /* CONFIG_CCW_CONSOLE */
723
724 static int
__disable_subchannel_easy(struct subchannel_id schid,struct schib * schib)725 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
726 {
727 int retry, cc;
728
729 cc = 0;
730 for (retry=0;retry<3;retry++) {
731 schib->pmcw.ena = 0;
732 cc = msch_err(schid, schib);
733 if (cc)
734 return (cc==3?-ENODEV:-EBUSY);
735 if (stsch_err(schid, schib) || !css_sch_is_valid(schib))
736 return -ENODEV;
737 if (!schib->pmcw.ena)
738 return 0;
739 }
740 return -EBUSY; /* uhm... */
741 }
742
743 static int
__clear_io_subchannel_easy(struct subchannel_id schid)744 __clear_io_subchannel_easy(struct subchannel_id schid)
745 {
746 int retry;
747
748 if (csch(schid))
749 return -ENODEV;
750 for (retry=0;retry<20;retry++) {
751 struct tpi_info ti;
752
753 if (tpi(&ti)) {
754 tsch(ti.schid, this_cpu_ptr(&cio_irb));
755 if (schid_equal(&ti.schid, &schid))
756 return 0;
757 }
758 udelay_simple(100);
759 }
760 return -EBUSY;
761 }
762
__clear_chsc_subchannel_easy(void)763 static void __clear_chsc_subchannel_easy(void)
764 {
765 /* It seems we can only wait for a bit here :/ */
766 udelay_simple(100);
767 }
768
769 static int pgm_check_occured;
770
cio_reset_pgm_check_handler(void)771 static void cio_reset_pgm_check_handler(void)
772 {
773 pgm_check_occured = 1;
774 }
775
stsch_reset(struct subchannel_id schid,struct schib * addr)776 static int stsch_reset(struct subchannel_id schid, struct schib *addr)
777 {
778 int rc;
779
780 pgm_check_occured = 0;
781 s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
782 rc = stsch_err(schid, addr);
783 s390_base_pgm_handler_fn = NULL;
784
785 /* The program check handler could have changed pgm_check_occured. */
786 barrier();
787
788 if (pgm_check_occured)
789 return -EIO;
790 else
791 return rc;
792 }
793
__shutdown_subchannel_easy(struct subchannel_id schid,void * data)794 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
795 {
796 struct schib schib;
797
798 if (stsch_reset(schid, &schib))
799 return -ENXIO;
800 if (!schib.pmcw.ena)
801 return 0;
802 switch(__disable_subchannel_easy(schid, &schib)) {
803 case 0:
804 case -ENODEV:
805 break;
806 default: /* -EBUSY */
807 switch (schib.pmcw.st) {
808 case SUBCHANNEL_TYPE_IO:
809 if (__clear_io_subchannel_easy(schid))
810 goto out; /* give up... */
811 break;
812 case SUBCHANNEL_TYPE_CHSC:
813 __clear_chsc_subchannel_easy();
814 break;
815 default:
816 /* No default clear strategy */
817 break;
818 }
819 stsch_err(schid, &schib);
820 __disable_subchannel_easy(schid, &schib);
821 }
822 out:
823 return 0;
824 }
825
826 static atomic_t chpid_reset_count;
827
s390_reset_chpids_mcck_handler(void)828 static void s390_reset_chpids_mcck_handler(void)
829 {
830 struct crw crw;
831 struct mci *mci;
832
833 /* Check for pending channel report word. */
834 mci = (struct mci *)&S390_lowcore.mcck_interruption_code;
835 if (!mci->cp)
836 return;
837 /* Process channel report words. */
838 while (stcrw(&crw) == 0) {
839 /* Check for responses to RCHP. */
840 if (crw.slct && crw.rsc == CRW_RSC_CPATH)
841 atomic_dec(&chpid_reset_count);
842 }
843 }
844
845 #define RCHP_TIMEOUT (30 * USEC_PER_SEC)
css_reset(void)846 static void css_reset(void)
847 {
848 int i, ret;
849 unsigned long long timeout;
850 struct chp_id chpid;
851
852 /* Reset subchannels. */
853 for_each_subchannel(__shutdown_subchannel_easy, NULL);
854 /* Reset channel paths. */
855 s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
856 /* Enable channel report machine checks. */
857 __ctl_set_bit(14, 28);
858 /* Temporarily reenable machine checks. */
859 local_mcck_enable();
860 chp_id_init(&chpid);
861 for (i = 0; i <= __MAX_CHPID; i++) {
862 chpid.id = i;
863 ret = rchp(chpid);
864 if ((ret == 0) || (ret == 2))
865 /*
866 * rchp either succeeded, or another rchp is already
867 * in progress. In either case, we'll get a crw.
868 */
869 atomic_inc(&chpid_reset_count);
870 }
871 /* Wait for machine check for all channel paths. */
872 timeout = get_tod_clock_fast() + (RCHP_TIMEOUT << 12);
873 while (atomic_read(&chpid_reset_count) != 0) {
874 if (get_tod_clock_fast() > timeout)
875 break;
876 cpu_relax();
877 }
878 /* Disable machine checks again. */
879 local_mcck_disable();
880 /* Disable channel report machine checks. */
881 __ctl_clear_bit(14, 28);
882 s390_base_mcck_handler_fn = NULL;
883 }
884
885 static struct reset_call css_reset_call = {
886 .fn = css_reset,
887 };
888
init_css_reset_call(void)889 static int __init init_css_reset_call(void)
890 {
891 atomic_set(&chpid_reset_count, 0);
892 register_reset_call(&css_reset_call);
893 return 0;
894 }
895
896 arch_initcall(init_css_reset_call);
897
898 struct sch_match_id {
899 struct subchannel_id schid;
900 struct ccw_dev_id devid;
901 int rc;
902 };
903
__reipl_subchannel_match(struct subchannel_id schid,void * data)904 static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
905 {
906 struct schib schib;
907 struct sch_match_id *match_id = data;
908
909 if (stsch_reset(schid, &schib))
910 return -ENXIO;
911 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
912 (schib.pmcw.dev == match_id->devid.devno) &&
913 (schid.ssid == match_id->devid.ssid)) {
914 match_id->schid = schid;
915 match_id->rc = 0;
916 return 1;
917 }
918 return 0;
919 }
920
reipl_find_schid(struct ccw_dev_id * devid,struct subchannel_id * schid)921 static int reipl_find_schid(struct ccw_dev_id *devid,
922 struct subchannel_id *schid)
923 {
924 struct sch_match_id match_id;
925
926 match_id.devid = *devid;
927 match_id.rc = -ENODEV;
928 for_each_subchannel(__reipl_subchannel_match, &match_id);
929 if (match_id.rc == 0)
930 *schid = match_id.schid;
931 return match_id.rc;
932 }
933
934 extern void do_reipl_asm(__u32 schid);
935
936 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
reipl_ccw_dev(struct ccw_dev_id * devid)937 void reipl_ccw_dev(struct ccw_dev_id *devid)
938 {
939 struct subchannel_id uninitialized_var(schid);
940
941 s390_reset_system(NULL, NULL);
942 if (reipl_find_schid(devid, &schid) != 0)
943 panic("IPL Device not found\n");
944 do_reipl_asm(*((__u32*)&schid));
945 }
946
cio_get_iplinfo(struct cio_iplinfo * iplinfo)947 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
948 {
949 struct subchannel_id schid;
950 struct schib schib;
951
952 schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
953 if (!schid.one)
954 return -ENODEV;
955 if (stsch_err(schid, &schib))
956 return -ENODEV;
957 if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
958 return -ENODEV;
959 if (!schib.pmcw.dnv)
960 return -ENODEV;
961 iplinfo->devno = schib.pmcw.dev;
962 iplinfo->is_qdio = schib.pmcw.qf;
963 return 0;
964 }
965
966 /**
967 * cio_tm_start_key - perform start function
968 * @sch: subchannel on which to perform the start function
969 * @tcw: transport-command word to be started
970 * @lpm: mask of paths to use
971 * @key: storage key to use for storage access
972 *
973 * Start the tcw on the given subchannel. Return zero on success, non-zero
974 * otherwise.
975 */
cio_tm_start_key(struct subchannel * sch,struct tcw * tcw,u8 lpm,u8 key)976 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key)
977 {
978 int cc;
979 union orb *orb = &to_io_private(sch)->orb;
980
981 memset(orb, 0, sizeof(union orb));
982 orb->tm.intparm = (u32) (addr_t) sch;
983 orb->tm.key = key >> 4;
984 orb->tm.b = 1;
985 orb->tm.lpm = lpm ? lpm : sch->lpm;
986 orb->tm.tcw = (u32) (addr_t) tcw;
987 cc = ssch(sch->schid, orb);
988 switch (cc) {
989 case 0:
990 return 0;
991 case 1:
992 case 2:
993 return -EBUSY;
994 default:
995 return cio_start_handle_notoper(sch, lpm);
996 }
997 }
998
999 /**
1000 * cio_tm_intrg - perform interrogate function
1001 * @sch - subchannel on which to perform the interrogate function
1002 *
1003 * If the specified subchannel is running in transport-mode, perform the
1004 * interrogate function. Return zero on success, non-zero otherwie.
1005 */
cio_tm_intrg(struct subchannel * sch)1006 int cio_tm_intrg(struct subchannel *sch)
1007 {
1008 int cc;
1009
1010 if (!to_io_private(sch)->orb.tm.b)
1011 return -EINVAL;
1012 cc = xsch(sch->schid);
1013 switch (cc) {
1014 case 0:
1015 case 2:
1016 return 0;
1017 case 1:
1018 return -EBUSY;
1019 default:
1020 return -ENODEV;
1021 }
1022 }
1023