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