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 */ 28static void 29ccw_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 */ 55static void 56ccw_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 */ 75static void 76ccw_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 */ 97static int 98ccw_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 */ 112static void 113ccw_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 176 /* Copy authorization bit. */ 177 cdev_irb->esw.esw0.erw.auth = irb->esw.esw0.erw.auth; 178 /* Copy path verification required flag. */ 179 cdev_irb->esw.esw0.erw.pvrf = irb->esw.esw0.erw.pvrf; 180 if (irb->esw.esw0.erw.pvrf) 181 cdev->private->flags.doverify = 1; 182 /* Copy concurrent sense bit. */ 183 cdev_irb->esw.esw0.erw.cons = irb->esw.esw0.erw.cons; 184 if (irb->esw.esw0.erw.cons) 185 cdev_irb->esw.esw0.erw.scnt = irb->esw.esw0.erw.scnt; 186} 187 188/* 189 * Accumulate status from irb to devstat. 190 */ 191void 192ccw_device_accumulate_irb(struct ccw_device *cdev, struct irb *irb) 193{ 194 struct irb *cdev_irb; 195 196 /* 197 * Check if the status pending bit is set in stctl. 198 * If not, the remaining bit have no meaning and we must ignore them. 199 * The esw is not meaningful as well... 200 */ 201 if (!(irb->scsw.stctl & SCSW_STCTL_STATUS_PEND)) 202 return; 203 204 /* Check for channel checks and interface control checks. */ 205 ccw_device_msg_control_check(cdev, irb); 206 207 /* Check for path not operational. */ 208 if (irb->scsw.pno && irb->scsw.fctl != 0 && 209 (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) || 210 (irb->scsw.actl & SCSW_ACTL_SUSPENDED))) 211 ccw_device_path_notoper(cdev); 212 213 /* 214 * Don't accumulate unsolicited interrupts. 215 */ 216 if ((irb->scsw.stctl == 217 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) && 218 (!irb->scsw.cc)) 219 return; 220 221 cdev_irb = &cdev->private->irb; 222 223 /* 224 * If the clear function had been performed, all formerly pending 225 * status at the subchannel has been cleared and we must not pass 226 * intermediate accumulated status to the device driver. 227 */ 228 if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) 229 memset(&cdev->private->irb, 0, sizeof(struct irb)); 230 231 /* Copy bits which are valid only for the start function. */ 232 if (irb->scsw.fctl & SCSW_FCTL_START_FUNC) { 233 /* Copy key. */ 234 cdev_irb->scsw.key = irb->scsw.key; 235 /* Copy suspend control bit. */ 236 cdev_irb->scsw.sctl = irb->scsw.sctl; 237 /* Accumulate deferred condition code. */ 238 cdev_irb->scsw.cc |= irb->scsw.cc; 239 /* Copy ccw format bit. */ 240 cdev_irb->scsw.fmt = irb->scsw.fmt; 241 /* Copy prefetch bit. */ 242 cdev_irb->scsw.pfch = irb->scsw.pfch; 243 /* Copy initial-status-interruption-control. */ 244 cdev_irb->scsw.isic = irb->scsw.isic; 245 /* Copy address limit checking control. */ 246 cdev_irb->scsw.alcc = irb->scsw.alcc; 247 /* Copy suppress suspend bit. */ 248 cdev_irb->scsw.ssi = irb->scsw.ssi; 249 } 250 251 /* Take care of the extended control bit and extended control word. */ 252 ccw_device_accumulate_ecw(cdev, irb); 253 254 /* Accumulate function control. */ 255 cdev_irb->scsw.fctl |= irb->scsw.fctl; 256 /* Copy activity control. */ 257 cdev_irb->scsw.actl= irb->scsw.actl; 258 /* Accumulate status control. */ 259 cdev_irb->scsw.stctl |= irb->scsw.stctl; 260 /* 261 * Copy ccw address if it is valid. This is a bit simplified 262 * but should be close enough for all practical purposes. 263 */ 264 if ((irb->scsw.stctl & SCSW_STCTL_PRIM_STATUS) || 265 ((irb->scsw.stctl == 266 (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) && 267 (irb->scsw.actl & SCSW_ACTL_DEVACT) && 268 (irb->scsw.actl & SCSW_ACTL_SCHACT)) || 269 (irb->scsw.actl & SCSW_ACTL_SUSPENDED)) 270 cdev_irb->scsw.cpa = irb->scsw.cpa; 271 /* Accumulate device status, but not the device busy flag. */ 272 cdev_irb->scsw.dstat &= ~DEV_STAT_BUSY; 273 /* dstat is not always valid. */ 274 if (irb->scsw.stctl & 275 (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS 276 | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS)) 277 cdev_irb->scsw.dstat |= irb->scsw.dstat; 278 /* Accumulate subchannel status. */ 279 cdev_irb->scsw.cstat |= irb->scsw.cstat; 280 /* Copy residual count if it is valid. */ 281 if ((irb->scsw.stctl & SCSW_STCTL_PRIM_STATUS) && 282 (irb->scsw.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN)) == 0) 283 cdev_irb->scsw.count = irb->scsw.count; 284 285 /* Take care of bits in the extended status word. */ 286 ccw_device_accumulate_esw(cdev, irb); 287 288 /* 289 * Check whether we must issue a SENSE CCW ourselves if there is no 290 * concurrent sense facility installed for the subchannel. 291 * No sense is required if no delayed sense is pending 292 * and we did not get a unit check without sense information. 293 * 294 * Note: We should check for ioinfo[irq]->flags.consns but VM 295 * violates the ESA/390 architecture and doesn't present an 296 * operand exception for virtual devices without concurrent 297 * sense facility available/supported when enabling the 298 * concurrent sense facility. 299 */ 300 if ((cdev_irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && 301 !(cdev_irb->esw.esw0.erw.cons)) 302 cdev->private->flags.dosense = 1; 303} 304 305/* 306 * Do a basic sense. 307 */ 308int 309ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb) 310{ 311 struct subchannel *sch; 312 313 sch = to_subchannel(cdev->dev.parent); 314 315 /* A sense is required, can we do it now ? */ 316 if ((irb->scsw.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0) 317 /* 318 * we received an Unit Check but we have no final 319 * status yet, therefore we must delay the SENSE 320 * processing. We must not report this intermediate 321 * status to the device interrupt handler. 322 */ 323 return -EBUSY; 324 325 /* 326 * We have ending status but no sense information. Do a basic sense. 327 */ 328 sch->sense_ccw.cmd_code = CCW_CMD_BASIC_SENSE; 329 sch->sense_ccw.cda = (__u32) __pa(cdev->private->irb.ecw); 330 sch->sense_ccw.count = SENSE_MAX_COUNT; 331 sch->sense_ccw.flags = CCW_FLAG_SLI; 332 333 /* Reset internal retry indication. */ 334 cdev->private->flags.intretry = 0; 335 336 return cio_start (sch, &sch->sense_ccw, 0xff); 337} 338 339/* 340 * Add information from basic sense to devstat. 341 */ 342void 343ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb) 344{ 345 /* 346 * Check if the status pending bit is set in stctl. 347 * If not, the remaining bit have no meaning and we must ignore them. 348 * The esw is not meaningful as well... 349 */ 350 if (!(irb->scsw.stctl & SCSW_STCTL_STATUS_PEND)) 351 return; 352 353 /* Check for channel checks and interface control checks. */ 354 ccw_device_msg_control_check(cdev, irb); 355 356 /* Check for path not operational. */ 357 if (irb->scsw.pno && irb->scsw.fctl != 0 && 358 (!(irb->scsw.stctl & SCSW_STCTL_INTER_STATUS) || 359 (irb->scsw.actl & SCSW_ACTL_SUSPENDED))) 360 ccw_device_path_notoper(cdev); 361 362 if (!(irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && 363 (irb->scsw.dstat & DEV_STAT_CHN_END)) { 364 cdev->private->irb.esw.esw0.erw.cons = 1; 365 cdev->private->flags.dosense = 0; 366 } 367 /* Check if path verification is required. */ 368 if (ccw_device_accumulate_esw_valid(irb) && 369 irb->esw.esw0.erw.pvrf) 370 cdev->private->flags.doverify = 1; 371} 372 373/* 374 * This function accumulates the status into the private devstat and 375 * starts a basic sense if one is needed. 376 */ 377int 378ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb) 379{ 380 ccw_device_accumulate_irb(cdev, irb); 381 if ((irb->scsw.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0) 382 return -EBUSY; 383 /* Check for basic sense. */ 384 if (cdev->private->flags.dosense && 385 !(irb->scsw.dstat & DEV_STAT_UNIT_CHECK)) { 386 cdev->private->irb.esw.esw0.erw.cons = 1; 387 cdev->private->flags.dosense = 0; 388 return 0; 389 } 390 if (cdev->private->flags.dosense) { 391 ccw_device_do_sense(cdev, irb); 392 return -EBUSY; 393 } 394 return 0; 395} 396