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 */ 29static void 30ccw_device_msg_control_check(struct ccw_device *cdev, struct irb *irb) 31{ 32 char dbf_text[15]; 33 34 if (!scsw_is_valid_cstat(&irb->scsw) || 35 !(scsw_cstat(&irb->scsw) & (SCHN_STAT_CHN_DATA_CHK | 36 SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK))) 37 return; 38 CIO_MSG_EVENT(0, "Channel-Check or Interface-Control-Check " 39 "received" 40 " ... device %04x on subchannel 0.%x.%04x, dev_stat " 41 ": %02X sch_stat : %02X\n", 42 cdev->private->dev_id.devno, cdev->private->schid.ssid, 43 cdev->private->schid.sch_no, 44 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw)); 45 sprintf(dbf_text, "chk%x", cdev->private->schid.sch_no); 46 CIO_TRACE_EVENT(0, dbf_text); 47 CIO_HEX_EVENT(0, irb, sizeof(struct irb)); 48} 49 50/* 51 * Some paths became not operational (pno bit in scsw is set). 52 */ 53static void 54ccw_device_path_notoper(struct ccw_device *cdev) 55{ 56 struct subchannel *sch; 57 58 sch = to_subchannel(cdev->dev.parent); 59 if (cio_update_schib(sch)) 60 goto doverify; 61 62 CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are " 63 "not operational \n", __func__, 64 sch->schid.ssid, sch->schid.sch_no, 65 sch->schib.pmcw.pnom); 66 67 sch->lpm &= ~sch->schib.pmcw.pnom; 68doverify: 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.cmd.ectl = 0; 84 if ((irb->scsw.cmd.stctl & SCSW_STCTL_ALERT_STATUS) && 85 !(irb->scsw.cmd.stctl & SCSW_STCTL_INTER_STATUS)) 86 cdev->private->irb.scsw.cmd.ectl = irb->scsw.cmd.ectl; 87 /* Check if extended control word is valid. */ 88 if (!cdev->private->irb.scsw.cmd.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.cmd.eswf && 101 (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND)) 102 return 0; 103 if (irb->scsw.cmd.stctl == 104 (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) && 105 !(irb->scsw.cmd.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 */ 113static void 114ccw_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.cmd.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.cmd.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.cmd.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 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 */ 192void 193ccw_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 (!(scsw_stctl(&irb->scsw) & 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 (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw)) 210 ccw_device_path_notoper(cdev); 211 /* No irb accumulation for transport mode irbs. */ 212 if (scsw_is_tm(&irb->scsw)) { 213 memcpy(&cdev->private->irb, irb, sizeof(struct irb)); 214 return; 215 } 216 /* 217 * Don't accumulate unsolicited interrupts. 218 */ 219 if (!scsw_is_solicited(&irb->scsw)) 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.cmd.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.cmd.fctl & SCSW_FCTL_START_FUNC) { 234 /* Copy key. */ 235 cdev_irb->scsw.cmd.key = irb->scsw.cmd.key; 236 /* Copy suspend control bit. */ 237 cdev_irb->scsw.cmd.sctl = irb->scsw.cmd.sctl; 238 /* Accumulate deferred condition code. */ 239 cdev_irb->scsw.cmd.cc |= irb->scsw.cmd.cc; 240 /* Copy ccw format bit. */ 241 cdev_irb->scsw.cmd.fmt = irb->scsw.cmd.fmt; 242 /* Copy prefetch bit. */ 243 cdev_irb->scsw.cmd.pfch = irb->scsw.cmd.pfch; 244 /* Copy initial-status-interruption-control. */ 245 cdev_irb->scsw.cmd.isic = irb->scsw.cmd.isic; 246 /* Copy address limit checking control. */ 247 cdev_irb->scsw.cmd.alcc = irb->scsw.cmd.alcc; 248 /* Copy suppress suspend bit. */ 249 cdev_irb->scsw.cmd.ssi = irb->scsw.cmd.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.cmd.fctl |= irb->scsw.cmd.fctl; 257 /* Copy activity control. */ 258 cdev_irb->scsw.cmd.actl = irb->scsw.cmd.actl; 259 /* Accumulate status control. */ 260 cdev_irb->scsw.cmd.stctl |= irb->scsw.cmd.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.cmd.stctl & SCSW_STCTL_PRIM_STATUS) || 266 ((irb->scsw.cmd.stctl == 267 (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) && 268 (irb->scsw.cmd.actl & SCSW_ACTL_DEVACT) && 269 (irb->scsw.cmd.actl & SCSW_ACTL_SCHACT)) || 270 (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)) 271 cdev_irb->scsw.cmd.cpa = irb->scsw.cmd.cpa; 272 /* Accumulate device status, but not the device busy flag. */ 273 cdev_irb->scsw.cmd.dstat &= ~DEV_STAT_BUSY; 274 /* dstat is not always valid. */ 275 if (irb->scsw.cmd.stctl & 276 (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS 277 | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS)) 278 cdev_irb->scsw.cmd.dstat |= irb->scsw.cmd.dstat; 279 /* Accumulate subchannel status. */ 280 cdev_irb->scsw.cmd.cstat |= irb->scsw.cmd.cstat; 281 /* Copy residual count if it is valid. */ 282 if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) && 283 (irb->scsw.cmd.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN)) 284 == 0) 285 cdev_irb->scsw.cmd.count = irb->scsw.cmd.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.cmd.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 */ 310int 311ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb) 312{ 313 struct subchannel *sch; 314 struct ccw1 *sense_ccw; 315 int rc; 316 317 sch = to_subchannel(cdev->dev.parent); 318 319 /* A sense is required, can we do it now ? */ 320 if (scsw_actl(&irb->scsw) & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) 321 /* 322 * we received an Unit Check but we have no final 323 * status yet, therefore we must delay the SENSE 324 * processing. We must not report this intermediate 325 * status to the device interrupt handler. 326 */ 327 return -EBUSY; 328 329 /* 330 * We have ending status but no sense information. Do a basic sense. 331 */ 332 sense_ccw = &to_io_private(sch)->sense_ccw; 333 sense_ccw->cmd_code = CCW_CMD_BASIC_SENSE; 334 sense_ccw->cda = (__u32) __pa(cdev->private->irb.ecw); 335 sense_ccw->count = SENSE_MAX_COUNT; 336 sense_ccw->flags = CCW_FLAG_SLI; 337 338 rc = cio_start(sch, sense_ccw, 0xff); 339 if (rc == -ENODEV || rc == -EACCES) 340 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 341 return rc; 342} 343 344/* 345 * Add information from basic sense to devstat. 346 */ 347void 348ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb) 349{ 350 /* 351 * Check if the status pending bit is set in stctl. 352 * If not, the remaining bit have no meaning and we must ignore them. 353 * The esw is not meaningful as well... 354 */ 355 if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND)) 356 return; 357 358 /* Check for channel checks and interface control checks. */ 359 ccw_device_msg_control_check(cdev, irb); 360 361 /* Check for path not operational. */ 362 if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw)) 363 ccw_device_path_notoper(cdev); 364 365 if (!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) && 366 (irb->scsw.cmd.dstat & DEV_STAT_CHN_END)) { 367 cdev->private->irb.esw.esw0.erw.cons = 1; 368 cdev->private->flags.dosense = 0; 369 } 370 /* Check if path verification is required. */ 371 if (ccw_device_accumulate_esw_valid(irb) && 372 irb->esw.esw0.erw.pvrf) 373 cdev->private->flags.doverify = 1; 374} 375 376/* 377 * This function accumulates the status into the private devstat and 378 * starts a basic sense if one is needed. 379 */ 380int 381ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb) 382{ 383 ccw_device_accumulate_irb(cdev, irb); 384 if ((irb->scsw.cmd.actl & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0) 385 return -EBUSY; 386 /* Check for basic sense. */ 387 if (cdev->private->flags.dosense && 388 !(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) { 389 cdev->private->irb.esw.esw0.erw.cons = 1; 390 cdev->private->flags.dosense = 0; 391 return 0; 392 } 393 if (cdev->private->flags.dosense) { 394 ccw_device_do_sense(cdev, irb); 395 return -EBUSY; 396 } 397 return 0; 398} 399