1 // SPDX-License-Identifier: GPL-1.0+
3 * Copyright IBM Corp. 2002, 2009
5 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
6 * Cornelia Huck (cornelia.huck@de.ibm.com)
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>
17 #include <asm/ccwdev.h>
18 #include <asm/idals.h>
19 #include <asm/chpid.h>
23 #include "cio_debug.h"
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
34 * All flags specified in @flags are set, all flags not specified in @flags
37 * %0 on success, -%EINVAL on an invalid flag combination.
39 int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
42 * The flag usage is mutal exclusive ...
44 if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
45 (flags & CCWDEV_REPORT_ALL))
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;
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
60 * All flags specified in @flags are set, the remainder is left untouched.
62 * %0 on success, -%EINVAL if an invalid flag combination would ensue.
64 int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
67 * The flag usage is mutal exclusive ...
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))
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;
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
89 * All flags specified in @flags are cleared, the remainder is left untouched.
91 void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
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;
101 * ccw_device_is_pathgroup() - determine if paths to this device are grouped
104 * Return non-zero if there is a path group, zero otherwise.
106 int ccw_device_is_pathgroup(struct ccw_device *cdev)
108 return cdev->private->flags.pgroup;
110 EXPORT_SYMBOL(ccw_device_is_pathgroup);
113 * ccw_device_is_multipath() - determine if device is operating in multipath mode
116 * Return non-zero if device is operating in multipath mode, zero otherwise.
118 int ccw_device_is_multipath(struct ccw_device *cdev)
120 return cdev->private->flags.mpath;
122 EXPORT_SYMBOL(ccw_device_is_multipath);
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
129 * ccw_device_clear() calls csch on @cdev's subchannel.
132 * -%ENODEV on device not operational,
133 * -%EINVAL on invalid device state.
135 * Interrupts disabled, ccw device lock held
137 int ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
139 struct subchannel *sch;
142 if (!cdev || !cdev->dev.parent)
144 sch = to_subchannel(cdev->dev.parent);
145 if (!sch->schib.pmcw.ena)
147 if (cdev->private->state == DEV_STATE_NOT_OPER)
149 if (cdev->private->state != DEV_STATE_ONLINE &&
150 cdev->private->state != DEV_STATE_W4SENSE)
153 ret = cio_clear(sch);
155 cdev->private->intparm = intparm;
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
171 * @expires: timeout value in jiffies
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().
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.
189 * Interrupts disabled, ccw device lock held
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)
195 struct subchannel *sch;
198 if (!cdev || !cdev->dev.parent)
200 sch = to_subchannel(cdev->dev.parent);
201 if (!sch->schib.pmcw.ena)
203 if (cdev->private->state == DEV_STATE_NOT_OPER)
205 if (cdev->private->state == DEV_STATE_VERIFY ||
206 cdev->private->flags.doverify) {
207 /* Remember to fake irb when finished. */
208 if (!cdev->private->flags.fake_irb) {
209 cdev->private->flags.fake_irb = FAKE_CMD_IRB;
210 cdev->private->intparm = intparm;
211 CIO_MSG_EVENT(2, "fakeirb: queue device 0.%x.%04x intparm %lx type=%d\n",
212 cdev->private->dev_id.ssid,
213 cdev->private->dev_id.devno, intparm,
214 cdev->private->flags.fake_irb);
217 /* There's already a fake I/O around. */
220 if (cdev->private->state != DEV_STATE_ONLINE ||
221 ((sch->schib.scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
222 !(sch->schib.scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS)))
224 ret = cio_set_options (sch, flags);
227 /* Adjust requested path mask to exclude unusable paths. */
233 ret = cio_start_key (sch, cpa, lpm, key);
236 cdev->private->intparm = intparm;
238 ccw_device_set_timeout(cdev, expires);
242 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
249 * ccw_device_start_key() - start a s390 channel program with key
250 * @cdev: target ccw device
251 * @cpa: logical start address of channel program
252 * @intparm: user specific interruption parameter; will be presented back to
253 * @cdev's interrupt handler. Allows a device driver to associate
254 * the interrupt with a particular I/O request.
255 * @lpm: defines the channel path to be used for a specific I/O request. A
256 * value of 0 will make cio use the opm.
257 * @key: storage key to be used for the I/O
258 * @flags: additional flags; defines the action to be performed for I/O
261 * Start a S/390 channel program. When the interrupt arrives, the
262 * IRQ handler is called, either immediately, delayed (dev-end missing,
263 * or sense required) or never (no IRQ handler registered).
264 * The interruption handler will echo back the @intparm specified here, unless
265 * another interruption parameter is specified by a subsequent invocation of
266 * ccw_device_halt() or ccw_device_clear().
268 * %0, if the operation was successful;
269 * -%EBUSY, if the device is busy, or status pending;
270 * -%EACCES, if no path specified in @lpm is operational;
271 * -%ENODEV, if the device is not operational.
273 * Interrupts disabled, ccw device lock held
275 int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
276 unsigned long intparm, __u8 lpm, __u8 key,
279 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm, key,
284 * ccw_device_start() - start a s390 channel program
285 * @cdev: target ccw device
286 * @cpa: logical start address of channel program
287 * @intparm: user specific interruption parameter; will be presented back to
288 * @cdev's interrupt handler. Allows a device driver to associate
289 * the interrupt with a particular I/O request.
290 * @lpm: defines the channel path to be used for a specific I/O request. A
291 * value of 0 will make cio use the opm.
292 * @flags: additional flags; defines the action to be performed for I/O
295 * Start a S/390 channel program. When the interrupt arrives, the
296 * IRQ handler is called, either immediately, delayed (dev-end missing,
297 * or sense required) or never (no IRQ handler registered).
298 * The interruption handler will echo back the @intparm specified here, unless
299 * another interruption parameter is specified by a subsequent invocation of
300 * ccw_device_halt() or ccw_device_clear().
302 * %0, if the operation was successful;
303 * -%EBUSY, if the device is busy, or status pending;
304 * -%EACCES, if no path specified in @lpm is operational;
305 * -%ENODEV, if the device is not operational.
307 * Interrupts disabled, ccw device lock held
309 int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
310 unsigned long intparm, __u8 lpm, unsigned long flags)
312 return ccw_device_start_key(cdev, cpa, intparm, lpm,
313 PAGE_DEFAULT_KEY, flags);
317 * ccw_device_start_timeout() - start a s390 channel program with timeout
318 * @cdev: target ccw device
319 * @cpa: logical start address of channel program
320 * @intparm: user specific interruption parameter; will be presented back to
321 * @cdev's interrupt handler. Allows a device driver to associate
322 * the interrupt with a particular I/O request.
323 * @lpm: defines the channel path to be used for a specific I/O request. A
324 * value of 0 will make cio use the opm.
325 * @flags: additional flags; defines the action to be performed for I/O
327 * @expires: timeout value in jiffies
329 * Start a S/390 channel program. When the interrupt arrives, the
330 * IRQ handler is called, either immediately, delayed (dev-end missing,
331 * or sense required) or never (no IRQ handler registered).
332 * This function notifies the device driver if the channel program has not
333 * completed during the time specified by @expires. If a timeout occurs, the
334 * channel program is terminated via xsch, hsch or csch, and the device's
335 * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
336 * The interruption handler will echo back the @intparm specified here, unless
337 * another interruption parameter is specified by a subsequent invocation of
338 * ccw_device_halt() or ccw_device_clear().
340 * %0, if the operation was successful;
341 * -%EBUSY, if the device is busy, or status pending;
342 * -%EACCES, if no path specified in @lpm is operational;
343 * -%ENODEV, if the device is not operational.
345 * Interrupts disabled, ccw device lock held
347 int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
348 unsigned long intparm, __u8 lpm,
349 unsigned long flags, int expires)
351 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
352 PAGE_DEFAULT_KEY, flags,
358 * ccw_device_halt() - halt I/O request processing
359 * @cdev: target ccw device
360 * @intparm: interruption parameter to be returned upon conclusion of hsch
362 * ccw_device_halt() calls hsch on @cdev's subchannel.
363 * The interruption handler will echo back the @intparm specified here, unless
364 * another interruption parameter is specified by a subsequent invocation of
365 * ccw_device_clear().
368 * -%ENODEV on device not operational,
369 * -%EINVAL on invalid device state,
370 * -%EBUSY on device busy or interrupt pending.
372 * Interrupts disabled, ccw device lock held
374 int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
376 struct subchannel *sch;
379 if (!cdev || !cdev->dev.parent)
381 sch = to_subchannel(cdev->dev.parent);
382 if (!sch->schib.pmcw.ena)
384 if (cdev->private->state == DEV_STATE_NOT_OPER)
386 if (cdev->private->state != DEV_STATE_ONLINE &&
387 cdev->private->state != DEV_STATE_W4SENSE)
392 cdev->private->intparm = intparm;
397 * ccw_device_resume() - resume channel program execution
398 * @cdev: target ccw device
400 * ccw_device_resume() calls rsch on @cdev's subchannel.
403 * -%ENODEV on device not operational,
404 * -%EINVAL on invalid device state,
405 * -%EBUSY on device busy or interrupt pending.
407 * Interrupts disabled, ccw device lock held
409 int ccw_device_resume(struct ccw_device *cdev)
411 struct subchannel *sch;
413 if (!cdev || !cdev->dev.parent)
415 sch = to_subchannel(cdev->dev.parent);
416 if (!sch->schib.pmcw.ena)
418 if (cdev->private->state == DEV_STATE_NOT_OPER)
420 if (cdev->private->state != DEV_STATE_ONLINE ||
421 !(sch->schib.scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
423 return cio_resume(sch);
427 * ccw_device_get_ciw() - Search for CIW command in extended sense data.
428 * @cdev: ccw device to inspect
429 * @ct: command type to look for
431 * During SenseID, command information words (CIWs) describing special
432 * commands available to the device may have been stored in the extended
433 * sense data. This function searches for CIWs of a specified command
434 * type in the extended sense data.
436 * %NULL if no extended sense data has been stored or if no CIW of the
437 * specified command type could be found,
438 * else a pointer to the CIW of the specified command type.
440 struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
444 if (cdev->private->flags.esid == 0)
446 for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
447 if (cdev->private->dma_area->senseid.ciw[ciw_cnt].ct == ct)
448 return cdev->private->dma_area->senseid.ciw + ciw_cnt;
453 * ccw_device_get_path_mask() - get currently available paths
454 * @cdev: ccw device to be queried
456 * %0 if no subchannel for the device is available,
457 * else the mask of currently available paths for the ccw device's subchannel.
459 __u8 ccw_device_get_path_mask(struct ccw_device *cdev)
461 struct subchannel *sch;
463 if (!cdev->dev.parent)
466 sch = to_subchannel(cdev->dev.parent);
471 * ccw_device_get_chp_desc() - return newly allocated channel-path descriptor
472 * @cdev: device to obtain the descriptor for
473 * @chp_idx: index of the channel path
475 * On success return a newly allocated copy of the channel-path description
476 * data associated with the given channel path. Return %NULL on error.
478 struct channel_path_desc_fmt0 *ccw_device_get_chp_desc(struct ccw_device *cdev,
481 struct subchannel *sch;
484 sch = to_subchannel(cdev->dev.parent);
486 chpid.id = sch->schib.pmcw.chpid[chp_idx];
487 return chp_get_chp_desc(chpid);
491 * ccw_device_get_util_str() - return newly allocated utility strings
492 * @cdev: device to obtain the utility strings for
493 * @chp_idx: index of the channel path
495 * On success return a newly allocated copy of the utility strings
496 * associated with the given channel path. Return %NULL on error.
498 u8 *ccw_device_get_util_str(struct ccw_device *cdev, int chp_idx)
500 struct subchannel *sch = to_subchannel(cdev->dev.parent);
501 struct channel_path *chp;
506 chpid.id = sch->schib.pmcw.chpid[chp_idx];
507 chp = chpid_to_chp(chpid);
509 util_str = kmalloc(sizeof(chp->desc_fmt3.util_str), GFP_KERNEL);
513 mutex_lock(&chp->lock);
514 memcpy(util_str, chp->desc_fmt3.util_str, sizeof(chp->desc_fmt3.util_str));
515 mutex_unlock(&chp->lock);
521 * ccw_device_get_id() - obtain a ccw device id
522 * @cdev: device to obtain the id for
523 * @dev_id: where to fill in the values
525 void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
527 *dev_id = cdev->private->dev_id;
529 EXPORT_SYMBOL(ccw_device_get_id);
532 * ccw_device_tm_start_timeout_key() - perform start function
533 * @cdev: ccw device on which to perform the start function
534 * @tcw: transport-command word to be started
535 * @intparm: user defined parameter to be passed to the interrupt handler
536 * @lpm: mask of paths to use
537 * @key: storage key to use for storage access
538 * @expires: time span in jiffies after which to abort request
540 * Start the tcw on the given ccw device. Return zero on success, non-zero
543 int ccw_device_tm_start_timeout_key(struct ccw_device *cdev, struct tcw *tcw,
544 unsigned long intparm, u8 lpm, u8 key,
547 struct subchannel *sch;
550 sch = to_subchannel(cdev->dev.parent);
551 if (!sch->schib.pmcw.ena)
553 if (cdev->private->state == DEV_STATE_VERIFY) {
554 /* Remember to fake irb when finished. */
555 if (!cdev->private->flags.fake_irb) {
556 cdev->private->flags.fake_irb = FAKE_TM_IRB;
557 cdev->private->intparm = intparm;
558 CIO_MSG_EVENT(2, "fakeirb: queue device 0.%x.%04x intparm %lx type=%d\n",
559 cdev->private->dev_id.ssid,
560 cdev->private->dev_id.devno, intparm,
561 cdev->private->flags.fake_irb);
564 /* There's already a fake I/O around. */
567 if (cdev->private->state != DEV_STATE_ONLINE)
569 /* Adjust requested path mask to exclude unusable paths. */
575 rc = cio_tm_start_key(sch, tcw, lpm, key);
577 cdev->private->intparm = intparm;
579 ccw_device_set_timeout(cdev, expires);
583 EXPORT_SYMBOL(ccw_device_tm_start_timeout_key);
586 * ccw_device_tm_start_key() - perform start function
587 * @cdev: ccw device on which to perform the start function
588 * @tcw: transport-command word to be started
589 * @intparm: user defined parameter to be passed to the interrupt handler
590 * @lpm: mask of paths to use
591 * @key: storage key to use for storage access
593 * Start the tcw on the given ccw device. Return zero on success, non-zero
596 int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw,
597 unsigned long intparm, u8 lpm, u8 key)
599 return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm, key, 0);
601 EXPORT_SYMBOL(ccw_device_tm_start_key);
604 * ccw_device_tm_start() - perform start function
605 * @cdev: ccw device on which to perform the start function
606 * @tcw: transport-command word to be started
607 * @intparm: user defined parameter to be passed to the interrupt handler
608 * @lpm: mask of paths to use
610 * Start the tcw on the given ccw device. Return zero on success, non-zero
613 int ccw_device_tm_start(struct ccw_device *cdev, struct tcw *tcw,
614 unsigned long intparm, u8 lpm)
616 return ccw_device_tm_start_key(cdev, tcw, intparm, lpm,
619 EXPORT_SYMBOL(ccw_device_tm_start);
622 * ccw_device_tm_start_timeout() - perform start function
623 * @cdev: ccw device on which to perform the start function
624 * @tcw: transport-command word to be started
625 * @intparm: user defined parameter to be passed to the interrupt handler
626 * @lpm: mask of paths to use
627 * @expires: time span in jiffies after which to abort request
629 * Start the tcw on the given ccw device. Return zero on success, non-zero
632 int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
633 unsigned long intparm, u8 lpm, int expires)
635 return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm,
636 PAGE_DEFAULT_KEY, expires);
638 EXPORT_SYMBOL(ccw_device_tm_start_timeout);
641 * ccw_device_get_mdc() - accumulate max data count
642 * @cdev: ccw device for which the max data count is accumulated
643 * @mask: mask of paths to use
645 * Return the number of 64K-bytes blocks all paths at least support
646 * for a transport command. Return value 0 indicates failure.
648 int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
650 struct subchannel *sch = to_subchannel(cdev->dev.parent);
651 struct channel_path *chp;
655 /* Adjust requested path mask to excluded varied off paths. */
662 for (i = 0; i < 8; i++) {
663 if (!(mask & (0x80 >> i)))
665 chpid.id = sch->schib.pmcw.chpid[i];
666 chp = chpid_to_chp(chpid);
670 mutex_lock(&chp->lock);
671 if (!chp->desc_fmt1.f) {
672 mutex_unlock(&chp->lock);
675 if (!chp->desc_fmt1.r)
677 mdc = mdc ? min_t(int, mdc, chp->desc_fmt1.mdc) :
679 mutex_unlock(&chp->lock);
684 EXPORT_SYMBOL(ccw_device_get_mdc);
687 * ccw_device_tm_intrg() - perform interrogate function
688 * @cdev: ccw device on which to perform the interrogate function
690 * Perform an interrogate function on the given ccw device. Return zero on
691 * success, non-zero otherwise.
693 int ccw_device_tm_intrg(struct ccw_device *cdev)
695 struct subchannel *sch = to_subchannel(cdev->dev.parent);
697 if (!sch->schib.pmcw.ena)
699 if (cdev->private->state != DEV_STATE_ONLINE)
701 if (!scsw_is_tm(&sch->schib.scsw) ||
702 !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_START_PEND))
704 return cio_tm_intrg(sch);
706 EXPORT_SYMBOL(ccw_device_tm_intrg);
709 * ccw_device_get_schid() - obtain a subchannel id
710 * @cdev: device to obtain the id for
711 * @schid: where to fill in the values
713 void ccw_device_get_schid(struct ccw_device *cdev, struct subchannel_id *schid)
715 struct subchannel *sch = to_subchannel(cdev->dev.parent);
719 EXPORT_SYMBOL_GPL(ccw_device_get_schid);
722 * ccw_device_pnso() - Perform Network-Subchannel Operation
723 * @cdev: device on which PNSO is performed
724 * @pnso_area: request and response block for the operation
725 * @oc: Operation Code
726 * @resume_token: resume token for multiblock response
727 * @cnc: Boolean change-notification control
729 * pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
731 * Returns 0 on success.
733 int ccw_device_pnso(struct ccw_device *cdev,
734 struct chsc_pnso_area *pnso_area, u8 oc,
735 struct chsc_pnso_resume_token resume_token, int cnc)
737 struct subchannel_id schid;
739 ccw_device_get_schid(cdev, &schid);
740 return chsc_pnso(schid, pnso_area, oc, resume_token, cnc);
742 EXPORT_SYMBOL_GPL(ccw_device_pnso);
745 * ccw_device_get_cssid() - obtain Channel Subsystem ID
746 * @cdev: device to obtain the CSSID for
747 * @cssid: The resulting Channel Subsystem ID
749 int ccw_device_get_cssid(struct ccw_device *cdev, u8 *cssid)
751 struct device *sch_dev = cdev->dev.parent;
752 struct channel_subsystem *css = to_css(sch_dev->parent);
756 return css->id_valid ? 0 : -ENODEV;
758 EXPORT_SYMBOL_GPL(ccw_device_get_cssid);
761 * ccw_device_get_iid() - obtain MIF-image ID
762 * @cdev: device to obtain the MIF-image ID for
763 * @iid: The resulting MIF-image ID
765 int ccw_device_get_iid(struct ccw_device *cdev, u8 *iid)
767 struct device *sch_dev = cdev->dev.parent;
768 struct channel_subsystem *css = to_css(sch_dev->parent);
772 return css->id_valid ? 0 : -ENODEV;
774 EXPORT_SYMBOL_GPL(ccw_device_get_iid);
777 * ccw_device_get_chpid() - obtain Channel Path ID
778 * @cdev: device to obtain the Channel Path ID for
779 * @chp_idx: Index of the channel path
780 * @chpid: The resulting Channel Path ID
782 int ccw_device_get_chpid(struct ccw_device *cdev, int chp_idx, u8 *chpid)
784 struct subchannel *sch = to_subchannel(cdev->dev.parent);
787 if ((chp_idx < 0) || (chp_idx > 7))
789 mask = 0x80 >> chp_idx;
790 if (!(sch->schib.pmcw.pim & mask))
793 *chpid = sch->schib.pmcw.chpid[chp_idx];
796 EXPORT_SYMBOL_GPL(ccw_device_get_chpid);
799 * ccw_device_get_chid() - obtain Channel ID associated with specified CHPID
800 * @cdev: device to obtain the Channel ID for
801 * @chp_idx: Index of the channel path
802 * @chid: The resulting Channel ID
804 int ccw_device_get_chid(struct ccw_device *cdev, int chp_idx, u16 *chid)
806 struct chp_id cssid_chpid;
807 struct channel_path *chp;
810 chp_id_init(&cssid_chpid);
811 rc = ccw_device_get_chpid(cdev, chp_idx, &cssid_chpid.id);
814 chp = chpid_to_chp(cssid_chpid);
818 mutex_lock(&chp->lock);
819 if (chp->desc_fmt1.flags & 0x10)
820 *chid = chp->desc_fmt1.chid;
823 mutex_unlock(&chp->lock);
827 EXPORT_SYMBOL_GPL(ccw_device_get_chid);
830 * Allocate zeroed dma coherent 31 bit addressable memory using
831 * the subchannels dma pool. Maximal size of allocation supported
834 void *ccw_device_dma_zalloc(struct ccw_device *cdev, size_t size,
839 if (!get_device(&cdev->dev))
841 addr = __cio_gp_dma_zalloc(cdev->private->dma_pool, &cdev->dev, size, dma_handle);
842 if (IS_ERR_OR_NULL(addr))
843 put_device(&cdev->dev);
846 EXPORT_SYMBOL(ccw_device_dma_zalloc);
848 void ccw_device_dma_free(struct ccw_device *cdev, void *cpu_addr, size_t size)
852 cio_gp_dma_free(cdev->private->dma_pool, cpu_addr, size);
853 put_device(&cdev->dev);
855 EXPORT_SYMBOL(ccw_device_dma_free);
857 EXPORT_SYMBOL(ccw_device_set_options_mask);
858 EXPORT_SYMBOL(ccw_device_set_options);
859 EXPORT_SYMBOL(ccw_device_clear_options);
860 EXPORT_SYMBOL(ccw_device_clear);
861 EXPORT_SYMBOL(ccw_device_halt);
862 EXPORT_SYMBOL(ccw_device_resume);
863 EXPORT_SYMBOL(ccw_device_start_timeout);
864 EXPORT_SYMBOL(ccw_device_start);
865 EXPORT_SYMBOL(ccw_device_start_timeout_key);
866 EXPORT_SYMBOL(ccw_device_start_key);
867 EXPORT_SYMBOL(ccw_device_get_ciw);
868 EXPORT_SYMBOL(ccw_device_get_path_mask);
869 EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
870 EXPORT_SYMBOL_GPL(ccw_device_get_util_str);