drivers/s390/cio/ccwreq.c

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

DEFINITIONS
