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