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