blob: 986ef6a92a410ad893127ff786fe43774d9e0daa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * S/390 common I/O routines -- low level i/o calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02004 * Copyright IBM Corp. 1999, 2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Ingo Adlung (adlung@de.ibm.com)
Cornelia Huck4ce3b302006-01-14 13:21:04 -08006 * Cornelia Huck (cornelia.huck@de.ibm.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Arnd Bergmann (arndb@de.ibm.com)
8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 */
10
Michael Ernste6d5a422008-12-25 13:39:36 +010011#define KMSG_COMPONENT "cio"
12#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
Heiko Carstens88dbd202009-06-12 10:26:46 +020014#include <linux/ftrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/cio.h>
22#include <asm/delay.h>
23#include <asm/irq.h>
Heiko Carstens5a489b92006-10-06 16:38:35 +020024#include <asm/irq_regs.h>
Heiko Carstense87bfe52006-09-20 15:59:15 +020025#include <asm/setup.h>
Heiko Carstens15e9b582006-12-04 15:40:26 +010026#include <asm/reset.h>
Michael Holzheu46b05d22007-02-21 10:55:21 +010027#include <asm/ipl.h>
Peter Oberparleitere5854a52007-04-27 16:01:31 +020028#include <asm/chpid.h>
Peter Oberparleiter4e8e56c2008-01-26 14:10:44 +010029#include <asm/airq.h>
Cornelia Huck3a3fc292008-07-14 09:58:58 +020030#include <asm/isc.h>
Martin Schwidefsky76d4e002009-06-12 10:26:21 +020031#include <asm/cputime.h>
Peter Oberparleiter83262d62008-07-14 09:58:51 +020032#include <asm/fcx.h>
Heiko Carstensf5daba12009-03-26 15:24:01 +010033#include <asm/nmi.h>
34#include <asm/crw.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "cio.h"
36#include "css.h"
37#include "chsc.h"
38#include "ioasm.h"
Cornelia Huckcd6b4f22008-01-26 14:10:43 +010039#include "io_sch.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "blacklist.h"
41#include "cio_debug.h"
Peter Oberparleitere6b6e102007-04-27 16:01:28 +020042#include "chp.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44debug_info_t *cio_debug_msg_id;
45debug_info_t *cio_debug_trace_id;
46debug_info_t *cio_debug_crw_id;
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/*
49 * Function: cio_debug_init
Cornelia Huckbc698bc2008-01-26 14:10:42 +010050 * Initializes three debug logs for common I/O:
51 * - cio_msg logs generic cio messages
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 * - cio_trace logs the calling of different functions
Cornelia Huckbc698bc2008-01-26 14:10:42 +010053 * - cio_crw logs machine check related cio messages
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 */
Cornelia Huckbc698bc2008-01-26 14:10:42 +010055static int __init cio_debug_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Peter Tiedemann361f4942008-01-26 14:11:30 +010057 cio_debug_msg_id = debug_register("cio_msg", 16, 1, 16 * sizeof(long));
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 if (!cio_debug_msg_id)
59 goto out_unregister;
Cornelia Huckbc698bc2008-01-26 14:10:42 +010060 debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
61 debug_set_level(cio_debug_msg_id, 2);
Peter Tiedemann361f4942008-01-26 14:11:30 +010062 cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 if (!cio_debug_trace_id)
64 goto out_unregister;
Cornelia Huckbc698bc2008-01-26 14:10:42 +010065 debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
66 debug_set_level(cio_debug_trace_id, 2);
Peter Tiedemann361f4942008-01-26 14:11:30 +010067 cio_debug_crw_id = debug_register("cio_crw", 16, 1, 16 * sizeof(long));
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 if (!cio_debug_crw_id)
69 goto out_unregister;
Cornelia Huckbc698bc2008-01-26 14:10:42 +010070 debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
71 debug_set_level(cio_debug_crw_id, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 return 0;
73
74out_unregister:
75 if (cio_debug_msg_id)
Cornelia Huckbc698bc2008-01-26 14:10:42 +010076 debug_unregister(cio_debug_msg_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 if (cio_debug_trace_id)
Cornelia Huckbc698bc2008-01-26 14:10:42 +010078 debug_unregister(cio_debug_trace_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 if (cio_debug_crw_id)
Cornelia Huckbc698bc2008-01-26 14:10:42 +010080 debug_unregister(cio_debug_crw_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 return -1;
82}
83
84arch_initcall (cio_debug_init);
85
Sebastian Ottc513d072011-03-15 17:08:25 +010086int cio_set_options(struct subchannel *sch, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Sebastian Ottc513d072011-03-15 17:08:25 +010088 struct io_subchannel_private *priv = to_io_private(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Sebastian Ottc513d072011-03-15 17:08:25 +010090 priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
91 priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
92 priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
93 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
95
Heiko Carstens4d284ca2007-02-05 21:18:53 +010096static int
Linus Torvalds1da177e2005-04-16 15:20:36 -070097cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
98{
99 char dbf_text[15];
100
101 if (lpm != 0)
102 sch->lpm &= ~lpm;
103 else
104 sch->lpm = 0;
105
Michael Ernst139b83d2008-05-07 09:22:54 +0200106 CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800107 "subchannel 0.%x.%04x!\n", sch->schid.ssid,
108 sch->schid.sch_no);
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100109
110 if (cio_update_schib(sch))
111 return -ENODEV;
112
Kay Sievers2a0217d2008-10-10 21:33:09 +0200113 sprintf(dbf_text, "no%s", dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 CIO_TRACE_EVENT(0, dbf_text);
115 CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
116
117 return (sch->lpm ? -EACCES : -ENODEV);
118}
119
120int
121cio_start_key (struct subchannel *sch, /* subchannel structure */
122 struct ccw1 * cpa, /* logical channel prog addr */
123 __u8 lpm, /* logical path mask */
124 __u8 key) /* storage key */
125{
Sebastian Ottc513d072011-03-15 17:08:25 +0100126 struct io_subchannel_private *priv = to_io_private(sch);
127 union orb *orb = &priv->orb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 int ccode;
129
Sebastian Ottefd986d2009-09-11 10:28:18 +0200130 CIO_TRACE_EVENT(5, "stIO");
131 CIO_TRACE_EVENT(5, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Stefan Weinhuber9adb8c12008-09-16 09:32:19 -0700133 memset(orb, 0, sizeof(union orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 /* sch is always under 2G. */
Peter Oberparleiter83262d62008-07-14 09:58:51 +0200135 orb->cmd.intparm = (u32)(addr_t)sch;
136 orb->cmd.fmt = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Sebastian Ottc513d072011-03-15 17:08:25 +0100138 orb->cmd.pfch = priv->options.prefetch == 0;
139 orb->cmd.spnd = priv->options.suspend;
140 orb->cmd.ssic = priv->options.suspend && priv->options.inter;
Peter Oberparleiter83262d62008-07-14 09:58:51 +0200141 orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800142#ifdef CONFIG_64BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 /*
144 * for 64 bit we always support 64 bit IDAWs with 4k page size only
145 */
Peter Oberparleiter83262d62008-07-14 09:58:51 +0200146 orb->cmd.c64 = 1;
147 orb->cmd.i2k = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148#endif
Peter Oberparleiter83262d62008-07-14 09:58:51 +0200149 orb->cmd.key = key >> 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 /* issue "Start Subchannel" */
Peter Oberparleiter83262d62008-07-14 09:58:51 +0200151 orb->cmd.cpa = (__u32) __pa(cpa);
Cornelia Huckcd6b4f22008-01-26 14:10:43 +0100152 ccode = ssch(sch->schid, orb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* process condition code */
Sebastian Ottefd986d2009-09-11 10:28:18 +0200155 CIO_HEX_EVENT(5, &ccode, sizeof(ccode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 switch (ccode) {
158 case 0:
159 /*
160 * initialize device status information
161 */
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200162 sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 return 0;
164 case 1: /* status pending */
165 case 2: /* busy */
166 return -EBUSY;
Cornelia Huckc91ebe42008-09-09 12:38:58 +0200167 case 3: /* device/path not operational */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 return cio_start_handle_notoper(sch, lpm);
Cornelia Huckc91ebe42008-09-09 12:38:58 +0200169 default:
170 return ccode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
172}
173
174int
175cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
176{
Peter Oberparleiter0b642ed2005-05-01 08:58:58 -0700177 return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
180/*
181 * resume suspended I/O operation
182 */
183int
184cio_resume (struct subchannel *sch)
185{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 int ccode;
187
Sebastian Ottefd986d2009-09-11 10:28:18 +0200188 CIO_TRACE_EVENT(4, "resIO");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200189 CIO_TRACE_EVENT(4, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800191 ccode = rsch (sch->schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Sebastian Ottefd986d2009-09-11 10:28:18 +0200193 CIO_HEX_EVENT(4, &ccode, sizeof(ccode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
195 switch (ccode) {
196 case 0:
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200197 sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return 0;
199 case 1:
200 return -EBUSY;
201 case 2:
202 return -EINVAL;
203 default:
204 /*
205 * useless to wait for request completion
206 * as device is no longer operational !
207 */
208 return -ENODEV;
209 }
210}
211
212/*
213 * halt I/O operation
214 */
215int
216cio_halt(struct subchannel *sch)
217{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 int ccode;
219
220 if (!sch)
221 return -ENODEV;
222
Sebastian Ottefd986d2009-09-11 10:28:18 +0200223 CIO_TRACE_EVENT(2, "haltIO");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200224 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 /*
227 * Issue "Halt subchannel" and process condition code
228 */
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800229 ccode = hsch (sch->schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Sebastian Ottefd986d2009-09-11 10:28:18 +0200231 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 switch (ccode) {
234 case 0:
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200235 sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return 0;
237 case 1: /* status pending */
238 case 2: /* busy */
239 return -EBUSY;
240 default: /* device not operational */
241 return -ENODEV;
242 }
243}
244
245/*
246 * Clear I/O operation
247 */
248int
249cio_clear(struct subchannel *sch)
250{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 int ccode;
252
253 if (!sch)
254 return -ENODEV;
255
Sebastian Ottefd986d2009-09-11 10:28:18 +0200256 CIO_TRACE_EVENT(2, "clearIO");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200257 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 /*
260 * Issue "Clear subchannel" and process condition code
261 */
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800262 ccode = csch (sch->schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Sebastian Ottefd986d2009-09-11 10:28:18 +0200264 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 switch (ccode) {
267 case 0:
Peter Oberparleiter23d805b2008-07-14 09:58:50 +0200268 sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return 0;
270 default: /* device not operational */
271 return -ENODEV;
272 }
273}
274
275/*
276 * Function: cio_cancel
277 * Issues a "Cancel Subchannel" on the specified subchannel
278 * Note: We don't need any fancy intparms and flags here
279 * since xsch is executed synchronously.
280 * Only for common I/O internal use as for now.
281 */
282int
283cio_cancel (struct subchannel *sch)
284{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 int ccode;
286
287 if (!sch)
288 return -ENODEV;
289
Sebastian Ottefd986d2009-09-11 10:28:18 +0200290 CIO_TRACE_EVENT(2, "cancelIO");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200291 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800293 ccode = xsch (sch->schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Sebastian Ottefd986d2009-09-11 10:28:18 +0200295 CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
297 switch (ccode) {
298 case 0: /* success */
299 /* Update information in scsw. */
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100300 if (cio_update_schib(sch))
301 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return 0;
303 case 1: /* status pending */
304 return -EBUSY;
305 case 2: /* not applicable */
306 return -EINVAL;
307 default: /* not oper */
308 return -ENODEV;
309 }
310}
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
Sebastian Ott13952ec2008-12-25 13:39:13 +0100313static void cio_apply_config(struct subchannel *sch, struct schib *schib)
314{
315 schib->pmcw.intparm = sch->config.intparm;
316 schib->pmcw.mbi = sch->config.mbi;
317 schib->pmcw.isc = sch->config.isc;
318 schib->pmcw.ena = sch->config.ena;
319 schib->pmcw.mme = sch->config.mme;
320 schib->pmcw.mp = sch->config.mp;
321 schib->pmcw.csense = sch->config.csense;
322 schib->pmcw.mbfc = sch->config.mbfc;
323 if (sch->config.mbfc)
324 schib->mba = sch->config.mba;
325}
326
327static int cio_check_config(struct subchannel *sch, struct schib *schib)
328{
329 return (schib->pmcw.intparm == sch->config.intparm) &&
330 (schib->pmcw.mbi == sch->config.mbi) &&
331 (schib->pmcw.isc == sch->config.isc) &&
332 (schib->pmcw.ena == sch->config.ena) &&
333 (schib->pmcw.mme == sch->config.mme) &&
334 (schib->pmcw.mp == sch->config.mp) &&
335 (schib->pmcw.csense == sch->config.csense) &&
336 (schib->pmcw.mbfc == sch->config.mbfc) &&
337 (!sch->config.mbfc || (schib->mba == sch->config.mba));
338}
339
340/*
341 * cio_commit_config - apply configuration to the subchannel
342 */
343int cio_commit_config(struct subchannel *sch)
344{
345 struct schib schib;
346 int ccode, retry, ret = 0;
347
Sebastian Ott8821d242010-04-22 17:17:05 +0200348 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
Sebastian Ott13952ec2008-12-25 13:39:13 +0100349 return -ENODEV;
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 for (retry = 0; retry < 5; retry++) {
Sebastian Ott13952ec2008-12-25 13:39:13 +0100352 /* copy desired changes to local schib */
353 cio_apply_config(sch, &schib);
354 ccode = msch_err(sch->schid, &schib);
355 if (ccode < 0) /* -EIO if msch gets a program check. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return ccode;
357 switch (ccode) {
Coly Li73ac36e2009-01-07 18:09:16 -0800358 case 0: /* successful */
Sebastian Ott8821d242010-04-22 17:17:05 +0200359 if (stsch_err(sch->schid, &schib) ||
Sebastian Ott13952ec2008-12-25 13:39:13 +0100360 !css_sch_is_valid(&schib))
361 return -ENODEV;
362 if (cio_check_config(sch, &schib)) {
363 /* commit changes from local schib */
364 memcpy(&sch->schib, &schib, sizeof(schib));
365 return 0;
366 }
367 ret = -EAGAIN;
368 break;
369 case 1: /* status pending */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 return -EBUSY;
Sebastian Ott13952ec2008-12-25 13:39:13 +0100371 case 2: /* busy */
372 udelay(100); /* allow for recovery */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 ret = -EBUSY;
374 break;
Sebastian Ott13952ec2008-12-25 13:39:13 +0100375 case 3: /* not operational */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return -ENODEV;
377 }
378 }
379 return ret;
380}
381
Cornelia Huck44a1c192008-07-14 09:58:47 +0200382/**
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100383 * cio_update_schib - Perform stsch and update schib if subchannel is valid.
384 * @sch: subchannel on which to perform stsch
385 * Return zero on success, -ENODEV otherwise.
386 */
387int cio_update_schib(struct subchannel *sch)
388{
389 struct schib schib;
390
Sebastian Ott8821d242010-04-22 17:17:05 +0200391 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100392 return -ENODEV;
393
394 memcpy(&sch->schib, &schib, sizeof(schib));
395 return 0;
396}
397EXPORT_SYMBOL_GPL(cio_update_schib);
398
399/**
Cornelia Huck44a1c192008-07-14 09:58:47 +0200400 * cio_enable_subchannel - enable a subchannel.
401 * @sch: subchannel to be enabled
402 * @intparm: interruption parameter to set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 */
Cornelia Huckedf22092008-04-30 13:38:39 +0200404int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 int retry;
407 int ret;
408
Sebastian Ottefd986d2009-09-11 10:28:18 +0200409 CIO_TRACE_EVENT(2, "ensch");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200410 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100412 if (sch_is_pseudo_sch(sch))
413 return -EINVAL;
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100414 if (cio_update_schib(sch))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 return -ENODEV;
416
Sebastian Ott13952ec2008-12-25 13:39:13 +0100417 sch->config.ena = 1;
418 sch->config.isc = sch->isc;
419 sch->config.intparm = intparm;
420
421 for (retry = 0; retry < 3; retry++) {
422 ret = cio_commit_config(sch);
423 if (ret == -EIO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 /*
Sebastian Ott13952ec2008-12-25 13:39:13 +0100425 * Got a program check in msch. Try without
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 * the concurrent sense bit the next time.
427 */
Sebastian Ott13952ec2008-12-25 13:39:13 +0100428 sch->config.csense = 0;
429 } else if (ret == -EBUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 struct irb irb;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800431 if (tsch(sch->schid, &irb) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 break;
Sebastian Ott13952ec2008-12-25 13:39:13 +0100433 } else
434 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 }
Sebastian Ottefd986d2009-09-11 10:28:18 +0200436 CIO_HEX_EVENT(2, &ret, sizeof(ret));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return ret;
438}
Cornelia Huck44a1c192008-07-14 09:58:47 +0200439EXPORT_SYMBOL_GPL(cio_enable_subchannel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Cornelia Huck44a1c192008-07-14 09:58:47 +0200441/**
442 * cio_disable_subchannel - disable a subchannel.
443 * @sch: subchannel to disable
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 */
Cornelia Huck44a1c192008-07-14 09:58:47 +0200445int cio_disable_subchannel(struct subchannel *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Cornelia Hucked04b892009-03-26 15:24:06 +0100447 int retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 int ret;
449
Sebastian Ottefd986d2009-09-11 10:28:18 +0200450 CIO_TRACE_EVENT(2, "dissch");
Kay Sievers2a0217d2008-10-10 21:33:09 +0200451 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100453 if (sch_is_pseudo_sch(sch))
454 return 0;
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100455 if (cio_update_schib(sch))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 return -ENODEV;
457
Sebastian Ott13952ec2008-12-25 13:39:13 +0100458 sch->config.ena = 0;
Sebastian Ott13952ec2008-12-25 13:39:13 +0100459
Cornelia Hucked04b892009-03-26 15:24:06 +0100460 for (retry = 0; retry < 3; retry++) {
461 ret = cio_commit_config(sch);
462 if (ret == -EBUSY) {
463 struct irb irb;
464 if (tsch(sch->schid, &irb) != 0)
465 break;
466 } else
467 break;
468 }
Sebastian Ottefd986d2009-09-11 10:28:18 +0200469 CIO_HEX_EVENT(2, &ret, sizeof(ret));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return ret;
471}
Cornelia Huck44a1c192008-07-14 09:58:47 +0200472EXPORT_SYMBOL_GPL(cio_disable_subchannel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100474int cio_create_sch_lock(struct subchannel *sch)
Cornelia Huck2ec22982006-12-08 15:54:26 +0100475{
476 sch->lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
477 if (!sch->lock)
478 return -ENOMEM;
479 spin_lock_init(sch->lock);
480 return 0;
481}
482
Cornelia Huckb3a686f2008-07-14 09:58:48 +0200483static int cio_check_devno_blacklisted(struct subchannel *sch)
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200484{
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200485 if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
486 /*
487 * This device must not be known to Linux. So we simply
488 * say that there is no device and return ENODEV.
489 */
490 CIO_MSG_EVENT(6, "Blacklisted device detected "
491 "at devno %04X, subchannel set %x\n",
492 sch->schib.pmcw.dev, sch->schid.ssid);
493 return -ENODEV;
494 }
495 return 0;
496}
497
Cornelia Huckb3a686f2008-07-14 09:58:48 +0200498static int cio_validate_io_subchannel(struct subchannel *sch)
499{
500 /* Initialization for io subchannels. */
501 if (!css_sch_is_valid(&sch->schib))
502 return -ENODEV;
503
504 /* Devno is valid. */
505 return cio_check_devno_blacklisted(sch);
506}
507
508static int cio_validate_msg_subchannel(struct subchannel *sch)
509{
510 /* Initialization for message subchannels. */
511 if (!css_sch_is_valid(&sch->schib))
512 return -ENODEV;
513
514 /* Devno is valid. */
515 return cio_check_devno_blacklisted(sch);
516}
517
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200518/**
519 * cio_validate_subchannel - basic validation of subchannel
520 * @sch: subchannel structure to be filled out
521 * @schid: subchannel id
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 *
523 * Find out subchannel type and initialize struct subchannel.
524 * Return codes:
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200525 * 0 on success
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 * -ENXIO for non-defined subchannels
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200527 * -ENODEV for invalid subchannels or blacklisted devices
528 * -EIO for subchannels in an invalid subchannel set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 */
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200530int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531{
532 char dbf_txt[15];
533 int ccode;
Cornelia Huck2ec22982006-12-08 15:54:26 +0100534 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200536 sprintf(dbf_txt, "valsch%x", schid.sch_no);
537 CIO_TRACE_EVENT(4, dbf_txt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 /* Nuke all fields. */
540 memset(sch, 0, sizeof(struct subchannel));
541
Cornelia Huck2ec22982006-12-08 15:54:26 +0100542 sch->schid = schid;
543 if (cio_is_console(schid)) {
544 sch->lock = cio_get_console_lock();
545 } else {
546 err = cio_create_sch_lock(sch);
547 if (err)
548 goto out;
549 }
Cornelia Huck6ab48792006-07-12 16:39:50 +0200550 mutex_init(&sch->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 /*
553 * The first subchannel that is not-operational (ccode==3)
554 * indicates that there aren't any more devices available.
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800555 * If stsch gets an exception, it means the current subchannel set
556 * is not valid.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 */
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800558 ccode = stsch_err (schid, &sch->schib);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100559 if (ccode) {
560 err = (ccode == 3) ? -ENXIO : ccode;
561 goto out;
562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 /* Copy subchannel type from path management control word. */
564 sch->st = sch->schib.pmcw.st;
Cornelia Huckc820de32008-07-14 09:58:45 +0200565
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200566 switch (sch->st) {
567 case SUBCHANNEL_TYPE_IO:
568 err = cio_validate_io_subchannel(sch);
569 break;
Cornelia Huckb3a686f2008-07-14 09:58:48 +0200570 case SUBCHANNEL_TYPE_MSG:
571 err = cio_validate_msg_subchannel(sch);
572 break;
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200573 default:
574 err = 0;
575 }
576 if (err)
Cornelia Huck2ec22982006-12-08 15:54:26 +0100577 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200579 CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
580 sch->schid.ssid, sch->schid.sch_no, sch->st);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return 0;
Cornelia Huck2ec22982006-12-08 15:54:26 +0100582out:
583 if (!cio_is_console(schid))
584 kfree(sch->lock);
585 sch->lock = NULL;
586 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
589/*
590 * do_IRQ() handles all normal I/O device IRQ's (the special
591 * SMP cross-CPU interrupts have their own specific
592 * handlers).
593 *
594 */
Heiko Carstens88dbd202009-06-12 10:26:46 +0200595void __irq_entry do_IRQ(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 struct tpi_info *tpi_info;
598 struct subchannel *sch;
599 struct irb *irb;
Heiko Carstens5a489b92006-10-06 16:38:35 +0200600 struct pt_regs *old_regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Heiko Carstens5a489b92006-10-06 16:38:35 +0200602 old_regs = set_irq_regs(regs);
Martin Schwidefsky9cfb9b32008-12-31 15:11:41 +0100603 irq_enter();
Christoph Lameter4a6f4fe2010-12-06 11:16:24 -0600604 __this_cpu_write(s390_idle.nohz_delay, 1);
Heiko Carstens5a62b192008-04-17 07:46:25 +0200605 if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
606 /* Serve timer interrupts first. */
607 clock_comparator_work();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /*
609 * Get interrupt information from lowcore
610 */
Heiko Carstenscbb870c2010-02-26 22:37:43 +0100611 tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
612 irb = (struct irb *)&S390_lowcore.irb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 do {
Heiko Carstensadd9bde2013-01-02 14:01:23 +0100614 kstat_incr_irqs_this_cpu(IO_INTERRUPT, NULL);
Sebastian Ottee5894f2011-03-15 17:08:20 +0100615 if (tpi_info->adapter_IO) {
Cornelia Huckda7c5af2008-07-14 09:58:59 +0200616 do_adapter_IO(tpi_info->isc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 continue;
618 }
619 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
Heiko Carstensa8061702008-04-17 07:46:26 +0200620 if (!sch) {
621 /* Clear pending interrupt condition. */
Heiko Carstens420f42e2013-01-02 15:18:18 +0100622 inc_irq_stat(IRQIO_CIO);
Heiko Carstensa8061702008-04-17 07:46:26 +0200623 tsch(tpi_info->schid, irb);
624 continue;
625 }
626 spin_lock(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 /* Store interrupt response block to lowcore. */
Heiko Carstensa8061702008-04-17 07:46:26 +0200628 if (tsch(tpi_info->schid, irb) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 /* Keep subchannel information word up to date. */
630 memcpy (&sch->schib.scsw, &irb->scsw,
631 sizeof (irb->scsw));
632 /* Call interrupt handler if there is one. */
633 if (sch->driver && sch->driver->irq)
Cornelia Huck602b20f2008-01-26 14:10:39 +0100634 sch->driver->irq(sch);
Peter Oberparleiterde400d62011-10-30 15:16:04 +0100635 else
Heiko Carstens420f42e2013-01-02 15:18:18 +0100636 inc_irq_stat(IRQIO_CIO);
Peter Oberparleiterde400d62011-10-30 15:16:04 +0100637 } else
Heiko Carstens420f42e2013-01-02 15:18:18 +0100638 inc_irq_stat(IRQIO_CIO);
Heiko Carstensa8061702008-04-17 07:46:26 +0200639 spin_unlock(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 /*
641 * Are more interrupts pending?
642 * If so, the tpi instruction will update the lowcore
643 * to hold the info for the next interrupt.
644 * We don't do this for VM because a tpi drops the cpu
645 * out of the sie which costs more cycles than it saves.
646 */
Martin Schwidefsky27d71602010-02-26 22:37:38 +0100647 } while (MACHINE_IS_LPAR && tpi(NULL) != 0);
Heiko Carstens9d0a57c2006-10-11 15:31:26 +0200648 irq_exit();
Heiko Carstens5a489b92006-10-06 16:38:35 +0200649 set_irq_regs(old_regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650}
651
652#ifdef CONFIG_CCW_CONSOLE
653static struct subchannel console_subchannel;
Cornelia Huckcd6b4f22008-01-26 14:10:43 +0100654static struct io_subchannel_private console_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655static int console_subchannel_in_use;
656
Heiko Carstens191fd442008-12-25 13:39:01 +0100657/*
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200658 * Use cio_tsch to update the subchannel status and call the interrupt handler
659 * if status had been pending. Called with the console_subchannel lock.
Heiko Carstens191fd442008-12-25 13:39:01 +0100660 */
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200661static void cio_tsch(struct subchannel *sch)
Heiko Carstens191fd442008-12-25 13:39:01 +0100662{
Heiko Carstens191fd442008-12-25 13:39:01 +0100663 struct irb *irb;
664 int irq_context;
665
Heiko Carstenscbb870c2010-02-26 22:37:43 +0100666 irb = (struct irb *)&S390_lowcore.irb;
Heiko Carstens191fd442008-12-25 13:39:01 +0100667 /* Store interrupt response block to lowcore. */
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200668 if (tsch(sch->schid, irb) != 0)
Heiko Carstens191fd442008-12-25 13:39:01 +0100669 /* Not status pending or not operational. */
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200670 return;
Heiko Carstens191fd442008-12-25 13:39:01 +0100671 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200672 /* Call interrupt handler with updated status. */
673 irq_context = in_interrupt();
674 if (!irq_context) {
675 local_bh_disable();
676 irq_enter();
677 }
Heiko Carstens191fd442008-12-25 13:39:01 +0100678 if (sch->driver && sch->driver->irq)
679 sch->driver->irq(sch);
Peter Oberparleiterde400d62011-10-30 15:16:04 +0100680 else
Heiko Carstens420f42e2013-01-02 15:18:18 +0100681 inc_irq_stat(IRQIO_CIO);
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200682 if (!irq_context) {
683 irq_exit();
Heiko Carstens191fd442008-12-25 13:39:01 +0100684 _local_bh_enable();
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200685 }
Heiko Carstens191fd442008-12-25 13:39:01 +0100686}
687
Cornelia Huckcd6b4f22008-01-26 14:10:43 +0100688void *cio_get_console_priv(void)
689{
690 return &console_priv;
691}
692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693/*
694 * busy wait for the next interrupt on the console
695 */
Heiko Carstensa8061702008-04-17 07:46:26 +0200696void wait_cons_dev(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 if (!console_subchannel_in_use)
699 return;
700
Martin Schwidefskyb603d252012-05-09 16:27:36 +0200701 while (1) {
702 cio_tsch(&console_subchannel);
703 if (console_subchannel.schib.scsw.cmd.actl == 0)
704 break;
705 udelay_simple(100);
706 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709static int
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800710cio_test_for_console(struct subchannel_id schid, void *data)
711{
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800712 if (stsch_err(schid, &console_subchannel.schib) != 0)
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800713 return -ENXIO;
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100714 if ((console_subchannel.schib.pmcw.st == SUBCHANNEL_TYPE_IO) &&
715 console_subchannel.schib.pmcw.dnv &&
716 (console_subchannel.schib.pmcw.dev == console_devno)) {
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800717 console_irq = schid.sch_no;
718 return 1; /* found */
719 }
720 return 0;
721}
722
723
724static int
725cio_get_console_sch_no(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726{
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800727 struct subchannel_id schid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800729 init_subchannel_id(&schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (console_irq != -1) {
731 /* VM provided us with the irq number of the console. */
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800732 schid.sch_no = console_irq;
Sebastian Ott8821d242010-04-22 17:17:05 +0200733 if (stsch_err(schid, &console_subchannel.schib) != 0 ||
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100734 (console_subchannel.schib.pmcw.st != SUBCHANNEL_TYPE_IO) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 !console_subchannel.schib.pmcw.dnv)
736 return -1;
737 console_devno = console_subchannel.schib.pmcw.dev;
738 } else if (console_devno != -1) {
739 /* At least the console device number is known. */
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800740 for_each_subchannel(cio_test_for_console, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (console_irq == -1)
742 return -1;
743 } else {
744 /* unlike in 2.4, we cannot autoprobe here, since
745 * the channel subsystem is not fully initialized.
746 * With some luck, the HWC console can take over */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return -1;
748 }
749 return console_irq;
750}
751
752struct subchannel *
753cio_probe_console(void)
754{
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800755 int sch_no, ret;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800756 struct subchannel_id schid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 if (xchg(&console_subchannel_in_use, 1) != 0)
759 return ERR_PTR(-EBUSY);
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800760 sch_no = cio_get_console_sch_no();
761 if (sch_no == -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 console_subchannel_in_use = 0;
Michael Ernste6d5a422008-12-25 13:39:36 +0100763 pr_warning("No CCW console was found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 return ERR_PTR(-ENODEV);
765 }
766 memset(&console_subchannel, 0, sizeof(struct subchannel));
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800767 init_subchannel_id(&schid);
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800768 schid.sch_no = sch_no;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800769 ret = cio_validate_subchannel(&console_subchannel, schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if (ret) {
771 console_subchannel_in_use = 0;
772 return ERR_PTR(-ENODEV);
773 }
774
775 /*
Cornelia Huck3a3fc292008-07-14 09:58:58 +0200776 * enable console I/O-interrupt subclass
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 */
Cornelia Huck6ef556c2008-07-14 09:59:01 +0200778 isc_register(CONSOLE_ISC);
Sebastian Ott13952ec2008-12-25 13:39:13 +0100779 console_subchannel.config.isc = CONSOLE_ISC;
780 console_subchannel.config.intparm = (u32)(addr_t)&console_subchannel;
781 ret = cio_commit_config(&console_subchannel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 if (ret) {
Cornelia Huck6ef556c2008-07-14 09:59:01 +0200783 isc_unregister(CONSOLE_ISC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 console_subchannel_in_use = 0;
785 return ERR_PTR(ret);
786 }
787 return &console_subchannel;
788}
789
790void
791cio_release_console(void)
792{
Sebastian Ott13952ec2008-12-25 13:39:13 +0100793 console_subchannel.config.intparm = 0;
794 cio_commit_config(&console_subchannel);
Cornelia Huck6ef556c2008-07-14 09:59:01 +0200795 isc_unregister(CONSOLE_ISC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 console_subchannel_in_use = 0;
797}
798
799/* Bah... hack to catch console special sausages. */
800int
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800801cio_is_console(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
803 if (!console_subchannel_in_use)
804 return 0;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800805 return schid_equal(&schid, &console_subchannel.schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806}
807
808struct subchannel *
809cio_get_console_subchannel(void)
810{
811 if (!console_subchannel_in_use)
Heiko Carstensd2c993d2006-07-12 16:41:55 +0200812 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 return &console_subchannel;
814}
815
816#endif
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100817static int
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800818__disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 int retry, cc;
821
822 cc = 0;
823 for (retry=0;retry<3;retry++) {
824 schib->pmcw.ena = 0;
Sebastian Ott8821d242010-04-22 17:17:05 +0200825 cc = msch_err(schid, schib);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 if (cc)
827 return (cc==3?-ENODEV:-EBUSY);
Sebastian Ott8821d242010-04-22 17:17:05 +0200828 if (stsch_err(schid, schib) || !css_sch_is_valid(schib))
Sebastian Ottcdb912a2008-12-25 13:39:12 +0100829 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 if (!schib->pmcw.ena)
831 return 0;
832 }
833 return -EBUSY; /* uhm... */
834}
835
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100836static int
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200837__clear_io_subchannel_easy(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
839 int retry;
840
841 if (csch(schid))
842 return -ENODEV;
843 for (retry=0;retry<20;retry++) {
844 struct tpi_info ti;
845
846 if (tpi(&ti)) {
Heiko Carstenscbb870c2010-02-26 22:37:43 +0100847 tsch(ti.schid, (struct irb *)&S390_lowcore.irb);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800848 if (schid_equal(&ti.schid, &schid))
Cornelia Huck4c24da72005-09-03 15:58:01 -0700849 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 }
Heiko Carstens5a0d0e62008-10-10 21:33:22 +0200851 udelay_simple(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853 return -EBUSY;
854}
855
Cornelia Huck9d92a7e2008-07-14 09:59:05 +0200856static void __clear_chsc_subchannel_easy(void)
857{
858 /* It seems we can only wait for a bit here :/ */
Heiko Carstens5a0d0e62008-10-10 21:33:22 +0200859 udelay_simple(100);
Cornelia Huck9d92a7e2008-07-14 09:59:05 +0200860}
861
Michael Holzheua45e1412006-12-15 17:18:22 +0100862static int pgm_check_occured;
863
864static void cio_reset_pgm_check_handler(void)
865{
866 pgm_check_occured = 1;
867}
868
Peter Oberparleiterf9c9fe32008-10-10 21:33:15 +0200869static int stsch_reset(struct subchannel_id schid, struct schib *addr)
Michael Holzheua45e1412006-12-15 17:18:22 +0100870{
871 int rc;
872
873 pgm_check_occured = 0;
Heiko Carstensab14de62007-02-05 21:18:37 +0100874 s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
Sebastian Ott8821d242010-04-22 17:17:05 +0200875 rc = stsch_err(schid, addr);
Heiko Carstensab14de62007-02-05 21:18:37 +0100876 s390_base_pgm_handler_fn = NULL;
Heiko Carstens6faf4442007-01-09 10:18:41 +0100877
Heiko Carstensab14de62007-02-05 21:18:37 +0100878 /* The program check handler could have changed pgm_check_occured. */
Heiko Carstens6faf4442007-01-09 10:18:41 +0100879 barrier();
880
Michael Holzheua45e1412006-12-15 17:18:22 +0100881 if (pgm_check_occured)
882 return -EIO;
883 else
884 return rc;
885}
886
Heiko Carstens15e9b582006-12-04 15:40:26 +0100887static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800888{
889 struct schib schib;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
Michael Holzheua45e1412006-12-15 17:18:22 +0100891 if (stsch_reset(schid, &schib))
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800892 return -ENXIO;
893 if (!schib.pmcw.ena)
894 return 0;
895 switch(__disable_subchannel_easy(schid, &schib)) {
896 case 0:
897 case -ENODEV:
898 break;
899 default: /* -EBUSY */
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200900 switch (schib.pmcw.st) {
901 case SUBCHANNEL_TYPE_IO:
902 if (__clear_io_subchannel_easy(schid))
903 goto out; /* give up... */
904 break;
Cornelia Huck9d92a7e2008-07-14 09:59:05 +0200905 case SUBCHANNEL_TYPE_CHSC:
906 __clear_chsc_subchannel_easy();
907 break;
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200908 default:
909 /* No default clear strategy */
910 break;
911 }
Sebastian Ott8821d242010-04-22 17:17:05 +0200912 stsch_err(schid, &schib);
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800913 __disable_subchannel_easy(schid, &schib);
914 }
Cornelia Huck0ae7a7b2008-07-14 09:58:43 +0200915out:
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800916 return 0;
917}
918
Heiko Carstens15e9b582006-12-04 15:40:26 +0100919static atomic_t chpid_reset_count;
920
921static void s390_reset_chpids_mcck_handler(void)
922{
923 struct crw crw;
924 struct mci *mci;
925
926 /* Check for pending channel report word. */
927 mci = (struct mci *)&S390_lowcore.mcck_interruption_code;
928 if (!mci->cp)
929 return;
930 /* Process channel report words. */
931 while (stcrw(&crw) == 0) {
932 /* Check for responses to RCHP. */
933 if (crw.slct && crw.rsc == CRW_RSC_CPATH)
934 atomic_dec(&chpid_reset_count);
935 }
936}
937
938#define RCHP_TIMEOUT (30 * USEC_PER_SEC)
939static void css_reset(void)
940{
941 int i, ret;
942 unsigned long long timeout;
Peter Oberparleiterf86635f2007-04-27 16:01:26 +0200943 struct chp_id chpid;
Heiko Carstens15e9b582006-12-04 15:40:26 +0100944
945 /* Reset subchannels. */
946 for_each_subchannel(__shutdown_subchannel_easy, NULL);
947 /* Reset channel paths. */
Heiko Carstensab14de62007-02-05 21:18:37 +0100948 s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
Heiko Carstens15e9b582006-12-04 15:40:26 +0100949 /* Enable channel report machine checks. */
950 __ctl_set_bit(14, 28);
951 /* Temporarily reenable machine checks. */
952 local_mcck_enable();
Peter Oberparleiterf86635f2007-04-27 16:01:26 +0200953 chp_id_init(&chpid);
Heiko Carstens15e9b582006-12-04 15:40:26 +0100954 for (i = 0; i <= __MAX_CHPID; i++) {
Peter Oberparleiterf86635f2007-04-27 16:01:26 +0200955 chpid.id = i;
956 ret = rchp(chpid);
Heiko Carstens15e9b582006-12-04 15:40:26 +0100957 if ((ret == 0) || (ret == 2))
958 /*
959 * rchp either succeeded, or another rchp is already
960 * in progress. In either case, we'll get a crw.
961 */
962 atomic_inc(&chpid_reset_count);
963 }
964 /* Wait for machine check for all channel paths. */
Heiko Carstens1aae0562013-01-30 09:49:40 +0100965 timeout = get_tod_clock() + (RCHP_TIMEOUT << 12);
Heiko Carstens15e9b582006-12-04 15:40:26 +0100966 while (atomic_read(&chpid_reset_count) != 0) {
Heiko Carstens1aae0562013-01-30 09:49:40 +0100967 if (get_tod_clock() > timeout)
Heiko Carstens15e9b582006-12-04 15:40:26 +0100968 break;
969 cpu_relax();
970 }
971 /* Disable machine checks again. */
972 local_mcck_disable();
973 /* Disable channel report machine checks. */
974 __ctl_clear_bit(14, 28);
Heiko Carstensab14de62007-02-05 21:18:37 +0100975 s390_base_mcck_handler_fn = NULL;
Heiko Carstens15e9b582006-12-04 15:40:26 +0100976}
977
978static struct reset_call css_reset_call = {
979 .fn = css_reset,
980};
981
982static int __init init_css_reset_call(void)
983{
984 atomic_set(&chpid_reset_count, 0);
985 register_reset_call(&css_reset_call);
986 return 0;
987}
988
989arch_initcall(init_css_reset_call);
990
991struct sch_match_id {
992 struct subchannel_id schid;
993 struct ccw_dev_id devid;
994 int rc;
995};
996
997static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
998{
999 struct schib schib;
1000 struct sch_match_id *match_id = data;
1001
Michael Holzheua45e1412006-12-15 17:18:22 +01001002 if (stsch_reset(schid, &schib))
Heiko Carstens15e9b582006-12-04 15:40:26 +01001003 return -ENXIO;
Cornelia Huckb279a4f2008-01-26 14:10:45 +01001004 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
Heiko Carstens15e9b582006-12-04 15:40:26 +01001005 (schib.pmcw.dev == match_id->devid.devno) &&
1006 (schid.ssid == match_id->devid.ssid)) {
1007 match_id->schid = schid;
1008 match_id->rc = 0;
1009 return 1;
1010 }
1011 return 0;
1012}
1013
1014static int reipl_find_schid(struct ccw_dev_id *devid,
1015 struct subchannel_id *schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001017 struct sch_match_id match_id;
1018
1019 match_id.devid = *devid;
1020 match_id.rc = -ENODEV;
Heiko Carstens15e9b582006-12-04 15:40:26 +01001021 for_each_subchannel(__reipl_subchannel_match, &match_id);
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001022 if (match_id.rc == 0)
1023 *schid = match_id.schid;
1024 return match_id.rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025}
1026
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001027extern void do_reipl_asm(__u32 schid);
1028
1029/* Make sure all subchannels are quiet before we re-ipl an lpar. */
1030void reipl_ccw_dev(struct ccw_dev_id *devid)
1031{
Heiko Carstens41459d32012-09-14 11:09:52 +02001032 struct subchannel_id uninitialized_var(schid);
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001033
Michael Holzheu60a0c682011-10-30 15:16:40 +01001034 s390_reset_system(NULL, NULL);
Heiko Carstens15e9b582006-12-04 15:40:26 +01001035 if (reipl_find_schid(devid, &schid) != 0)
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001036 panic("IPL Device not found\n");
Michael Holzheuff6b8ea2006-09-20 15:58:49 +02001037 do_reipl_asm(*((__u32*)&schid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038}
Heiko Carstense87bfe52006-09-20 15:59:15 +02001039
Heiko Carstens6fc321f2007-04-27 16:01:25 +02001040int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
Heiko Carstense87bfe52006-09-20 15:59:15 +02001041{
1042 struct subchannel_id schid;
Heiko Carstens6fc321f2007-04-27 16:01:25 +02001043 struct schib schib;
Heiko Carstense87bfe52006-09-20 15:59:15 +02001044
Heiko Carstenscbb870c2010-02-26 22:37:43 +01001045 schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
Heiko Carstense87bfe52006-09-20 15:59:15 +02001046 if (!schid.one)
Heiko Carstens6fc321f2007-04-27 16:01:25 +02001047 return -ENODEV;
Sebastian Ott8821d242010-04-22 17:17:05 +02001048 if (stsch_err(schid, &schib))
Heiko Carstens6fc321f2007-04-27 16:01:25 +02001049 return -ENODEV;
Cornelia Huckb279a4f2008-01-26 14:10:45 +01001050 if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
1051 return -ENODEV;
Heiko Carstens6fc321f2007-04-27 16:01:25 +02001052 if (!schib.pmcw.dnv)
1053 return -ENODEV;
1054 iplinfo->devno = schib.pmcw.dev;
1055 iplinfo->is_qdio = schib.pmcw.qf;
1056 return 0;
Heiko Carstense87bfe52006-09-20 15:59:15 +02001057}
Peter Oberparleiter83262d62008-07-14 09:58:51 +02001058
1059/**
1060 * cio_tm_start_key - perform start function
1061 * @sch: subchannel on which to perform the start function
1062 * @tcw: transport-command word to be started
1063 * @lpm: mask of paths to use
1064 * @key: storage key to use for storage access
1065 *
1066 * Start the tcw on the given subchannel. Return zero on success, non-zero
1067 * otherwise.
1068 */
1069int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key)
1070{
1071 int cc;
1072 union orb *orb = &to_io_private(sch)->orb;
1073
1074 memset(orb, 0, sizeof(union orb));
1075 orb->tm.intparm = (u32) (addr_t) sch;
1076 orb->tm.key = key >> 4;
1077 orb->tm.b = 1;
1078 orb->tm.lpm = lpm ? lpm : sch->lpm;
1079 orb->tm.tcw = (u32) (addr_t) tcw;
1080 cc = ssch(sch->schid, orb);
1081 switch (cc) {
1082 case 0:
1083 return 0;
1084 case 1:
1085 case 2:
1086 return -EBUSY;
1087 default:
1088 return cio_start_handle_notoper(sch, lpm);
1089 }
1090}
1091
1092/**
1093 * cio_tm_intrg - perform interrogate function
1094 * @sch - subchannel on which to perform the interrogate function
1095 *
1096 * If the specified subchannel is running in transport-mode, perform the
1097 * interrogate function. Return zero on success, non-zero otherwie.
1098 */
1099int cio_tm_intrg(struct subchannel *sch)
1100{
1101 int cc;
1102
1103 if (!to_io_private(sch)->orb.tm.b)
1104 return -EINVAL;
1105 cc = xsch(sch->schid);
1106 switch (cc) {
1107 case 0:
1108 case 2:
1109 return 0;
1110 case 1:
1111 return -EBUSY;
1112 default:
1113 return -ENODEV;
1114 }
1115}