drivers/s390/cio/device_pgid.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  CCW device PGID and path verification I/O handling.
   4  *
   5  *    Copyright IBM Corp. 2002, 2009
   6  *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
   7  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
   8  *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/string.h>
  13 #include <linux/bitops.h>
  14 #include <linux/types.h>
  15 #include <linux/errno.h>
  16 #include <linux/slab.h>
  17 #include <linux/io.h>
  18 #include <asm/ccwdev.h>
  19 #include <asm/cio.h>
  20
  21 #include "cio.h"
  22 #include "cio_debug.h"
  23 #include "device.h"
  24 #include "io_sch.h"
  25
  26 #define PGID_RETRIES    256
  27 #define PGID_TIMEOUT    (10 * HZ)
  28
  29 static void verify_start(struct ccw_device *cdev);
  30
  31 /*
  32  * Process path verification data and report result.
  33  */
  34 static void verify_done(struct ccw_device *cdev, int rc)
  35 {
  36         struct subchannel *sch = to_subchannel(cdev->dev.parent);
  37         struct ccw_dev_id *id = &cdev->private->dev_id;
  38         int mpath = cdev->private->flags.mpath;
  39         int pgroup = cdev->private->flags.pgroup;
  40
  41         if (rc)
  42                 goto out;
  43         /* Ensure consistent multipathing state at device and channel. */
  44         if (sch->config.mp != mpath) {
  45                 sch->config.mp = mpath;
  46                 rc = cio_commit_config(sch);
  47         }
  48 out:
  49         CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
  50                          "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
  51                          sch->vpm);
  52         ccw_device_verify_done(cdev, rc);
  53 }
  54
  55 /*
  56  * Create channel program to perform a NOOP.
  57  */
  58 static void nop_build_cp(struct ccw_device *cdev)
  59 {
  60         struct ccw_request *req = &cdev->private->req;
  61         struct ccw1 *cp = cdev->private->dma_area->iccws;
  62
  63         cp->cmd_code    = CCW_CMD_NOOP;
  64         cp->cda         = 0;
  65         cp->count       = 0;
  66         cp->flags       = CCW_FLAG_SLI;
  67         req->cp         = cp;
  68 }
  69
  70 /*
  71  * Perform NOOP on a single path.
  72  */
  73 static void nop_do(struct ccw_device *cdev)
  74 {
  75         struct subchannel *sch = to_subchannel(cdev->dev.parent);
  76         struct ccw_request *req = &cdev->private->req;
  77
  78         req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm &
  79                               ~cdev->private->path_noirq_mask);
  80         if (!req->lpm)
  81                 goto out_nopath;
  82         nop_build_cp(cdev);
  83         ccw_request_start(cdev);
  84         return;
  85
  86 out_nopath:
  87         verify_done(cdev, sch->vpm ? 0 : -EACCES);
  88 }
  89
  90 /*
  91  * Adjust NOOP I/O status.
  92  */
  93 static enum io_status nop_filter(struct ccw_device *cdev, void *data,
  94                                  struct irb *irb, enum io_status status)
  95 {
  96         /* Only subchannel status might indicate a path error. */
  97         if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
  98                 return IO_DONE;
  99         return status;
 100 }
 101
 102 /*
 103  * Process NOOP request result for a single path.
 104  */
 105 static void nop_callback(struct ccw_device *cdev, void *data, int rc)
 106 {
 107         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 108         struct ccw_request *req = &cdev->private->req;
 109
 110         switch (rc) {
 111         case 0:
 112                 sch->vpm |= req->lpm;
 113                 break;
 114         case -ETIME:
 115                 cdev->private->path_noirq_mask |= req->lpm;
 116                 break;
 117         case -EACCES:
 118                 cdev->private->path_notoper_mask |= req->lpm;
 119                 break;
 120         default:
 121                 goto err;
 122         }
 123         /* Continue on the next path. */
 124         req->lpm >>= 1;
 125         nop_do(cdev);
 126         return;
 127
 128 err:
 129         verify_done(cdev, rc);
 130 }
 131
 132 /*
 133  * Create channel program to perform SET PGID on a single path.
 134  */
 135 static void spid_build_cp(struct ccw_device *cdev, u8 fn)
 136 {
 137         struct ccw_request *req = &cdev->private->req;
 138         struct ccw1 *cp = cdev->private->dma_area->iccws;
 139         int i = pathmask_to_pos(req->lpm);
 140         struct pgid *pgid = &cdev->private->dma_area->pgid[i];
 141
 142         pgid->inf.fc    = fn;
 143         cp->cmd_code    = CCW_CMD_SET_PGID;
 144         cp->cda         = virt_to_dma32(pgid);
 145         cp->count       = sizeof(*pgid);
 146         cp->flags       = CCW_FLAG_SLI;
 147         req->cp         = cp;
 148 }
 149
 150 static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc)
 151 {
 152         if (rc) {
 153                 /* We don't know the path groups' state. Abort. */
 154                 verify_done(cdev, rc);
 155                 return;
 156         }
 157         /*
 158          * Path groups have been reset. Restart path verification but
 159          * leave paths in path_noirq_mask out.
 160          */
 161         cdev->private->flags.pgid_unknown = 0;
 162         verify_start(cdev);
 163 }
 164
 165 /*
 166  * Reset pathgroups and restart path verification, leave unusable paths out.
 167  */
 168 static void pgid_wipeout_start(struct ccw_device *cdev)
 169 {
 170         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 171         struct ccw_dev_id *id = &cdev->private->dev_id;
 172         struct ccw_request *req = &cdev->private->req;
 173         u8 fn;
 174
 175         CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n",
 176                       id->ssid, id->devno, cdev->private->pgid_valid_mask,
 177                       cdev->private->path_noirq_mask);
 178
 179         /* Initialize request data. */
 180         memset(req, 0, sizeof(*req));
 181         req->timeout    = PGID_TIMEOUT;
 182         req->maxretries = PGID_RETRIES;
 183         req->lpm        = sch->schib.pmcw.pam;
 184         req->callback   = pgid_wipeout_callback;
 185         fn = SPID_FUNC_DISBAND;
 186         if (cdev->private->flags.mpath)
 187                 fn |= SPID_FUNC_MULTI_PATH;
 188         spid_build_cp(cdev, fn);
 189         ccw_request_start(cdev);
 190 }
 191
 192 /*
 193  * Perform establish/resign SET PGID on a single path.
 194  */
 195 static void spid_do(struct ccw_device *cdev)
 196 {
 197         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 198         struct ccw_request *req = &cdev->private->req;
 199         u8 fn;
 200
 201         /* Use next available path that is not already in correct state. */
 202         req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
 203         if (!req->lpm)
 204                 goto out_nopath;
 205         /* Channel program setup. */
 206         if (req->lpm & sch->opm)
 207                 fn = SPID_FUNC_ESTABLISH;
 208         else
 209                 fn = SPID_FUNC_RESIGN;
 210         if (cdev->private->flags.mpath)
 211                 fn |= SPID_FUNC_MULTI_PATH;
 212         spid_build_cp(cdev, fn);
 213         ccw_request_start(cdev);
 214         return;
 215
 216 out_nopath:
 217         if (cdev->private->flags.pgid_unknown) {
 218                 /* At least one SPID could be partially done. */
 219                 pgid_wipeout_start(cdev);
 220                 return;
 221         }
 222         verify_done(cdev, sch->vpm ? 0 : -EACCES);
 223 }
 224
 225 /*
 226  * Process SET PGID request result for a single path.
 227  */
 228 static void spid_callback(struct ccw_device *cdev, void *data, int rc)
 229 {
 230         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 231         struct ccw_request *req = &cdev->private->req;
 232
 233         switch (rc) {
 234         case 0:
 235                 sch->vpm |= req->lpm & sch->opm;
 236                 break;
 237         case -ETIME:
 238                 cdev->private->flags.pgid_unknown = 1;
 239                 cdev->private->path_noirq_mask |= req->lpm;
 240                 break;
 241         case -EACCES:
 242                 cdev->private->path_notoper_mask |= req->lpm;
 243                 break;
 244         case -EOPNOTSUPP:
 245                 if (cdev->private->flags.mpath) {
 246                         /* Try without multipathing. */
 247                         cdev->private->flags.mpath = 0;
 248                         goto out_restart;
 249                 }
 250                 /* Try without pathgrouping. */
 251                 cdev->private->flags.pgroup = 0;
 252                 goto out_restart;
 253         default:
 254                 goto err;
 255         }
 256         req->lpm >>= 1;
 257         spid_do(cdev);
 258         return;
 259
 260 out_restart:
 261         verify_start(cdev);
 262         return;
 263 err:
 264         verify_done(cdev, rc);
 265 }
 266
 267 static void spid_start(struct ccw_device *cdev)
 268 {
 269         struct ccw_request *req = &cdev->private->req;
 270
 271         /* Initialize request data. */
 272         memset(req, 0, sizeof(*req));
 273         req->timeout    = PGID_TIMEOUT;
 274         req->maxretries = PGID_RETRIES;
 275         req->lpm        = 0x80;
 276         req->singlepath = 1;
 277         req->callback   = spid_callback;
 278         spid_do(cdev);
 279 }
 280
 281 static int pgid_is_reset(struct pgid *p)
 282 {
 283         char *c;
 284
 285         for (c = (char *)p + 1; c < (char *)(p + 1); c++) {
 286                 if (*c != 0)
 287                         return 0;
 288         }
 289         return 1;
 290 }
 291
 292 static int pgid_cmp(struct pgid *p1, struct pgid *p2)
 293 {
 294         return memcmp((char *) p1 + 1, (char *) p2 + 1,
 295                       sizeof(struct pgid) - 1);
 296 }
 297
 298 /*
 299  * Determine pathgroup state from PGID data.
 300  */
 301 static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
 302                          int *mismatch, u8 *reserved, u8 *reset)
 303 {
 304         struct pgid *pgid = &cdev->private->dma_area->pgid[0];
 305         struct pgid *first = NULL;
 306         int lpm;
 307         int i;
 308
 309         *mismatch = 0;
 310         *reserved = 0;
 311         *reset = 0;
 312         for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
 313                 if ((cdev->private->pgid_valid_mask & lpm) == 0)
 314                         continue;
 315                 if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
 316                         *reserved |= lpm;
 317                 if (pgid_is_reset(pgid)) {
 318                         *reset |= lpm;
 319                         continue;
 320                 }
 321                 if (!first) {
 322                         first = pgid;
 323                         continue;
 324                 }
 325                 if (pgid_cmp(pgid, first) != 0)
 326                         *mismatch = 1;
 327         }
 328         if (!first)
 329                 first = &channel_subsystems[0]->global_pgid;
 330         *p = first;
 331 }
 332
 333 static u8 pgid_to_donepm(struct ccw_device *cdev)
 334 {
 335         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 336         struct pgid *pgid;
 337         int i;
 338         int lpm;
 339         u8 donepm = 0;
 340
 341         /* Set bits for paths which are already in the target state. */
 342         for (i = 0; i < 8; i++) {
 343                 lpm = 0x80 >> i;
 344                 if ((cdev->private->pgid_valid_mask & lpm) == 0)
 345                         continue;
 346                 pgid = &cdev->private->dma_area->pgid[i];
 347                 if (sch->opm & lpm) {
 348                         if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
 349                                 continue;
 350                 } else {
 351                         if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
 352                                 continue;
 353                 }
 354                 if (cdev->private->flags.mpath) {
 355                         if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
 356                                 continue;
 357                 } else {
 358                         if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
 359                                 continue;
 360                 }
 361                 donepm |= lpm;
 362         }
 363
 364         return donepm;
 365 }
 366
 367 static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
 368 {
 369         int i;
 370
 371         for (i = 0; i < 8; i++)
 372                 memcpy(&cdev->private->dma_area->pgid[i], pgid,
 373                        sizeof(struct pgid));
 374 }
 375
 376 /*
 377  * Process SENSE PGID data and report result.
 378  */
 379 static void snid_done(struct ccw_device *cdev, int rc)
 380 {
 381         struct ccw_dev_id *id = &cdev->private->dev_id;
 382         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 383         struct pgid *pgid;
 384         int mismatch = 0;
 385         u8 reserved = 0;
 386         u8 reset = 0;
 387         u8 donepm;
 388
 389         if (rc)
 390                 goto out;
 391         pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
 392         if (reserved == cdev->private->pgid_valid_mask)
 393                 rc = -EUSERS;
 394         else if (mismatch)
 395                 rc = -EOPNOTSUPP;
 396         else {
 397                 donepm = pgid_to_donepm(cdev);
 398                 sch->vpm = donepm & sch->opm;
 399                 cdev->private->pgid_reset_mask |= reset;
 400                 cdev->private->pgid_todo_mask &=
 401                         ~(donepm | cdev->private->path_noirq_mask);
 402                 pgid_fill(cdev, pgid);
 403         }
 404 out:
 405         CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
 406                       "todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid,
 407                       id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
 408                       cdev->private->pgid_todo_mask, mismatch, reserved, reset);
 409         switch (rc) {
 410         case 0:
 411                 if (cdev->private->flags.pgid_unknown) {
 412                         pgid_wipeout_start(cdev);
 413                         return;
 414                 }
 415                 /* Anything left to do? */
 416                 if (cdev->private->pgid_todo_mask == 0) {
 417                         verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
 418                         return;
 419                 }
 420                 /* Perform path-grouping. */
 421                 spid_start(cdev);
 422                 break;
 423         case -EOPNOTSUPP:
 424                 /* Path-grouping not supported. */
 425                 cdev->private->flags.pgroup = 0;
 426                 cdev->private->flags.mpath = 0;
 427                 verify_start(cdev);
 428                 break;
 429         default:
 430                 verify_done(cdev, rc);
 431         }
 432 }
 433
 434 /*
 435  * Create channel program to perform a SENSE PGID on a single path.
 436  */
 437 static void snid_build_cp(struct ccw_device *cdev)
 438 {
 439         struct ccw_request *req = &cdev->private->req;
 440         struct ccw1 *cp = cdev->private->dma_area->iccws;
 441         int i = pathmask_to_pos(req->lpm);
 442
 443         /* Channel program setup. */
 444         cp->cmd_code    = CCW_CMD_SENSE_PGID;
 445         cp->cda         = virt_to_dma32(&cdev->private->dma_area->pgid[i]);
 446         cp->count       = sizeof(struct pgid);
 447         cp->flags       = CCW_FLAG_SLI;
 448         req->cp         = cp;
 449 }
 450
 451 /*
 452  * Perform SENSE PGID on a single path.
 453  */
 454 static void snid_do(struct ccw_device *cdev)
 455 {
 456         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 457         struct ccw_request *req = &cdev->private->req;
 458         int ret;
 459
 460         req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam &
 461                               ~cdev->private->path_noirq_mask);
 462         if (!req->lpm)
 463                 goto out_nopath;
 464         snid_build_cp(cdev);
 465         ccw_request_start(cdev);
 466         return;
 467
 468 out_nopath:
 469         if (cdev->private->pgid_valid_mask)
 470                 ret = 0;
 471         else if (cdev->private->path_noirq_mask)
 472                 ret = -ETIME;
 473         else
 474                 ret = -EACCES;
 475         snid_done(cdev, ret);
 476 }
 477
 478 /*
 479  * Process SENSE PGID request result for single path.
 480  */
 481 static void snid_callback(struct ccw_device *cdev, void *data, int rc)
 482 {
 483         struct ccw_request *req = &cdev->private->req;
 484
 485         switch (rc) {
 486         case 0:
 487                 cdev->private->pgid_valid_mask |= req->lpm;
 488                 break;
 489         case -ETIME:
 490                 cdev->private->flags.pgid_unknown = 1;
 491                 cdev->private->path_noirq_mask |= req->lpm;
 492                 break;
 493         case -EACCES:
 494                 cdev->private->path_notoper_mask |= req->lpm;
 495                 break;
 496         default:
 497                 goto err;
 498         }
 499         /* Continue on the next path. */
 500         req->lpm >>= 1;
 501         snid_do(cdev);
 502         return;
 503
 504 err:
 505         snid_done(cdev, rc);
 506 }
 507
 508 /*
 509  * Perform path verification.
 510  */
 511 static void verify_start(struct ccw_device *cdev)
 512 {
 513         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 514         struct ccw_request *req = &cdev->private->req;
 515         struct ccw_dev_id *devid = &cdev->private->dev_id;
 516
 517         sch->vpm = 0;
 518         sch->lpm = sch->schib.pmcw.pam;
 519
 520         /* Initialize PGID data. */
 521         memset(cdev->private->dma_area->pgid, 0,
 522                sizeof(cdev->private->dma_area->pgid));
 523         cdev->private->pgid_valid_mask = 0;
 524         cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
 525         cdev->private->path_notoper_mask = 0;
 526
 527         /* Initialize request data. */
 528         memset(req, 0, sizeof(*req));
 529         req->timeout    = PGID_TIMEOUT;
 530         req->maxretries = PGID_RETRIES;
 531         req->lpm        = 0x80;
 532         req->singlepath = 1;
 533         if (cdev->private->flags.pgroup) {
 534                 CIO_TRACE_EVENT(4, "snid");
 535                 CIO_HEX_EVENT(4, devid, sizeof(*devid));
 536                 req->callback   = snid_callback;
 537                 snid_do(cdev);
 538         } else {
 539                 CIO_TRACE_EVENT(4, "nop");
 540                 CIO_HEX_EVENT(4, devid, sizeof(*devid));
 541                 req->filter     = nop_filter;
 542                 req->callback   = nop_callback;
 543                 nop_do(cdev);
 544         }
 545 }
 546
 547 /**
 548  * ccw_device_verify_start - perform path verification
 549  * @cdev: ccw device
 550  *
 551  * Perform an I/O on each available channel path to @cdev to determine which
 552  * paths are operational. The resulting path mask is stored in sch->vpm.
 553  * If device options specify pathgrouping, establish a pathgroup for the
 554  * operational paths. When finished, call ccw_device_verify_done with a
 555  * return code specifying the result.
 556  */
 557 void ccw_device_verify_start(struct ccw_device *cdev)
 558 {
 559         CIO_TRACE_EVENT(4, "vrfy");
 560         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 561         /*
 562          * Initialize pathgroup and multipath state with target values.
 563          * They may change in the course of path verification.
 564          */
 565         cdev->private->flags.pgroup = cdev->private->options.pgroup;
 566         cdev->private->flags.mpath = cdev->private->options.mpath;
 567         cdev->private->flags.doverify = 0;
 568         cdev->private->path_noirq_mask = 0;
 569         verify_start(cdev);
 570 }
 571
 572 /*
 573  * Process disband SET PGID request result.
 574  */
 575 static void disband_callback(struct ccw_device *cdev, void *data, int rc)
 576 {
 577         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 578         struct ccw_dev_id *id = &cdev->private->dev_id;
 579
 580         if (rc)
 581                 goto out;
 582         /* Ensure consistent multipathing state at device and channel. */
 583         cdev->private->flags.mpath = 0;
 584         if (sch->config.mp) {
 585                 sch->config.mp = 0;
 586                 rc = cio_commit_config(sch);
 587         }
 588 out:
 589         CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
 590                       rc);
 591         ccw_device_disband_done(cdev, rc);
 592 }
 593
 594 /**
 595  * ccw_device_disband_start - disband pathgroup
 596  * @cdev: ccw device
 597  *
 598  * Execute a SET PGID channel program on @cdev to disband a previously
 599  * established pathgroup. When finished, call ccw_device_disband_done with
 600  * a return code specifying the result.
 601  */
 602 void ccw_device_disband_start(struct ccw_device *cdev)
 603 {
 604         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 605         struct ccw_request *req = &cdev->private->req;
 606         u8 fn;
 607
 608         CIO_TRACE_EVENT(4, "disb");
 609         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 610         /* Request setup. */
 611         memset(req, 0, sizeof(*req));
 612         req->timeout    = PGID_TIMEOUT;
 613         req->maxretries = PGID_RETRIES;
 614         req->lpm        = sch->schib.pmcw.pam & sch->opm;
 615         req->singlepath = 1;
 616         req->callback   = disband_callback;
 617         fn = SPID_FUNC_DISBAND;
 618         if (cdev->private->flags.mpath)
 619                 fn |= SPID_FUNC_MULTI_PATH;
 620         spid_build_cp(cdev, fn);
 621         ccw_request_start(cdev);
 622 }
 623
 624 struct stlck_data {
 625         struct completion done;
 626         int rc;
 627 };
 628
 629 static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
 630 {
 631         struct ccw_request *req = &cdev->private->req;
 632         struct ccw1 *cp = cdev->private->dma_area->iccws;
 633
 634         cp[0].cmd_code = CCW_CMD_STLCK;
 635         cp[0].cda = virt_to_dma32(buf1);
 636         cp[0].count = 32;
 637         cp[0].flags = CCW_FLAG_CC;
 638         cp[1].cmd_code = CCW_CMD_RELEASE;
 639         cp[1].cda = virt_to_dma32(buf2);
 640         cp[1].count = 32;
 641         cp[1].flags = 0;
 642         req->cp = cp;
 643 }
 644
 645 static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
 646 {
 647         struct stlck_data *sdata = data;
 648
 649         sdata->rc = rc;
 650         complete(&sdata->done);
 651 }
 652
 653 /**
 654  * ccw_device_stlck_start - perform unconditional release
 655  * @cdev: ccw device
 656  * @data: data pointer to be passed to ccw_device_stlck_done
 657  * @buf1: data pointer used in channel program
 658  * @buf2: data pointer used in channel program
 659  *
 660  * Execute a channel program on @cdev to release an existing PGID reservation.
 661  */
 662 static void ccw_device_stlck_start(struct ccw_device *cdev, void *data,
 663                                    void *buf1, void *buf2)
 664 {
 665         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 666         struct ccw_request *req = &cdev->private->req;
 667
 668         CIO_TRACE_EVENT(4, "stlck");
 669         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 670         /* Request setup. */
 671         memset(req, 0, sizeof(*req));
 672         req->timeout    = PGID_TIMEOUT;
 673         req->maxretries = PGID_RETRIES;
 674         req->lpm        = sch->schib.pmcw.pam & sch->opm;
 675         req->data       = data;
 676         req->callback   = stlck_callback;
 677         stlck_build_cp(cdev, buf1, buf2);
 678         ccw_request_start(cdev);
 679 }
 680
 681 /*
 682  * Perform unconditional reserve + release.
 683  */
 684 int ccw_device_stlck(struct ccw_device *cdev)
 685 {
 686         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 687         struct stlck_data data;
 688         u8 *buffer;
 689         int rc;
 690
 691         /* Check if steal lock operation is valid for this device. */
 692         if (cdev->drv) {
 693                 if (!cdev->private->options.force)
 694                         return -EINVAL;
 695         }
 696         buffer = kzalloc(64, GFP_DMA | GFP_KERNEL);
 697         if (!buffer)
 698                 return -ENOMEM;
 699         init_completion(&data.done);
 700         data.rc = -EIO;
 701         spin_lock_irq(&sch->lock);
 702         rc = cio_enable_subchannel(sch, (u32)virt_to_phys(sch));
 703         if (rc)
 704                 goto out_unlock;
 705         /* Perform operation. */
 706         cdev->private->state = DEV_STATE_STEAL_LOCK;
 707         ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]);
 708         spin_unlock_irq(&sch->lock);
 709         /* Wait for operation to finish. */
 710         if (wait_for_completion_interruptible(&data.done)) {
 711                 /* Got a signal. */
 712                 spin_lock_irq(&sch->lock);
 713                 ccw_request_cancel(cdev);
 714                 spin_unlock_irq(&sch->lock);
 715                 wait_for_completion(&data.done);
 716         }
 717         rc = data.rc;
 718         /* Check results. */
 719         spin_lock_irq(&sch->lock);
 720         cio_disable_subchannel(sch);
 721         cdev->private->state = DEV_STATE_BOXED;
 722 out_unlock:
 723         spin_unlock_irq(&sch->lock);
 724         kfree(buffer);
 725
 726         return rc;
 727 }