]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/s390/cio/device_status.c | |
3 | * | |
4 | * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, | |
5 | * IBM Corporation | |
4ce3b30c | 6 | * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com) |
1da177e4 LT |
7 | * Martin Schwidefsky (schwidefsky@de.ibm.com) |
8 | * | |
9 | * Status accumulation and basic sense functions. | |
10 | */ | |
11 | ||
1da177e4 LT |
12 | #include <linux/module.h> |
13 | #include <linux/init.h> | |
14 | ||
15 | #include <asm/ccwdev.h> | |
16 | #include <asm/cio.h> | |
17 | ||
18 | #include "cio.h" | |
19 | #include "cio_debug.h" | |
20 | #include "css.h" | |
21 | #include "device.h" | |
22 | #include "ioasm.h" | |
23 | ||
24 | /* | |
25 | * Check for any kind of channel or interface control check but don't | |
26 | * issue the message for the console device | |
27 | */ | |
4d284cac | 28 | static void |
1da177e4 LT |
29 | ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb) |
30 | { | |
31 | if (!(irb->scsw.cstat & (SCHN_STAT_CHN_DATA_CHK | | |
32 | SCHN_STAT_CHN_CTRL_CHK | | |
33 | SCHN_STAT_INTF_CTRL_CHK))) | |
34 | return; | |
1da177e4 LT |
35 | CIO_MSG_EVENT(0, "Channel-Check or Interface-Control-Check " |
36 | "received" | |
fb6958a5 | 37 | " ... device %04x on subchannel 0.%x.%04x, dev_stat " |
1da177e4 | 38 | ": %02X sch_stat : %02X\n", |
78964268 CH |
39 | cdev->private->dev_id.devno, cdev->private->schid.ssid, |
40 | cdev->private->schid.sch_no, | |
1d3ac7aa | 41 | irb->scsw.dstat, irb->scsw.cstat); |
1da177e4 LT |
42 | |
43 | if (irb->scsw.cc != 3) { | |
44 | char dbf_text[15]; | |
45 | ||
78964268 | 46 | sprintf(dbf_text, "chk%x", cdev->private->schid.sch_no); |
1da177e4 | 47 | CIO_TRACE_EVENT(0, dbf_text); |
1d3ac7aa | 48 | CIO_HEX_EVENT(0, irb, sizeof (struct irb)); |
1da177e4 LT |
49 | } |
50 | } | |
51 | ||
52 | /* | |
53 | * Some paths became not operational (pno bit in scsw is set). | |
54 | */ | |
55 | static void | |
56 | ccw_device_path_notoper(struct ccw_device *cdev) | |
57 | { | |
58 | struct subchannel *sch; | |
59 | ||
60 | sch = to_subchannel(cdev->dev.parent); | |
a8237fc4 | 61 | stsch (sch->schid, &sch->schib); |
1da177e4 | 62 | |
fb6958a5 CH |
63 | CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are " |
64 | "not operational \n", __FUNCTION__, | |
65 | sch->schid.ssid, sch->schid.sch_no, | |
1da177e4 LT |
66 | sch->schib.pmcw.pnom); |
67 | ||
68 | sch->lpm &= ~sch->schib.pmcw.pnom; | |
7e560814 | 69 | cdev->private->flags.doverify = 1; |
1da177e4 LT |
70 | } |
71 | ||
72 | /* | |
73 | * Copy valid bits from the extended control word to device irb. | |
74 | */ | |
4d284cac | 75 | static void |
1da177e4 LT |
76 | ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb) |
77 | { | |
78 | /* | |
79 | * Copy extended control bit if it is valid... yes there | |
80 | * are condition that have to be met for the extended control | |
81 | * bit to have meaning. Sick. | |
82 | */ | |
83 | cdev->private->irb.scsw.ectl = 0; | |
84 | if ((irb->scsw.stctl & SCSW_STCTL_ALERT_STATUS) && | |
85 | !(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS)) | |
86 | cdev->private->irb.scsw.ectl = irb->scsw.ectl; | |
87 | /* Check if extended control word is valid. */ | |
88 | if (!cdev->private->irb.scsw.ectl) | |
89 | return; | |
90 | /* Copy concurrent sense / model dependent information. */ | |
91 | memcpy (&cdev->private->irb.ecw, irb->ecw, sizeof (irb->ecw)); | |
92 | } | |
93 | ||
94 | /* | |
95 | * Check if extended status word is valid. | |
96 | */ | |
4d284cac | 97 | static int |
1da177e4 LT |
98 | ccw_device_accumulate_esw_valid(struct irb *irb) |
99 | { | |
100 | if (!irb->scsw.eswf && irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) | |
101 | return 0; | |
102 | if (irb->scsw.stctl == | |
103 | (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) && | |
104 | !(irb->scsw.actl & SCSW_ACTL_SUSPENDED)) | |
105 | return 0; | |
106 | return 1; | |
107 | } | |
108 | ||
109 | /* | |
110 | * Copy valid bits from the extended status word to device irb. | |
111 | */ | |
4d284cac | 112 | static void |
1da177e4 LT |
113 | ccw_device_accumulate_esw(struct ccw_device *cdev, struct irb *irb) |
114 | { | |
115 | struct irb *cdev_irb; | |
116 | struct sublog *cdev_sublog, *sublog; | |
117 | ||
118 | if (!ccw_device_accumulate_esw_valid(irb)) | |
119 | return; | |
120 | ||
121 | cdev_irb = &cdev->private->irb; | |
122 | ||
123 | /* Copy last path used mask. */ | |
124 | cdev_irb->esw.esw1.lpum = irb->esw.esw1.lpum; | |
125 | ||
126 | /* Copy subchannel logout information if esw is of format 0. */ | |
127 | if (irb->scsw.eswf) { | |
128 | cdev_sublog = &cdev_irb->esw.esw0.sublog; | |
129 | sublog = &irb->esw.esw0.sublog; | |
130 | /* Copy extended status flags. */ | |
131 | cdev_sublog->esf = sublog->esf; | |
132 | /* | |
133 | * Copy fields that have a meaning for channel data check | |
134 | * channel control check and interface control check. | |
135 | */ | |
136 | if (irb->scsw.cstat & (SCHN_STAT_CHN_DATA_CHK | | |
137 | SCHN_STAT_CHN_CTRL_CHK | | |
138 | SCHN_STAT_INTF_CTRL_CHK)) { | |
139 | /* Copy ancillary report bit. */ | |
140 | cdev_sublog->arep = sublog->arep; | |
141 | /* Copy field-validity-flags. */ | |
142 | cdev_sublog->fvf = sublog->fvf; | |
143 | /* Copy storage access code. */ | |
144 | cdev_sublog->sacc = sublog->sacc; | |
145 | /* Copy termination code. */ | |
146 | cdev_sublog->termc = sublog->termc; | |
147 | /* Copy sequence code. */ | |
148 | cdev_sublog->seqc = sublog->seqc; | |
149 | } | |
150 | /* Copy device status check. */ | |
151 | cdev_sublog->devsc = sublog->devsc; | |
152 | /* Copy secondary error. */ | |
153 | cdev_sublog->serr = sublog->serr; | |
154 | /* Copy i/o-error alert. */ | |
155 | cdev_sublog->ioerr = sublog->ioerr; | |
156 | /* Copy channel path timeout bit. */ | |
157 | if (irb->scsw.cstat & SCHN_STAT_INTF_CTRL_CHK) | |
158 | cdev_irb->esw.esw0.erw.cpt = irb->esw.esw0.erw.cpt; | |
159 | /* Copy failing storage address validity flag. */ | |
160 | cdev_irb->esw.esw0.erw.fsavf = irb->esw.esw0.erw.fsavf; | |
161 | if (cdev_irb->esw.esw0.erw.fsavf) { | |
162 | /* ... and copy the failing storage address. */ | |
163 | memcpy(cdev_irb->esw.esw0.faddr, irb->esw.esw0.faddr, | |
164 | sizeof (irb->esw.esw0.faddr)); | |
165 | /* ... and copy the failing storage address format. */ | |
166 | cdev_irb->esw.esw0.erw.fsaf = irb->esw.esw0.erw.fsaf; | |
167 | } | |
168 | /* Copy secondary ccw address validity bit. */ | |
169 | cdev_irb->esw.esw0.erw.scavf = irb->esw.esw0.erw.scavf; | |
170 | if (irb->esw.esw0.erw.scavf) | |
171 | /* ... and copy the secondary ccw address. */ | |
172 | cdev_irb->esw.esw0.saddr = irb->esw.esw0.saddr; | |
173 | ||
174 | } | |
175 | /* FIXME: DCTI for format 2? */ | |
176 | ||
177 | /* Copy authorization bit. */ | |
178 | cdev_irb->esw.esw0.erw.auth = irb->esw.esw0.erw.auth; | |
179 | /* Copy path verification required flag. */ | |
180 | cdev_irb->esw.esw0.erw.pvrf = irb->esw.esw0.erw.pvrf; | |
7e560814 | 181 | if (irb->esw.esw0.erw.pvrf) |
1da177e4 LT |
182 | cdev->private->flags.doverify = 1; |
183 | /* Copy concurrent sense bit. */ | |
184 | cdev_irb->esw.esw0.erw.cons = irb->esw.esw0.erw.cons; | |
185 | if (irb->esw.esw0.erw.cons) | |
186 | cdev_irb->esw.esw0.erw.scnt = irb->esw.esw0.erw.scnt; | |
187 | } | |
188 | ||
189 | /* | |
190 | * Accumulate status from irb to devstat. | |
191 | */ | |
192 | void | |
193 | ccw_device_accumulate_irb(struct ccw_device *cdev, struct irb *irb) | |
194 | { | |
195 | struct irb *cdev_irb; | |
196 | ||
197 | /* | |
198 | * Check if the status pending bit is set in stctl. | |
199 | * If not, the remaining bit have no meaning and we must ignore them. | |
200 | * The esw is not meaningful as well... | |
201 | */ | |
202 | if (!(irb->scsw.stctl & SCSW_STCTL_STATUS_PEND)) | |
203 | return; | |
204 | ||
205 | /* Check for channel checks and interface control checks. */ | |
206 | ccw_device_msg_control_check(cdev, irb); | |
207 | ||
208 | /* Check for path not operational. */ | |
209 | if (irb->scsw.pno && irb->scsw.fctl != 0 && | |
210 | (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) || | |
211 | (irb->scsw.actl & SCSW_ACTL_SUSPENDED))) | |
212 | ccw_device_path_notoper(cdev); | |
213 | ||
214 | /* | |
215 | * Don't accumulate unsolicited interrupts. | |
216 | */ | |
217 | if ((irb->scsw.stctl == | |
218 | (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) && | |
219 | (!irb->scsw.cc)) | |
220 | return; | |
221 | ||
222 | cdev_irb = &cdev->private->irb; | |
223 | ||
8c3ce5be CH |
224 | /* |
225 | * If the clear function had been performed, all formerly pending | |
226 | * status at the subchannel has been cleared and we must not pass | |
227 | * intermediate accumulated status to the device driver. | |
228 | */ | |
229 | if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) | |
230 | memset(&cdev->private->irb, 0, sizeof(struct irb)); | |
231 | ||
1da177e4 LT |
232 | /* Copy bits which are valid only for the start function. */ |
233 | if (irb->scsw.fctl & SCSW_FCTL_START_FUNC) { | |
234 | /* Copy key. */ | |
235 | cdev_irb->scsw.key = irb->scsw.key; | |
236 | /* Copy suspend control bit. */ | |
237 | cdev_irb->scsw.sctl = irb->scsw.sctl; | |
238 | /* Accumulate deferred condition code. */ | |
239 | cdev_irb->scsw.cc |= irb->scsw.cc; | |
240 | /* Copy ccw format bit. */ | |
241 | cdev_irb->scsw.fmt = irb->scsw.fmt; | |
242 | /* Copy prefetch bit. */ | |
243 | cdev_irb->scsw.pfch = irb->scsw.pfch; | |
244 | /* Copy initial-status-interruption-control. */ | |
245 | cdev_irb->scsw.isic = irb->scsw.isic; | |
246 | /* Copy address limit checking control. */ | |
247 | cdev_irb->scsw.alcc = irb->scsw.alcc; | |
248 | /* Copy suppress suspend bit. */ | |
249 | cdev_irb->scsw.ssi = irb->scsw.ssi; | |
250 | } | |
251 | ||
252 | /* Take care of the extended control bit and extended control word. */ | |
253 | ccw_device_accumulate_ecw(cdev, irb); | |
254 | ||
255 | /* Accumulate function control. */ | |
256 | cdev_irb->scsw.fctl |= irb->scsw.fctl; | |
257 | /* Copy activity control. */ | |
258 | cdev_irb->scsw.actl= irb->scsw.actl; | |
259 | /* Accumulate status control. */ | |
260 | cdev_irb->scsw.stctl |= irb->scsw.stctl; | |
261 | /* | |
262 | * Copy ccw address if it is valid. This is a bit simplified | |
263 | * but should be close enough for all practical purposes. | |
264 | */ | |
265 | if ((irb->scsw.stctl & SCSW_STCTL_PRIM_STATUS) || | |
266 | ((irb->scsw.stctl == | |
267 | (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) && | |
268 | (irb->scsw.actl & SCSW_ACTL_DEVACT) && | |
269 | (irb->scsw.actl & SCSW_ACTL_SCHACT)) || | |
270 | (irb->scsw.actl & SCSW_ACTL_SUSPENDED)) | |
271 | cdev_irb->scsw.cpa = irb->scsw.cpa; | |
272 | /* Accumulate device status, but not the device busy flag. */ | |
273 | cdev_irb->scsw.dstat &= ~DEV_STAT_BUSY; | |
25c61a1f CH |
274 | /* dstat is not always valid. */ |
275 | if (irb->scsw.stctl & | |
276 | (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS | |
277 | | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS)) | |
278 | cdev_irb->scsw.dstat |= irb->scsw.dstat; | |
1da177e4 LT |
279 | /* Accumulate subchannel status. */ |
280 | cdev_irb->scsw.cstat |= irb->scsw.cstat; | |
281 | /* Copy residual count if it is valid. */ | |
282 | if ((irb->scsw.stctl & SCSW_STCTL_PRIM_STATUS) && | |
283 | (irb->scsw.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN)) == 0) | |
284 | cdev_irb->scsw.count = irb->scsw.count; | |
285 | ||
286 | /* Take care of bits in the extended status word. */ | |
287 | ccw_device_accumulate_esw(cdev, irb); | |
288 | ||
289 | /* | |
290 | * Check whether we must issue a SENSE CCW ourselves if there is no | |
291 | * concurrent sense facility installed for the subchannel. | |
292 | * No sense is required if no delayed sense is pending | |
293 | * and we did not get a unit check without sense information. | |
294 | * | |
295 | * Note: We should check for ioinfo[irq]->flags.consns but VM | |
296 | * violates the ESA/390 architecture and doesn't present an | |
297 | * operand exception for virtual devices without concurrent | |
298 | * sense facility available/supported when enabling the | |
299 | * concurrent sense facility. | |
300 | */ | |
301 | if ((cdev_irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && | |
302 | !(cdev_irb->esw.esw0.erw.cons)) | |
303 | cdev->private->flags.dosense = 1; | |
304 | } | |
305 | ||
306 | /* | |
307 | * Do a basic sense. | |
308 | */ | |
309 | int | |
310 | ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb) | |
311 | { | |
312 | struct subchannel *sch; | |
313 | ||
314 | sch = to_subchannel(cdev->dev.parent); | |
315 | ||
316 | /* A sense is required, can we do it now ? */ | |
317 | if ((irb->scsw.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0) | |
318 | /* | |
319 | * we received an Unit Check but we have no final | |
320 | * status yet, therefore we must delay the SENSE | |
321 | * processing. We must not report this intermediate | |
322 | * status to the device interrupt handler. | |
323 | */ | |
324 | return -EBUSY; | |
325 | ||
326 | /* | |
327 | * We have ending status but no sense information. Do a basic sense. | |
328 | */ | |
1da177e4 LT |
329 | sch->sense_ccw.cmd_code = CCW_CMD_BASIC_SENSE; |
330 | sch->sense_ccw.cda = (__u32) __pa(cdev->private->irb.ecw); | |
331 | sch->sense_ccw.count = SENSE_MAX_COUNT; | |
332 | sch->sense_ccw.flags = CCW_FLAG_SLI; | |
333 | ||
d23861ff CH |
334 | /* Reset internal retry indication. */ |
335 | cdev->private->flags.intretry = 0; | |
336 | ||
1da177e4 LT |
337 | return cio_start (sch, &sch->sense_ccw, 0xff); |
338 | } | |
339 | ||
340 | /* | |
341 | * Add information from basic sense to devstat. | |
342 | */ | |
343 | void | |
344 | ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb) | |
345 | { | |
346 | /* | |
347 | * Check if the status pending bit is set in stctl. | |
348 | * If not, the remaining bit have no meaning and we must ignore them. | |
349 | * The esw is not meaningful as well... | |
350 | */ | |
351 | if (!(irb->scsw.stctl & SCSW_STCTL_STATUS_PEND)) | |
352 | return; | |
353 | ||
354 | /* Check for channel checks and interface control checks. */ | |
355 | ccw_device_msg_control_check(cdev, irb); | |
356 | ||
357 | /* Check for path not operational. */ | |
358 | if (irb->scsw.pno && irb->scsw.fctl != 0 && | |
359 | (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) || | |
360 | (irb->scsw.actl & SCSW_ACTL_SUSPENDED))) | |
361 | ccw_device_path_notoper(cdev); | |
362 | ||
363 | if (!(irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && | |
364 | (irb->scsw.dstat & DEV_STAT_CHN_END)) { | |
365 | cdev->private->irb.esw.esw0.erw.cons = 1; | |
366 | cdev->private->flags.dosense = 0; | |
367 | } | |
368 | /* Check if path verification is required. */ | |
369 | if (ccw_device_accumulate_esw_valid(irb) && | |
7e560814 | 370 | irb->esw.esw0.erw.pvrf) |
1da177e4 LT |
371 | cdev->private->flags.doverify = 1; |
372 | } | |
373 | ||
374 | /* | |
375 | * This function accumulates the status into the private devstat and | |
376 | * starts a basic sense if one is needed. | |
377 | */ | |
378 | int | |
379 | ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb) | |
380 | { | |
381 | ccw_device_accumulate_irb(cdev, irb); | |
382 | if ((irb->scsw.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0) | |
383 | return -EBUSY; | |
384 | /* Check for basic sense. */ | |
385 | if (cdev->private->flags.dosense && | |
386 | !(irb->scsw.dstat & DEV_STAT_UNIT_CHECK)) { | |
387 | cdev->private->irb.esw.esw0.erw.cons = 1; | |
388 | cdev->private->flags.dosense = 0; | |
389 | return 0; | |
390 | } | |
391 | if (cdev->private->flags.dosense) { | |
392 | ccw_device_do_sense(cdev, irb); | |
393 | return -EBUSY; | |
394 | } | |
395 | return 0; | |
396 | } | |
397 |