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 (cornelia.huck@de.ibm.com) 7 * Martin Schwidefsky (schwidefsky@de.ibm.com) 8 * 9 * Status accumulation and basic sense functions. 10 */ 11 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 */ 28 static void 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; 35 CIO_MSG_EVENT(0, "Channel-Check or Interface-Control-Check " 36 "received" 37 " ... device %04x on subchannel 0.%x.%04x, dev_stat " 38 ": %02X sch_stat : %02X\n", 39 cdev->private->dev_id.devno, cdev->private->schid.ssid, 40 cdev->private->schid.sch_no, 41 irb->scsw.dstat, irb->scsw.cstat); 42 43 if (irb->scsw.cc != 3) { 44 char dbf_text[15]; 45 46 sprintf(dbf_text, "chk%x", cdev->private->schid.sch_no); 47 CIO_TRACE_EVENT(0, dbf_text); 48 CIO_HEX_EVENT(0, irb, sizeof (struct irb)); 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); 61 stsch (sch->schid, &sch->schib); 62 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, 66 sch->schib.pmcw.pnom); 67 68 sch->lpm &= ~sch->schib.pmcw.pnom; 69 cdev->private->flags.doverify = 1; 70 } 71 72 /* 73 * Copy valid bits from the extended control word to device irb. 74 */ 75 static void 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 */ 97 static int 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 */ 112 static void 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; 181 if (irb->esw.esw0.erw.pvrf) 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 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 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; 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; 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 */ 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 334 /* Reset internal retry indication. */ 335 cdev->private->flags.intretry = 0; 336 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) && 370 irb->esw.esw0.erw.pvrf) 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 398