drivers/s390/cio/ccwreq.c

   1 /*
   2  *  Handling of internal CCW device requests.
   3  *
   4  *    Copyright IBM Corp. 2009, 2011
   5  *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   6  */
   7
   8 #define KMSG_COMPONENT "cio"
   9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  10
  11 #include <linux/types.h>
  12 #include <linux/err.h>
  13 #include <asm/ccwdev.h>
  14 #include <asm/cio.h>
  15
  16 #include "io_sch.h"
  17 #include "cio.h"
  18 #include "device.h"
  19 #include "cio_debug.h"
  20
  21 /**
  22  * lpm_adjust - adjust path mask
  23  * @lpm: path mask to adjust
  24  * @mask: mask of available paths
  25  *
  26  * Shift @lpm right until @lpm and @mask have at least one bit in common or
  27  * until @lpm is zero. Return the resulting lpm.
  28  */
  29 int lpm_adjust(int lpm, int mask)
  30 {
  31         while (lpm && ((lpm & mask) == 0))
  32                 lpm >>= 1;
  33         return lpm;
  34 }
  35
  36 /*
  37  * Adjust path mask to use next path and reset retry count. Return resulting
  38  * path mask.
  39  */
  40 static u16 ccwreq_next_path(struct ccw_device *cdev)
  41 {
  42         struct ccw_request *req = &cdev->private->req;
  43
  44         if (!req->singlepath) {
  45                 req->mask = 0;
  46                 goto out;
  47         }
  48         req->retries    = req->maxretries;
  49         req->mask       = lpm_adjust(req->mask >> 1, req->lpm);
  50 out:
  51         return req->mask;
  52 }
  53
  54 /*
  55  * Clean up device state and report to callback.
  56  */
  57 static void ccwreq_stop(struct ccw_device *cdev, int rc)
  58 {
  59         struct ccw_request *req = &cdev->private->req;
  60
  61         if (req->done)
  62                 return;
  63         req->done = 1;
  64         ccw_device_set_timeout(cdev, 0);
  65         memset(&cdev->private->irb, 0, sizeof(struct irb));
  66         if (rc && rc != -ENODEV && req->drc)
  67                 rc = req->drc;
  68         req->callback(cdev, req->data, rc);
  69 }
  70
  71 /*
  72  * (Re-)Start the operation until retries and paths are exhausted.
  73  */
  74 static void ccwreq_do(struct ccw_device *cdev)
  75 {
  76         struct ccw_request *req = &cdev->private->req;
  77         struct subchannel *sch = to_subchannel(cdev->dev.parent);
  78         struct ccw1 *cp = req->cp;
  79         int rc = -EACCES;
  80
  81         while (req->mask) {
  82                 if (req->retries-- == 0) {
  83                         /* Retries exhausted, try next path. */
  84                         ccwreq_next_path(cdev);
  85                         continue;
  86                 }
  87                 /* Perform start function. */
  88                 memset(&cdev->private->irb, 0, sizeof(struct irb));
  89                 rc = cio_start(sch, cp, (u8) req->mask);
  90                 if (rc == 0) {
  91                         /* I/O started successfully. */
  92                         ccw_device_set_timeout(cdev, req->timeout);
  93                         return;
  94                 }
  95                 if (rc == -ENODEV) {
  96                         /* Permanent device error. */
  97                         break;
  98                 }
  99                 if (rc == -EACCES) {
 100                         /* Permant path error. */
 101                         ccwreq_next_path(cdev);
 102                         continue;
 103                 }
 104                 /* Temporary improper status. */
 105                 rc = cio_clear(sch);
 106                 if (rc)
 107                         break;
 108                 return;
 109         }
 110         ccwreq_stop(cdev, rc);
 111 }
 112
 113 /**
 114  * ccw_request_start - perform I/O request
 115  * @cdev: ccw device
 116  *
 117  * Perform the I/O request specified by cdev->req.
 118  */
 119 void ccw_request_start(struct ccw_device *cdev)
 120 {
 121         struct ccw_request *req = &cdev->private->req;
 122
 123         if (req->singlepath) {
 124                 /* Try all paths twice to counter link flapping. */
 125                 req->mask = 0x8080;
 126         } else
 127                 req->mask = req->lpm;
 128
 129         req->retries    = req->maxretries;
 130         req->mask       = lpm_adjust(req->mask, req->lpm);
 131         req->drc        = 0;
 132         req->done       = 0;
 133         req->cancel     = 0;
 134         if (!req->mask)
 135                 goto out_nopath;
 136         ccwreq_do(cdev);
 137         return;
 138
 139 out_nopath:
 140         ccwreq_stop(cdev, -EACCES);
 141 }
 142
 143 /**
 144  * ccw_request_cancel - cancel running I/O request
 145  * @cdev: ccw device
 146  *
 147  * Cancel the I/O request specified by cdev->req. Return non-zero if request
 148  * has already finished, zero otherwise.
 149  */
 150 int ccw_request_cancel(struct ccw_device *cdev)
 151 {
 152         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 153         struct ccw_request *req = &cdev->private->req;
 154         int rc;
 155
 156         if (req->done)
 157                 return 1;
 158         req->cancel = 1;
 159         rc = cio_clear(sch);
 160         if (rc)
 161                 ccwreq_stop(cdev, rc);
 162         return 0;
 163 }
 164
 165 /*
 166  * Return the status of the internal I/O started on the specified ccw device.
 167  * Perform BASIC SENSE if required.
 168  */
 169 static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
 170 {
 171         struct irb *irb = &cdev->private->irb;
 172         struct cmd_scsw *scsw = &irb->scsw.cmd;
 173         enum uc_todo todo;
 174
 175         /* Perform BASIC SENSE if needed. */
 176         if (ccw_device_accumulate_and_sense(cdev, lcirb))
 177                 return IO_RUNNING;
 178         /* Check for halt/clear interrupt. */
 179         if (scsw->fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC))
 180                 return IO_KILLED;
 181         /* Check for path error. */
 182         if (scsw->cc == 3 || scsw->pno)
 183                 return IO_PATH_ERROR;
 184         /* Handle BASIC SENSE data. */
 185         if (irb->esw.esw0.erw.cons) {
 186                 CIO_TRACE_EVENT(2, "sensedata");
 187                 CIO_HEX_EVENT(2, &cdev->private->dev_id,
 188                               sizeof(struct ccw_dev_id));
 189                 CIO_HEX_EVENT(2, &cdev->private->irb.ecw, SENSE_MAX_COUNT);
 190                 /* Check for command reject. */
 191                 if (irb->ecw[0] & SNS0_CMD_REJECT)
 192                         return IO_REJECTED;
 193                 /* Ask the driver what to do */
 194                 if (cdev->drv && cdev->drv->uc_handler) {
 195                         todo = cdev->drv->uc_handler(cdev, lcirb);
 196                         CIO_TRACE_EVENT(2, "uc_response");
 197                         CIO_HEX_EVENT(2, &todo, sizeof(todo));
 198                         switch (todo) {
 199                         case UC_TODO_RETRY:
 200                                 return IO_STATUS_ERROR;
 201                         case UC_TODO_RETRY_ON_NEW_PATH:
 202                                 return IO_PATH_ERROR;
 203                         case UC_TODO_STOP:
 204                                 return IO_REJECTED;
 205                         default:
 206                                 return IO_STATUS_ERROR;
 207                         }
 208                 }
 209                 /* Assume that unexpected SENSE data implies an error. */
 210                 return IO_STATUS_ERROR;
 211         }
 212         /* Check for channel errors. */
 213         if (scsw->cstat != 0)
 214                 return IO_STATUS_ERROR;
 215         /* Check for device errors. */
 216         if (scsw->dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
 217                 return IO_STATUS_ERROR;
 218         /* Check for final state. */
 219         if (!(scsw->dstat & DEV_STAT_DEV_END))
 220                 return IO_RUNNING;
 221         /* Check for other improper status. */
 222         if (scsw->cc == 1 && (scsw->stctl & SCSW_STCTL_ALERT_STATUS))
 223                 return IO_STATUS_ERROR;
 224         return IO_DONE;
 225 }
 226
 227 /*
 228  * Log ccw request status.
 229  */
 230 static void ccwreq_log_status(struct ccw_device *cdev, enum io_status status)
 231 {
 232         struct ccw_request *req = &cdev->private->req;
 233         struct {
 234                 struct ccw_dev_id dev_id;
 235                 u16 retries;
 236                 u8 lpm;
 237                 u8 status;
 238         }  __attribute__ ((packed)) data;
 239         data.dev_id     = cdev->private->dev_id;
 240         data.retries    = req->retries;
 241         data.lpm        = (u8) req->mask;
 242         data.status     = (u8) status;
 243         CIO_TRACE_EVENT(2, "reqstat");
 244         CIO_HEX_EVENT(2, &data, sizeof(data));
 245 }
 246
 247 /**
 248  * ccw_request_handler - interrupt handler for I/O request procedure.
 249  * @cdev: ccw device
 250  *
 251  * Handle interrupt during I/O request procedure.
 252  */
 253 void ccw_request_handler(struct ccw_device *cdev)
 254 {
 255         struct irb *irb = this_cpu_ptr(&cio_irb);
 256         struct ccw_request *req = &cdev->private->req;
 257         enum io_status status;
 258         int rc = -EOPNOTSUPP;
 259
 260         /* Check status of I/O request. */
 261         status = ccwreq_status(cdev, irb);
 262         if (req->filter)
 263                 status = req->filter(cdev, req->data, irb, status);
 264         if (status != IO_RUNNING)
 265                 ccw_device_set_timeout(cdev, 0);
 266         if (status != IO_DONE && status != IO_RUNNING)
 267                 ccwreq_log_status(cdev, status);
 268         switch (status) {
 269         case IO_DONE:
 270                 break;
 271         case IO_RUNNING:
 272                 return;
 273         case IO_REJECTED:
 274                 goto err;
 275         case IO_PATH_ERROR:
 276                 goto out_next_path;
 277         case IO_STATUS_ERROR:
 278                 goto out_restart;
 279         case IO_KILLED:
 280                 /* Check if request was cancelled on purpose. */
 281                 if (req->cancel) {
 282                         rc = -EIO;
 283                         goto err;
 284                 }
 285                 goto out_restart;
 286         }
 287         /* Check back with request initiator. */
 288         if (!req->check)
 289                 goto out;
 290         switch (req->check(cdev, req->data)) {
 291         case 0:
 292                 break;
 293         case -EAGAIN:
 294                 goto out_restart;
 295         case -EACCES:
 296                 goto out_next_path;
 297         default:
 298                 goto err;
 299         }
 300 out:
 301         ccwreq_stop(cdev, 0);
 302         return;
 303
 304 out_next_path:
 305         /* Try next path and restart I/O. */
 306         if (!ccwreq_next_path(cdev)) {
 307                 rc = -EACCES;
 308                 goto err;
 309         }
 310 out_restart:
 311         /* Restart. */
 312         ccwreq_do(cdev);
 313         return;
 314 err:
 315         ccwreq_stop(cdev, rc);
 316 }
 317
 318
 319 /**
 320  * ccw_request_timeout - timeout handler for I/O request procedure
 321  * @cdev: ccw device
 322  *
 323  * Handle timeout during I/O request procedure.
 324  */
 325 void ccw_request_timeout(struct ccw_device *cdev)
 326 {
 327         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 328         struct ccw_request *req = &cdev->private->req;
 329         int rc = -ENODEV, chp;
 330
 331         if (cio_update_schib(sch))
 332                 goto err;
 333
 334         for (chp = 0; chp < 8; chp++) {
 335                 if ((0x80 >> chp) & sch->schib.pmcw.lpum)
 336                         pr_warn("%s: No interrupt was received within %lus (CS=%02x, DS=%02x, CHPID=%x.%02x)\n",
 337                                 dev_name(&cdev->dev), req->timeout / HZ,
 338                                 scsw_cstat(&sch->schib.scsw),
 339                                 scsw_dstat(&sch->schib.scsw),
 340                                 sch->schid.cssid,
 341                                 sch->schib.pmcw.chpid[chp]);
 342         }
 343
 344         if (!ccwreq_next_path(cdev)) {
 345                 /* set the final return code for this request */
 346                 req->drc = -ETIME;
 347         }
 348         rc = cio_clear(sch);
 349         if (rc)
 350                 goto err;
 351         return;
 352
 353 err:
 354         ccwreq_stop(cdev, rc);
 355 }
 356
 357 /**
 358  * ccw_request_notoper - notoper handler for I/O request procedure
 359  * @cdev: ccw device
 360  *
 361  * Handle notoper during I/O request procedure.
 362  */
 363 void ccw_request_notoper(struct ccw_device *cdev)
 364 {
 365         ccwreq_stop(cdev, -ENODEV);
 366 }