Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 3ad19b8fb07497f975aa6aba187198ce11191dd2

Authored by Sebastian Ott
Committed by Martin Schwidefsky
1 parent 94c163663f
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

s390/cio: fix irq statistics 

When we fetch an interrupt on the CCW console using tsch (via
ccw_device_wait_idle formerly known as wait_cons_dev) we increment
the irq count for the affected interruption class but it is not
accounted as an IO interrupt.

This is broken since commit b603d258a43b4e7339660bdd3b5c25eacd603e54
"s390: remove superfluous tpi from wait_cons_dev"

Fix it so that the sum of the individual interrupts per class matches
the number of IO interrupts again.

Reported-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Signed-off-by: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

Showing 1 changed file with 1 additions and 0 deletions Inline Diff

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