git.oblomov.eu Git - linux-2.6/blob - drivers/s390/cio/device_status.c

   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         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  */
  53 static void
  54 ccw_device_path_notoper(struct ccw_device *cdev)
  55 {
  56         struct subchannel *sch;
  57
  58         sch = to_subchannel(cdev->dev.parent);
  59         stsch (sch->schid, &sch->schib);
  60
  61         CIO_MSG_EVENT(0, "%s(0.%x.%04x) - path(s) %02x are "
  62                       "not operational \n", __func__,
  63                       sch->schid.ssid, sch->schid.sch_no,
  64                       sch->schib.pmcw.pnom);
  65
  66         sch->lpm &= ~sch->schib.pmcw.pnom;
  67         cdev->private->flags.doverify = 1;
  68 }
  69
  70 /*
  71  * Copy valid bits from the extended control word to device irb.
  72  */
  73 static void
  74 ccw_device_accumulate_ecw(struct ccw_device *cdev, struct irb *irb)
  75 {
  76         /*
  77          * Copy extended control bit if it is valid... yes there
  78          * are condition that have to be met for the extended control
  79          * bit to have meaning. Sick.
  80          */
  81         cdev->private->irb.scsw.cmd.ectl = 0;
  82         if ((irb->scsw.cmd.stctl & SCSW_STCTL_ALERT_STATUS) &&
  83             !(irb->scsw.cmd.stctl & SCSW_STCTL_INTER_STATUS))
  84                 cdev->private->irb.scsw.cmd.ectl = irb->scsw.cmd.ectl;
  85         /* Check if extended control word is valid. */
  86         if (!cdev->private->irb.scsw.cmd.ectl)
  87                 return;
  88         /* Copy concurrent sense / model dependent information. */
  89         memcpy (&cdev->private->irb.ecw, irb->ecw, sizeof (irb->ecw));
  90 }
  91
  92 /*
  93  * Check if extended status word is valid.
  94  */
  95 static int
  96 ccw_device_accumulate_esw_valid(struct irb *irb)
  97 {
  98         if (!irb->scsw.cmd.eswf &&
  99             (irb->scsw.cmd.stctl == SCSW_STCTL_STATUS_PEND))
 100                 return 0;
 101         if (irb->scsw.cmd.stctl ==
 102                         (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND) &&
 103             !(irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
 104                 return 0;
 105         return 1;
 106 }
 107
 108 /*
 109  * Copy valid bits from the extended status word to device irb.
 110  */
 111 static void
 112 ccw_device_accumulate_esw(struct ccw_device *cdev, struct irb *irb)
 113 {
 114         struct irb *cdev_irb;
 115         struct sublog *cdev_sublog, *sublog;
 116
 117         if (!ccw_device_accumulate_esw_valid(irb))
 118                 return;
 119
 120         cdev_irb = &cdev->private->irb;
 121
 122         /* Copy last path used mask. */
 123         cdev_irb->esw.esw1.lpum = irb->esw.esw1.lpum;
 124
 125         /* Copy subchannel logout information if esw is of format 0. */
 126         if (irb->scsw.cmd.eswf) {
 127                 cdev_sublog = &cdev_irb->esw.esw0.sublog;
 128                 sublog = &irb->esw.esw0.sublog;
 129                 /* Copy extended status flags. */
 130                 cdev_sublog->esf = sublog->esf;
 131                 /*
 132                  * Copy fields that have a meaning for channel data check
 133                  * channel control check and interface control check.
 134                  */
 135                 if (irb->scsw.cmd.cstat & (SCHN_STAT_CHN_DATA_CHK |
 136                                        SCHN_STAT_CHN_CTRL_CHK |
 137                                        SCHN_STAT_INTF_CTRL_CHK)) {
 138                         /* Copy ancillary report bit. */
 139                         cdev_sublog->arep = sublog->arep;
 140                         /* Copy field-validity-flags. */
 141                         cdev_sublog->fvf = sublog->fvf;
 142                         /* Copy storage access code. */
 143                         cdev_sublog->sacc = sublog->sacc;
 144                         /* Copy termination code. */
 145                         cdev_sublog->termc = sublog->termc;
 146                         /* Copy sequence code. */
 147                         cdev_sublog->seqc = sublog->seqc;
 148                 }
 149                 /* Copy device status check. */
 150                 cdev_sublog->devsc = sublog->devsc;
 151                 /* Copy secondary error. */
 152                 cdev_sublog->serr = sublog->serr;
 153                 /* Copy i/o-error alert. */
 154                 cdev_sublog->ioerr = sublog->ioerr;
 155                 /* Copy channel path timeout bit. */
 156                 if (irb->scsw.cmd.cstat & SCHN_STAT_INTF_CTRL_CHK)
 157                         cdev_irb->esw.esw0.erw.cpt = irb->esw.esw0.erw.cpt;
 158                 /* Copy failing storage address validity flag. */
 159                 cdev_irb->esw.esw0.erw.fsavf = irb->esw.esw0.erw.fsavf;
 160                 if (cdev_irb->esw.esw0.erw.fsavf) {
 161                         /* ... and copy the failing storage address. */
 162                         memcpy(cdev_irb->esw.esw0.faddr, irb->esw.esw0.faddr,
 163                                sizeof (irb->esw.esw0.faddr));
 164                         /* ... and copy the failing storage address format. */
 165                         cdev_irb->esw.esw0.erw.fsaf = irb->esw.esw0.erw.fsaf;
 166                 }
 167                 /* Copy secondary ccw address validity bit. */
 168                 cdev_irb->esw.esw0.erw.scavf = irb->esw.esw0.erw.scavf;
 169                 if (irb->esw.esw0.erw.scavf)
 170                         /* ... and copy the secondary ccw address. */
 171                         cdev_irb->esw.esw0.saddr = irb->esw.esw0.saddr;
 172
 173         }
 174         /* FIXME: DCTI for format 2? */
 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  */
 191 void
 192 ccw_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 (!(scsw_stctl(&irb->scsw) & 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 (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
 209                 ccw_device_path_notoper(cdev);
 210         /* No irb accumulation for transport mode irbs. */
 211         if (scsw_is_tm(&irb->scsw)) {
 212                 memcpy(&cdev->private->irb, irb, sizeof(struct irb));
 213                 return;
 214         }
 215         /*
 216          * Don't accumulate unsolicited interrupts.
 217          */
 218         if (!scsw_is_solicited(&irb->scsw))
 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.cmd.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.cmd.fctl & SCSW_FCTL_START_FUNC) {
 233                 /* Copy key. */
 234                 cdev_irb->scsw.cmd.key = irb->scsw.cmd.key;
 235                 /* Copy suspend control bit. */
 236                 cdev_irb->scsw.cmd.sctl = irb->scsw.cmd.sctl;
 237                 /* Accumulate deferred condition code. */
 238                 cdev_irb->scsw.cmd.cc |= irb->scsw.cmd.cc;
 239                 /* Copy ccw format bit. */
 240                 cdev_irb->scsw.cmd.fmt = irb->scsw.cmd.fmt;
 241                 /* Copy prefetch bit. */
 242                 cdev_irb->scsw.cmd.pfch = irb->scsw.cmd.pfch;
 243                 /* Copy initial-status-interruption-control. */
 244                 cdev_irb->scsw.cmd.isic = irb->scsw.cmd.isic;
 245                 /* Copy address limit checking control. */
 246                 cdev_irb->scsw.cmd.alcc = irb->scsw.cmd.alcc;
 247                 /* Copy suppress suspend bit. */
 248                 cdev_irb->scsw.cmd.ssi = irb->scsw.cmd.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.cmd.fctl |= irb->scsw.cmd.fctl;
 256         /* Copy activity control. */
 257         cdev_irb->scsw.cmd.actl = irb->scsw.cmd.actl;
 258         /* Accumulate status control. */
 259         cdev_irb->scsw.cmd.stctl |= irb->scsw.cmd.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.cmd.stctl & SCSW_STCTL_PRIM_STATUS) ||
 265             ((irb->scsw.cmd.stctl ==
 266               (SCSW_STCTL_INTER_STATUS|SCSW_STCTL_STATUS_PEND)) &&
 267              (irb->scsw.cmd.actl & SCSW_ACTL_DEVACT) &&
 268              (irb->scsw.cmd.actl & SCSW_ACTL_SCHACT)) ||
 269             (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
 270                 cdev_irb->scsw.cmd.cpa = irb->scsw.cmd.cpa;
 271         /* Accumulate device status, but not the device busy flag. */
 272         cdev_irb->scsw.cmd.dstat &= ~DEV_STAT_BUSY;
 273         /* dstat is not always valid. */
 274         if (irb->scsw.cmd.stctl &
 275             (SCSW_STCTL_PRIM_STATUS | SCSW_STCTL_SEC_STATUS
 276              | SCSW_STCTL_INTER_STATUS | SCSW_STCTL_ALERT_STATUS))
 277                 cdev_irb->scsw.cmd.dstat |= irb->scsw.cmd.dstat;
 278         /* Accumulate subchannel status. */
 279         cdev_irb->scsw.cmd.cstat |= irb->scsw.cmd.cstat;
 280         /* Copy residual count if it is valid. */
 281         if ((irb->scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
 282             (irb->scsw.cmd.cstat & ~(SCHN_STAT_PCI | SCHN_STAT_INCORR_LEN))
 283              == 0)
 284                 cdev_irb->scsw.cmd.count = irb->scsw.cmd.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.cmd.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         struct ccw1 *sense_ccw;
 314         int rc;
 315
 316         sch = to_subchannel(cdev->dev.parent);
 317
 318         /* A sense is required, can we do it now ? */
 319         if (scsw_actl(&irb->scsw) & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT))
 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         rc = cio_start(sch, sense_ccw, 0xff);
 341         if (rc == -ENODEV || rc == -EACCES)
 342                 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 343         return rc;
 344 }
 345
 346 /*
 347  * Add information from basic sense to devstat.
 348  */
 349 void
 350 ccw_device_accumulate_basic_sense(struct ccw_device *cdev, struct irb *irb)
 351 {
 352         /*
 353          * Check if the status pending bit is set in stctl.
 354          * If not, the remaining bit have no meaning and we must ignore them.
 355          * The esw is not meaningful as well...
 356          */
 357         if (!(scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))
 358                 return;
 359
 360         /* Check for channel checks and interface control checks. */
 361         ccw_device_msg_control_check(cdev, irb);
 362
 363         /* Check for path not operational. */
 364         if (scsw_is_valid_pno(&irb->scsw) && scsw_pno(&irb->scsw))
 365                 ccw_device_path_notoper(cdev);
 366
 367         if (!(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
 368             (irb->scsw.cmd.dstat & DEV_STAT_CHN_END)) {
 369                 cdev->private->irb.esw.esw0.erw.cons = 1;
 370                 cdev->private->flags.dosense = 0;
 371         }
 372         /* Check if path verification is required. */
 373         if (ccw_device_accumulate_esw_valid(irb) &&
 374             irb->esw.esw0.erw.pvrf)
 375                 cdev->private->flags.doverify = 1;
 376 }
 377
 378 /*
 379  * This function accumulates the status into the private devstat and
 380  * starts a basic sense if one is needed.
 381  */
 382 int
 383 ccw_device_accumulate_and_sense(struct ccw_device *cdev, struct irb *irb)
 384 {
 385         ccw_device_accumulate_irb(cdev, irb);
 386         if ((irb->scsw.cmd.actl  & (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) != 0)
 387                 return -EBUSY;
 388         /* Check for basic sense. */
 389         if (cdev->private->flags.dosense &&
 390             !(irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) {
 391                 cdev->private->irb.esw.esw0.erw.cons = 1;
 392                 cdev->private->flags.dosense = 0;
 393                 return 0;
 394         }
 395         if (cdev->private->flags.dosense) {
 396                 ccw_device_do_sense(cdev, irb);
 397                 return -EBUSY;
 398         }
 399         return 0;
 400 }
 401