drivers/s390/cio/device_ops.c

   1 /*
   2  * Copyright IBM Corp. 2002, 2009
   3  *
   4  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
   5  *            Cornelia Huck (cornelia.huck@de.ibm.com)
   6  */
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/errno.h>
  10 #include <linux/slab.h>
  11 #include <linux/list.h>
  12 #include <linux/device.h>
  13 #include <linux/delay.h>
  14 #include <linux/completion.h>
  15
  16 #include <asm/ccwdev.h>
  17 #include <asm/idals.h>
  18 #include <asm/chpid.h>
  19 #include <asm/fcx.h>
  20
  21 #include "cio.h"
  22 #include "cio_debug.h"
  23 #include "css.h"
  24 #include "chsc.h"
  25 #include "device.h"
  26 #include "chp.h"
  27
  28 /**
  29  * ccw_device_set_options_mask() - set some options and unset the rest
  30  * @cdev: device for which the options are to be set
  31  * @flags: options to be set
  32  *
  33  * All flags specified in @flags are set, all flags not specified in @flags
  34  * are cleared.
  35  * Returns:
  36  *   %0 on success, -%EINVAL on an invalid flag combination.
  37  */
  38 int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
  39 {
  40        /*
  41         * The flag usage is mutal exclusive ...
  42         */
  43         if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
  44             (flags & CCWDEV_REPORT_ALL))
  45                 return -EINVAL;
  46         cdev->private->options.fast = (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
  47         cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
  48         cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
  49         cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
  50         cdev->private->options.mpath = (flags & CCWDEV_DO_MULTIPATH) != 0;
  51         return 0;
  52 }
  53
  54 /**
  55  * ccw_device_set_options() - set some options
  56  * @cdev: device for which the options are to be set
  57  * @flags: options to be set
  58  *
  59  * All flags specified in @flags are set, the remainder is left untouched.
  60  * Returns:
  61  *   %0 on success, -%EINVAL if an invalid flag combination would ensue.
  62  */
  63 int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
  64 {
  65        /*
  66         * The flag usage is mutal exclusive ...
  67         */
  68         if (((flags & CCWDEV_EARLY_NOTIFICATION) &&
  69             (flags & CCWDEV_REPORT_ALL)) ||
  70             ((flags & CCWDEV_EARLY_NOTIFICATION) &&
  71              cdev->private->options.repall) ||
  72             ((flags & CCWDEV_REPORT_ALL) &&
  73              cdev->private->options.fast))
  74                 return -EINVAL;
  75         cdev->private->options.fast |= (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
  76         cdev->private->options.repall |= (flags & CCWDEV_REPORT_ALL) != 0;
  77         cdev->private->options.pgroup |= (flags & CCWDEV_DO_PATHGROUP) != 0;
  78         cdev->private->options.force |= (flags & CCWDEV_ALLOW_FORCE) != 0;
  79         cdev->private->options.mpath |= (flags & CCWDEV_DO_MULTIPATH) != 0;
  80         return 0;
  81 }
  82
  83 /**
  84  * ccw_device_clear_options() - clear some options
  85  * @cdev: device for which the options are to be cleared
  86  * @flags: options to be cleared
  87  *
  88  * All flags specified in @flags are cleared, the remainder is left untouched.
  89  */
  90 void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
  91 {
  92         cdev->private->options.fast &= (flags & CCWDEV_EARLY_NOTIFICATION) == 0;
  93         cdev->private->options.repall &= (flags & CCWDEV_REPORT_ALL) == 0;
  94         cdev->private->options.pgroup &= (flags & CCWDEV_DO_PATHGROUP) == 0;
  95         cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
  96         cdev->private->options.mpath &= (flags & CCWDEV_DO_MULTIPATH) == 0;
  97 }
  98
  99 /**
 100  * ccw_device_is_pathgroup() - determine if paths to this device are grouped
 101  * @cdev: ccw device
 102  *
 103  * Return non-zero if there is a path group, zero otherwise.
 104  */
 105 int ccw_device_is_pathgroup(struct ccw_device *cdev)
 106 {
 107         return cdev->private->flags.pgroup;
 108 }
 109 EXPORT_SYMBOL(ccw_device_is_pathgroup);
 110
 111 /**
 112  * ccw_device_is_multipath() - determine if device is operating in multipath mode
 113  * @cdev: ccw device
 114  *
 115  * Return non-zero if device is operating in multipath mode, zero otherwise.
 116  */
 117 int ccw_device_is_multipath(struct ccw_device *cdev)
 118 {
 119         return cdev->private->flags.mpath;
 120 }
 121 EXPORT_SYMBOL(ccw_device_is_multipath);
 122
 123 /**
 124  * ccw_device_clear() - terminate I/O request processing
 125  * @cdev: target ccw device
 126  * @intparm: interruption parameter; value is only used if no I/O is
 127  *           outstanding, otherwise the intparm associated with the I/O request
 128  *           is returned
 129  *
 130  * ccw_device_clear() calls csch on @cdev's subchannel.
 131  * Returns:
 132  *  %0 on success,
 133  *  -%ENODEV on device not operational,
 134  *  -%EINVAL on invalid device state.
 135  * Context:
 136  *  Interrupts disabled, ccw device lock held
 137  */
 138 int ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
 139 {
 140         struct subchannel *sch;
 141         int ret;
 142
 143         if (!cdev || !cdev->dev.parent)
 144                 return -ENODEV;
 145         sch = to_subchannel(cdev->dev.parent);
 146         if (!sch->schib.pmcw.ena)
 147                 return -EINVAL;
 148         if (cdev->private->state == DEV_STATE_NOT_OPER)
 149                 return -ENODEV;
 150         if (cdev->private->state != DEV_STATE_ONLINE &&
 151             cdev->private->state != DEV_STATE_W4SENSE)
 152                 return -EINVAL;
 153
 154         ret = cio_clear(sch);
 155         if (ret == 0)
 156                 cdev->private->intparm = intparm;
 157         return ret;
 158 }
 159
 160 /**
 161  * ccw_device_start_timeout_key() - start a s390 channel program with timeout and key
 162  * @cdev: target ccw device
 163  * @cpa: logical start address of channel program
 164  * @intparm: user specific interruption parameter; will be presented back to
 165  *           @cdev's interrupt handler. Allows a device driver to associate
 166  *           the interrupt with a particular I/O request.
 167  * @lpm: defines the channel path to be used for a specific I/O request. A
 168  *       value of 0 will make cio use the opm.
 169  * @key: storage key to be used for the I/O
 170  * @flags: additional flags; defines the action to be performed for I/O
 171  *         processing.
 172  * @expires: timeout value in jiffies
 173  *
 174  * Start a S/390 channel program. When the interrupt arrives, the
 175  * IRQ handler is called, either immediately, delayed (dev-end missing,
 176  * or sense required) or never (no IRQ handler registered).
 177  * This function notifies the device driver if the channel program has not
 178  * completed during the time specified by @expires. If a timeout occurs, the
 179  * channel program is terminated via xsch, hsch or csch, and the device's
 180  * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
 181  * Returns:
 182  *  %0, if the operation was successful;
 183  *  -%EBUSY, if the device is busy, or status pending;
 184  *  -%EACCES, if no path specified in @lpm is operational;
 185  *  -%ENODEV, if the device is not operational.
 186  * Context:
 187  *  Interrupts disabled, ccw device lock held
 188  */
 189 int ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
 190                                  unsigned long intparm, __u8 lpm, __u8 key,
 191                                  unsigned long flags, int expires)
 192 {
 193         struct subchannel *sch;
 194         int ret;
 195
 196         if (!cdev || !cdev->dev.parent)
 197                 return -ENODEV;
 198         sch = to_subchannel(cdev->dev.parent);
 199         if (!sch->schib.pmcw.ena)
 200                 return -EINVAL;
 201         if (cdev->private->state == DEV_STATE_NOT_OPER)
 202                 return -ENODEV;
 203         if (cdev->private->state == DEV_STATE_VERIFY) {
 204                 /* Remember to fake irb when finished. */
 205                 if (!cdev->private->flags.fake_irb) {
 206                         cdev->private->flags.fake_irb = FAKE_CMD_IRB;
 207                         cdev->private->intparm = intparm;
 208                         return 0;
 209                 } else
 210                         /* There's already a fake I/O around. */
 211                         return -EBUSY;
 212         }
 213         if (cdev->private->state != DEV_STATE_ONLINE ||
 214             ((sch->schib.scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
 215              !(sch->schib.scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS)) ||
 216             cdev->private->flags.doverify)
 217                 return -EBUSY;
 218         ret = cio_set_options (sch, flags);
 219         if (ret)
 220                 return ret;
 221         /* Adjust requested path mask to exclude unusable paths. */
 222         if (lpm) {
 223                 lpm &= sch->lpm;
 224                 if (lpm == 0)
 225                         return -EACCES;
 226         }
 227         ret = cio_start_key (sch, cpa, lpm, key);
 228         switch (ret) {
 229         case 0:
 230                 cdev->private->intparm = intparm;
 231                 if (expires)
 232                         ccw_device_set_timeout(cdev, expires);
 233                 break;
 234         case -EACCES:
 235         case -ENODEV:
 236                 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 237                 break;
 238         }
 239         return ret;
 240 }
 241
 242 /**
 243  * ccw_device_start_key() - start a s390 channel program with key
 244  * @cdev: target ccw device
 245  * @cpa: logical start address of channel program
 246  * @intparm: user specific interruption parameter; will be presented back to
 247  *           @cdev's interrupt handler. Allows a device driver to associate
 248  *           the interrupt with a particular I/O request.
 249  * @lpm: defines the channel path to be used for a specific I/O request. A
 250  *       value of 0 will make cio use the opm.
 251  * @key: storage key to be used for the I/O
 252  * @flags: additional flags; defines the action to be performed for I/O
 253  *         processing.
 254  *
 255  * Start a S/390 channel program. When the interrupt arrives, the
 256  * IRQ handler is called, either immediately, delayed (dev-end missing,
 257  * or sense required) or never (no IRQ handler registered).
 258  * Returns:
 259  *  %0, if the operation was successful;
 260  *  -%EBUSY, if the device is busy, or status pending;
 261  *  -%EACCES, if no path specified in @lpm is operational;
 262  *  -%ENODEV, if the device is not operational.
 263  * Context:
 264  *  Interrupts disabled, ccw device lock held
 265  */
 266 int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
 267                          unsigned long intparm, __u8 lpm, __u8 key,
 268                          unsigned long flags)
 269 {
 270         return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm, key,
 271                                             flags, 0);
 272 }
 273
 274 /**
 275  * ccw_device_start() - start a s390 channel program
 276  * @cdev: target ccw device
 277  * @cpa: logical start address of channel program
 278  * @intparm: user specific interruption parameter; will be presented back to
 279  *           @cdev's interrupt handler. Allows a device driver to associate
 280  *           the interrupt with a particular I/O request.
 281  * @lpm: defines the channel path to be used for a specific I/O request. A
 282  *       value of 0 will make cio use the opm.
 283  * @flags: additional flags; defines the action to be performed for I/O
 284  *         processing.
 285  *
 286  * Start a S/390 channel program. When the interrupt arrives, the
 287  * IRQ handler is called, either immediately, delayed (dev-end missing,
 288  * or sense required) or never (no IRQ handler registered).
 289  * Returns:
 290  *  %0, if the operation was successful;
 291  *  -%EBUSY, if the device is busy, or status pending;
 292  *  -%EACCES, if no path specified in @lpm is operational;
 293  *  -%ENODEV, if the device is not operational.
 294  * Context:
 295  *  Interrupts disabled, ccw device lock held
 296  */
 297 int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
 298                      unsigned long intparm, __u8 lpm, unsigned long flags)
 299 {
 300         return ccw_device_start_key(cdev, cpa, intparm, lpm,
 301                                     PAGE_DEFAULT_KEY, flags);
 302 }
 303
 304 /**
 305  * ccw_device_start_timeout() - start a s390 channel program with timeout
 306  * @cdev: target ccw device
 307  * @cpa: logical start address of channel program
 308  * @intparm: user specific interruption parameter; will be presented back to
 309  *           @cdev's interrupt handler. Allows a device driver to associate
 310  *           the interrupt with a particular I/O request.
 311  * @lpm: defines the channel path to be used for a specific I/O request. A
 312  *       value of 0 will make cio use the opm.
 313  * @flags: additional flags; defines the action to be performed for I/O
 314  *         processing.
 315  * @expires: timeout value in jiffies
 316  *
 317  * Start a S/390 channel program. When the interrupt arrives, the
 318  * IRQ handler is called, either immediately, delayed (dev-end missing,
 319  * or sense required) or never (no IRQ handler registered).
 320  * This function notifies the device driver if the channel program has not
 321  * completed during the time specified by @expires. If a timeout occurs, the
 322  * channel program is terminated via xsch, hsch or csch, and the device's
 323  * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
 324  * Returns:
 325  *  %0, if the operation was successful;
 326  *  -%EBUSY, if the device is busy, or status pending;
 327  *  -%EACCES, if no path specified in @lpm is operational;
 328  *  -%ENODEV, if the device is not operational.
 329  * Context:
 330  *  Interrupts disabled, ccw device lock held
 331  */
 332 int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
 333                              unsigned long intparm, __u8 lpm,
 334                              unsigned long flags, int expires)
 335 {
 336         return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
 337                                             PAGE_DEFAULT_KEY, flags,
 338                                             expires);
 339 }
 340
 341
 342 /**
 343  * ccw_device_halt() - halt I/O request processing
 344  * @cdev: target ccw device
 345  * @intparm: interruption parameter; value is only used if no I/O is
 346  *           outstanding, otherwise the intparm associated with the I/O request
 347  *           is returned
 348  *
 349  * ccw_device_halt() calls hsch on @cdev's subchannel.
 350  * Returns:
 351  *  %0 on success,
 352  *  -%ENODEV on device not operational,
 353  *  -%EINVAL on invalid device state,
 354  *  -%EBUSY on device busy or interrupt pending.
 355  * Context:
 356  *  Interrupts disabled, ccw device lock held
 357  */
 358 int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
 359 {
 360         struct subchannel *sch;
 361         int ret;
 362
 363         if (!cdev || !cdev->dev.parent)
 364                 return -ENODEV;
 365         sch = to_subchannel(cdev->dev.parent);
 366         if (!sch->schib.pmcw.ena)
 367                 return -EINVAL;
 368         if (cdev->private->state == DEV_STATE_NOT_OPER)
 369                 return -ENODEV;
 370         if (cdev->private->state != DEV_STATE_ONLINE &&
 371             cdev->private->state != DEV_STATE_W4SENSE)
 372                 return -EINVAL;
 373
 374         ret = cio_halt(sch);
 375         if (ret == 0)
 376                 cdev->private->intparm = intparm;
 377         return ret;
 378 }
 379
 380 /**
 381  * ccw_device_resume() - resume channel program execution
 382  * @cdev: target ccw device
 383  *
 384  * ccw_device_resume() calls rsch on @cdev's subchannel.
 385  * Returns:
 386  *  %0 on success,
 387  *  -%ENODEV on device not operational,
 388  *  -%EINVAL on invalid device state,
 389  *  -%EBUSY on device busy or interrupt pending.
 390  * Context:
 391  *  Interrupts disabled, ccw device lock held
 392  */
 393 int ccw_device_resume(struct ccw_device *cdev)
 394 {
 395         struct subchannel *sch;
 396
 397         if (!cdev || !cdev->dev.parent)
 398                 return -ENODEV;
 399         sch = to_subchannel(cdev->dev.parent);
 400         if (!sch->schib.pmcw.ena)
 401                 return -EINVAL;
 402         if (cdev->private->state == DEV_STATE_NOT_OPER)
 403                 return -ENODEV;
 404         if (cdev->private->state != DEV_STATE_ONLINE ||
 405             !(sch->schib.scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
 406                 return -EINVAL;
 407         return cio_resume(sch);
 408 }
 409
 410 /**
 411  * ccw_device_get_ciw() - Search for CIW command in extended sense data.
 412  * @cdev: ccw device to inspect
 413  * @ct: command type to look for
 414  *
 415  * During SenseID, command information words (CIWs) describing special
 416  * commands available to the device may have been stored in the extended
 417  * sense data. This function searches for CIWs of a specified command
 418  * type in the extended sense data.
 419  * Returns:
 420  *  %NULL if no extended sense data has been stored or if no CIW of the
 421  *  specified command type could be found,
 422  *  else a pointer to the CIW of the specified command type.
 423  */
 424 struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
 425 {
 426         int ciw_cnt;
 427
 428         if (cdev->private->flags.esid == 0)
 429                 return NULL;
 430         for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
 431                 if (cdev->private->senseid.ciw[ciw_cnt].ct == ct)
 432                         return cdev->private->senseid.ciw + ciw_cnt;
 433         return NULL;
 434 }
 435
 436 /**
 437  * ccw_device_get_path_mask() - get currently available paths
 438  * @cdev: ccw device to be queried
 439  * Returns:
 440  *  %0 if no subchannel for the device is available,
 441  *  else the mask of currently available paths for the ccw device's subchannel.
 442  */
 443 __u8 ccw_device_get_path_mask(struct ccw_device *cdev)
 444 {
 445         struct subchannel *sch;
 446
 447         if (!cdev->dev.parent)
 448                 return 0;
 449
 450         sch = to_subchannel(cdev->dev.parent);
 451         return sch->lpm;
 452 }
 453
 454 /**
 455  * ccw_device_get_chp_desc() - return newly allocated channel-path descriptor
 456  * @cdev: device to obtain the descriptor for
 457  * @chp_idx: index of the channel path
 458  *
 459  * On success return a newly allocated copy of the channel-path description
 460  * data associated with the given channel path. Return %NULL on error.
 461  */
 462 struct channel_path_desc *ccw_device_get_chp_desc(struct ccw_device *cdev,
 463                                                   int chp_idx)
 464 {
 465         struct subchannel *sch;
 466         struct chp_id chpid;
 467
 468         sch = to_subchannel(cdev->dev.parent);
 469         chp_id_init(&chpid);
 470         chpid.id = sch->schib.pmcw.chpid[chp_idx];
 471         return chp_get_chp_desc(chpid);
 472 }
 473
 474 /**
 475  * ccw_device_get_id() - obtain a ccw device id
 476  * @cdev: device to obtain the id for
 477  * @dev_id: where to fill in the values
 478  */
 479 void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
 480 {
 481         *dev_id = cdev->private->dev_id;
 482 }
 483 EXPORT_SYMBOL(ccw_device_get_id);
 484
 485 /**
 486  * ccw_device_tm_start_timeout_key() - perform start function
 487  * @cdev: ccw device on which to perform the start function
 488  * @tcw: transport-command word to be started
 489  * @intparm: user defined parameter to be passed to the interrupt handler
 490  * @lpm: mask of paths to use
 491  * @key: storage key to use for storage access
 492  * @expires: time span in jiffies after which to abort request
 493  *
 494  * Start the tcw on the given ccw device. Return zero on success, non-zero
 495  * otherwise.
 496  */
 497 int ccw_device_tm_start_timeout_key(struct ccw_device *cdev, struct tcw *tcw,
 498                                     unsigned long intparm, u8 lpm, u8 key,
 499                                     int expires)
 500 {
 501         struct subchannel *sch;
 502         int rc;
 503
 504         sch = to_subchannel(cdev->dev.parent);
 505         if (!sch->schib.pmcw.ena)
 506                 return -EINVAL;
 507         if (cdev->private->state == DEV_STATE_VERIFY) {
 508                 /* Remember to fake irb when finished. */
 509                 if (!cdev->private->flags.fake_irb) {
 510                         cdev->private->flags.fake_irb = FAKE_TM_IRB;
 511                         cdev->private->intparm = intparm;
 512                         return 0;
 513                 } else
 514                         /* There's already a fake I/O around. */
 515                         return -EBUSY;
 516         }
 517         if (cdev->private->state != DEV_STATE_ONLINE)
 518                 return -EIO;
 519         /* Adjust requested path mask to exclude unusable paths. */
 520         if (lpm) {
 521                 lpm &= sch->lpm;
 522                 if (lpm == 0)
 523                         return -EACCES;
 524         }
 525         rc = cio_tm_start_key(sch, tcw, lpm, key);
 526         if (rc == 0) {
 527                 cdev->private->intparm = intparm;
 528                 if (expires)
 529                         ccw_device_set_timeout(cdev, expires);
 530         }
 531         return rc;
 532 }
 533 EXPORT_SYMBOL(ccw_device_tm_start_timeout_key);
 534
 535 /**
 536  * ccw_device_tm_start_key() - perform start function
 537  * @cdev: ccw device on which to perform the start function
 538  * @tcw: transport-command word to be started
 539  * @intparm: user defined parameter to be passed to the interrupt handler
 540  * @lpm: mask of paths to use
 541  * @key: storage key to use for storage access
 542  *
 543  * Start the tcw on the given ccw device. Return zero on success, non-zero
 544  * otherwise.
 545  */
 546 int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw,
 547                             unsigned long intparm, u8 lpm, u8 key)
 548 {
 549         return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm, key, 0);
 550 }
 551 EXPORT_SYMBOL(ccw_device_tm_start_key);
 552
 553 /**
 554  * ccw_device_tm_start() - perform start function
 555  * @cdev: ccw device on which to perform the start function
 556  * @tcw: transport-command word to be started
 557  * @intparm: user defined parameter to be passed to the interrupt handler
 558  * @lpm: mask of paths to use
 559  *
 560  * Start the tcw on the given ccw device. Return zero on success, non-zero
 561  * otherwise.
 562  */
 563 int ccw_device_tm_start(struct ccw_device *cdev, struct tcw *tcw,
 564                         unsigned long intparm, u8 lpm)
 565 {
 566         return ccw_device_tm_start_key(cdev, tcw, intparm, lpm,
 567                                        PAGE_DEFAULT_KEY);
 568 }
 569 EXPORT_SYMBOL(ccw_device_tm_start);
 570
 571 /**
 572  * ccw_device_tm_start_timeout() - perform start function
 573  * @cdev: ccw device on which to perform the start function
 574  * @tcw: transport-command word to be started
 575  * @intparm: user defined parameter to be passed to the interrupt handler
 576  * @lpm: mask of paths to use
 577  * @expires: time span in jiffies after which to abort request
 578  *
 579  * Start the tcw on the given ccw device. Return zero on success, non-zero
 580  * otherwise.
 581  */
 582 int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
 583                                unsigned long intparm, u8 lpm, int expires)
 584 {
 585         return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm,
 586                                                PAGE_DEFAULT_KEY, expires);
 587 }
 588 EXPORT_SYMBOL(ccw_device_tm_start_timeout);
 589
 590 /**
 591  * ccw_device_get_mdc() - accumulate max data count
 592  * @cdev: ccw device for which the max data count is accumulated
 593  * @mask: mask of paths to use
 594  *
 595  * Return the number of 64K-bytes blocks all paths at least support
 596  * for a transport command. Return values <= 0 indicate failures.
 597  */
 598 int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
 599 {
 600         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 601         struct channel_path *chp;
 602         struct chp_id chpid;
 603         int mdc = 0, i;
 604
 605         /* Adjust requested path mask to excluded varied off paths. */
 606         if (mask)
 607                 mask &= sch->lpm;
 608         else
 609                 mask = sch->lpm;
 610
 611         chp_id_init(&chpid);
 612         for (i = 0; i < 8; i++) {
 613                 if (!(mask & (0x80 >> i)))
 614                         continue;
 615                 chpid.id = sch->schib.pmcw.chpid[i];
 616                 chp = chpid_to_chp(chpid);
 617                 if (!chp)
 618                         continue;
 619
 620                 mutex_lock(&chp->lock);
 621                 if (!chp->desc_fmt1.f) {
 622                         mutex_unlock(&chp->lock);
 623                         return 0;
 624                 }
 625                 if (!chp->desc_fmt1.r)
 626                         mdc = 1;
 627                 mdc = mdc ? min_t(int, mdc, chp->desc_fmt1.mdc) :
 628                             chp->desc_fmt1.mdc;
 629                 mutex_unlock(&chp->lock);
 630         }
 631
 632         return mdc;
 633 }
 634 EXPORT_SYMBOL(ccw_device_get_mdc);
 635
 636 /**
 637  * ccw_device_tm_intrg() - perform interrogate function
 638  * @cdev: ccw device on which to perform the interrogate function
 639  *
 640  * Perform an interrogate function on the given ccw device. Return zero on
 641  * success, non-zero otherwise.
 642  */
 643 int ccw_device_tm_intrg(struct ccw_device *cdev)
 644 {
 645         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 646
 647         if (!sch->schib.pmcw.ena)
 648                 return -EINVAL;
 649         if (cdev->private->state != DEV_STATE_ONLINE)
 650                 return -EIO;
 651         if (!scsw_is_tm(&sch->schib.scsw) ||
 652             !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_START_PEND))
 653                 return -EINVAL;
 654         return cio_tm_intrg(sch);
 655 }
 656 EXPORT_SYMBOL(ccw_device_tm_intrg);
 657
 658 /**
 659  * ccw_device_get_schid() - obtain a subchannel id
 660  * @cdev: device to obtain the id for
 661  * @schid: where to fill in the values
 662  */
 663 void ccw_device_get_schid(struct ccw_device *cdev, struct subchannel_id *schid)
 664 {
 665         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 666
 667         *schid = sch->schid;
 668 }
 669 EXPORT_SYMBOL_GPL(ccw_device_get_schid);
 670
 671 MODULE_LICENSE("GPL");
 672 EXPORT_SYMBOL(ccw_device_set_options_mask);
 673 EXPORT_SYMBOL(ccw_device_set_options);
 674 EXPORT_SYMBOL(ccw_device_clear_options);
 675 EXPORT_SYMBOL(ccw_device_clear);
 676 EXPORT_SYMBOL(ccw_device_halt);
 677 EXPORT_SYMBOL(ccw_device_resume);
 678 EXPORT_SYMBOL(ccw_device_start_timeout);
 679 EXPORT_SYMBOL(ccw_device_start);
 680 EXPORT_SYMBOL(ccw_device_start_timeout_key);
 681 EXPORT_SYMBOL(ccw_device_start_key);
 682 EXPORT_SYMBOL(ccw_device_get_ciw);
 683 EXPORT_SYMBOL(ccw_device_get_path_mask);
 684 EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);