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