Loading...
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 */
38int 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 */
63int 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 */
90void 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 */
105int ccw_device_is_pathgroup(struct ccw_device *cdev)
106{
107 return cdev->private->flags.pgroup;
108}
109EXPORT_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 */
117int ccw_device_is_multipath(struct ccw_device *cdev)
118{
119 return cdev->private->flags.mpath;
120}
121EXPORT_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 */
138int 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_key() - start a s390 channel program with 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 *
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 * Returns:
177 * %0, if the operation was successful;
178 * -%EBUSY, if the device is busy, or status pending;
179 * -%EACCES, if no path specified in @lpm is operational;
180 * -%ENODEV, if the device is not operational.
181 * Context:
182 * Interrupts disabled, ccw device lock held
183 */
184int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
185 unsigned long intparm, __u8 lpm, __u8 key,
186 unsigned long flags)
187{
188 struct subchannel *sch;
189 int ret;
190
191 if (!cdev || !cdev->dev.parent)
192 return -ENODEV;
193 sch = to_subchannel(cdev->dev.parent);
194 if (!sch->schib.pmcw.ena)
195 return -EINVAL;
196 if (cdev->private->state == DEV_STATE_NOT_OPER)
197 return -ENODEV;
198 if (cdev->private->state == DEV_STATE_VERIFY) {
199 /* Remember to fake irb when finished. */
200 if (!cdev->private->flags.fake_irb) {
201 cdev->private->flags.fake_irb = 1;
202 cdev->private->intparm = intparm;
203 return 0;
204 } else
205 /* There's already a fake I/O around. */
206 return -EBUSY;
207 }
208 if (cdev->private->state != DEV_STATE_ONLINE ||
209 ((sch->schib.scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
210 !(sch->schib.scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS)) ||
211 cdev->private->flags.doverify)
212 return -EBUSY;
213 ret = cio_set_options (sch, flags);
214 if (ret)
215 return ret;
216 /* Adjust requested path mask to excluded varied off paths. */
217 if (lpm) {
218 lpm &= sch->opm;
219 if (lpm == 0)
220 return -EACCES;
221 }
222 ret = cio_start_key (sch, cpa, lpm, key);
223 switch (ret) {
224 case 0:
225 cdev->private->intparm = intparm;
226 break;
227 case -EACCES:
228 case -ENODEV:
229 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
230 break;
231 }
232 return ret;
233}
234
235/**
236 * ccw_device_start_timeout_key() - start a s390 channel program with timeout and key
237 * @cdev: target ccw device
238 * @cpa: logical start address of channel program
239 * @intparm: user specific interruption parameter; will be presented back to
240 * @cdev's interrupt handler. Allows a device driver to associate
241 * the interrupt with a particular I/O request.
242 * @lpm: defines the channel path to be used for a specific I/O request. A
243 * value of 0 will make cio use the opm.
244 * @key: storage key to be used for the I/O
245 * @flags: additional flags; defines the action to be performed for I/O
246 * processing.
247 * @expires: timeout value in jiffies
248 *
249 * Start a S/390 channel program. When the interrupt arrives, the
250 * IRQ handler is called, either immediately, delayed (dev-end missing,
251 * or sense required) or never (no IRQ handler registered).
252 * This function notifies the device driver if the channel program has not
253 * completed during the time specified by @expires. If a timeout occurs, the
254 * channel program is terminated via xsch, hsch or csch, and the device's
255 * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
256 * Returns:
257 * %0, if the operation was successful;
258 * -%EBUSY, if the device is busy, or status pending;
259 * -%EACCES, if no path specified in @lpm is operational;
260 * -%ENODEV, if the device is not operational.
261 * Context:
262 * Interrupts disabled, ccw device lock held
263 */
264int ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
265 unsigned long intparm, __u8 lpm, __u8 key,
266 unsigned long flags, int expires)
267{
268 int ret;
269
270 if (!cdev)
271 return -ENODEV;
272 ccw_device_set_timeout(cdev, expires);
273 ret = ccw_device_start_key(cdev, cpa, intparm, lpm, key, flags);
274 if (ret != 0)
275 ccw_device_set_timeout(cdev, 0);
276 return ret;
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 * Returns:
295 * %0, if the operation was successful;
296 * -%EBUSY, if the device is busy, or status pending;
297 * -%EACCES, if no path specified in @lpm is operational;
298 * -%ENODEV, if the device is not operational.
299 * Context:
300 * Interrupts disabled, ccw device lock held
301 */
302int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
303 unsigned long intparm, __u8 lpm, unsigned long flags)
304{
305 return ccw_device_start_key(cdev, cpa, intparm, lpm,
306 PAGE_DEFAULT_KEY, flags);
307}
308
309/**
310 * ccw_device_start_timeout() - start a s390 channel program with timeout
311 * @cdev: target ccw device
312 * @cpa: logical start address of channel program
313 * @intparm: user specific interruption parameter; will be presented back to
314 * @cdev's interrupt handler. Allows a device driver to associate
315 * the interrupt with a particular I/O request.
316 * @lpm: defines the channel path to be used for a specific I/O request. A
317 * value of 0 will make cio use the opm.
318 * @flags: additional flags; defines the action to be performed for I/O
319 * processing.
320 * @expires: timeout value in jiffies
321 *
322 * Start a S/390 channel program. When the interrupt arrives, the
323 * IRQ handler is called, either immediately, delayed (dev-end missing,
324 * or sense required) or never (no IRQ handler registered).
325 * This function notifies the device driver if the channel program has not
326 * completed during the time specified by @expires. If a timeout occurs, the
327 * channel program is terminated via xsch, hsch or csch, and the device's
328 * interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
329 * Returns:
330 * %0, if the operation was successful;
331 * -%EBUSY, if the device is busy, or status pending;
332 * -%EACCES, if no path specified in @lpm is operational;
333 * -%ENODEV, if the device is not operational.
334 * Context:
335 * Interrupts disabled, ccw device lock held
336 */
337int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
338 unsigned long intparm, __u8 lpm,
339 unsigned long flags, int expires)
340{
341 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
342 PAGE_DEFAULT_KEY, flags,
343 expires);
344}
345
346
347/**
348 * ccw_device_halt() - halt I/O request processing
349 * @cdev: target ccw device
350 * @intparm: interruption parameter; value is only used if no I/O is
351 * outstanding, otherwise the intparm associated with the I/O request
352 * is returned
353 *
354 * ccw_device_halt() calls hsch on @cdev's subchannel.
355 * Returns:
356 * %0 on success,
357 * -%ENODEV on device not operational,
358 * -%EINVAL on invalid device state,
359 * -%EBUSY on device busy or interrupt pending.
360 * Context:
361 * Interrupts disabled, ccw device lock held
362 */
363int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
364{
365 struct subchannel *sch;
366 int ret;
367
368 if (!cdev || !cdev->dev.parent)
369 return -ENODEV;
370 sch = to_subchannel(cdev->dev.parent);
371 if (!sch->schib.pmcw.ena)
372 return -EINVAL;
373 if (cdev->private->state == DEV_STATE_NOT_OPER)
374 return -ENODEV;
375 if (cdev->private->state != DEV_STATE_ONLINE &&
376 cdev->private->state != DEV_STATE_W4SENSE)
377 return -EINVAL;
378
379 ret = cio_halt(sch);
380 if (ret == 0)
381 cdev->private->intparm = intparm;
382 return ret;
383}
384
385/**
386 * ccw_device_resume() - resume channel program execution
387 * @cdev: target ccw device
388 *
389 * ccw_device_resume() calls rsch on @cdev's subchannel.
390 * Returns:
391 * %0 on success,
392 * -%ENODEV on device not operational,
393 * -%EINVAL on invalid device state,
394 * -%EBUSY on device busy or interrupt pending.
395 * Context:
396 * Interrupts disabled, ccw device lock held
397 */
398int ccw_device_resume(struct ccw_device *cdev)
399{
400 struct subchannel *sch;
401
402 if (!cdev || !cdev->dev.parent)
403 return -ENODEV;
404 sch = to_subchannel(cdev->dev.parent);
405 if (!sch->schib.pmcw.ena)
406 return -EINVAL;
407 if (cdev->private->state == DEV_STATE_NOT_OPER)
408 return -ENODEV;
409 if (cdev->private->state != DEV_STATE_ONLINE ||
410 !(sch->schib.scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
411 return -EINVAL;
412 return cio_resume(sch);
413}
414
415/*
416 * Pass interrupt to device driver.
417 */
418int
419ccw_device_call_handler(struct ccw_device *cdev)
420{
421 unsigned int stctl;
422 int ending_status;
423
424 /*
425 * we allow for the device action handler if .
426 * - we received ending status
427 * - the action handler requested to see all interrupts
428 * - we received an intermediate status
429 * - fast notification was requested (primary status)
430 * - unsolicited interrupts
431 */
432 stctl = scsw_stctl(&cdev->private->irb.scsw);
433 ending_status = (stctl & SCSW_STCTL_SEC_STATUS) ||
434 (stctl == (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)) ||
435 (stctl == SCSW_STCTL_STATUS_PEND);
436 if (!ending_status &&
437 !cdev->private->options.repall &&
438 !(stctl & SCSW_STCTL_INTER_STATUS) &&
439 !(cdev->private->options.fast &&
440 (stctl & SCSW_STCTL_PRIM_STATUS)))
441 return 0;
442
443 /* Clear pending timers for device driver initiated I/O. */
444 if (ending_status)
445 ccw_device_set_timeout(cdev, 0);
446 /*
447 * Now we are ready to call the device driver interrupt handler.
448 */
449 if (cdev->handler)
450 cdev->handler(cdev, cdev->private->intparm,
451 &cdev->private->irb);
452
453 /*
454 * Clear the old and now useless interrupt response block.
455 */
456 memset(&cdev->private->irb, 0, sizeof(struct irb));
457
458 return 1;
459}
460
461/**
462 * ccw_device_get_ciw() - Search for CIW command in extended sense data.
463 * @cdev: ccw device to inspect
464 * @ct: command type to look for
465 *
466 * During SenseID, command information words (CIWs) describing special
467 * commands available to the device may have been stored in the extended
468 * sense data. This function searches for CIWs of a specified command
469 * type in the extended sense data.
470 * Returns:
471 * %NULL if no extended sense data has been stored or if no CIW of the
472 * specified command type could be found,
473 * else a pointer to the CIW of the specified command type.
474 */
475struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
476{
477 int ciw_cnt;
478
479 if (cdev->private->flags.esid == 0)
480 return NULL;
481 for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
482 if (cdev->private->senseid.ciw[ciw_cnt].ct == ct)
483 return cdev->private->senseid.ciw + ciw_cnt;
484 return NULL;
485}
486
487/**
488 * ccw_device_get_path_mask() - get currently available paths
489 * @cdev: ccw device to be queried
490 * Returns:
491 * %0 if no subchannel for the device is available,
492 * else the mask of currently available paths for the ccw device's subchannel.
493 */
494__u8 ccw_device_get_path_mask(struct ccw_device *cdev)
495{
496 struct subchannel *sch;
497
498 if (!cdev->dev.parent)
499 return 0;
500
501 sch = to_subchannel(cdev->dev.parent);
502 return sch->lpm;
503}
504
505struct stlck_data {
506 struct completion done;
507 int rc;
508};
509
510void ccw_device_stlck_done(struct ccw_device *cdev, void *data, int rc)
511{
512 struct stlck_data *sdata = data;
513
514 sdata->rc = rc;
515 complete(&sdata->done);
516}
517
518/*
519 * Perform unconditional reserve + release.
520 */
521int ccw_device_stlck(struct ccw_device *cdev)
522{
523 struct subchannel *sch = to_subchannel(cdev->dev.parent);
524 struct stlck_data data;
525 u8 *buffer;
526 int rc;
527
528 /* Check if steal lock operation is valid for this device. */
529 if (cdev->drv) {
530 if (!cdev->private->options.force)
531 return -EINVAL;
532 }
533 buffer = kzalloc(64, GFP_DMA | GFP_KERNEL);
534 if (!buffer)
535 return -ENOMEM;
536 init_completion(&data.done);
537 data.rc = -EIO;
538 spin_lock_irq(sch->lock);
539 rc = cio_enable_subchannel(sch, (u32) (addr_t) sch);
540 if (rc)
541 goto out_unlock;
542 /* Perform operation. */
543 cdev->private->state = DEV_STATE_STEAL_LOCK,
544 ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]);
545 spin_unlock_irq(sch->lock);
546 /* Wait for operation to finish. */
547 if (wait_for_completion_interruptible(&data.done)) {
548 /* Got a signal. */
549 spin_lock_irq(sch->lock);
550 ccw_request_cancel(cdev);
551 spin_unlock_irq(sch->lock);
552 wait_for_completion(&data.done);
553 }
554 rc = data.rc;
555 /* Check results. */
556 spin_lock_irq(sch->lock);
557 cio_disable_subchannel(sch);
558 cdev->private->state = DEV_STATE_BOXED;
559out_unlock:
560 spin_unlock_irq(sch->lock);
561 kfree(buffer);
562
563 return rc;
564}
565
566void *ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
567{
568 struct subchannel *sch;
569 struct chp_id chpid;
570
571 sch = to_subchannel(cdev->dev.parent);
572 chp_id_init(&chpid);
573 chpid.id = sch->schib.pmcw.chpid[chp_no];
574 return chp_get_chp_desc(chpid);
575}
576
577/**
578 * ccw_device_get_id - obtain a ccw device id
579 * @cdev: device to obtain the id for
580 * @dev_id: where to fill in the values
581 */
582void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
583{
584 *dev_id = cdev->private->dev_id;
585}
586EXPORT_SYMBOL(ccw_device_get_id);
587
588/**
589 * ccw_device_tm_start_key - perform start function
590 * @cdev: ccw device on which to perform the start function
591 * @tcw: transport-command word to be started
592 * @intparm: user defined parameter to be passed to the interrupt handler
593 * @lpm: mask of paths to use
594 * @key: storage key to use for storage access
595 *
596 * Start the tcw on the given ccw device. Return zero on success, non-zero
597 * otherwise.
598 */
599int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw,
600 unsigned long intparm, u8 lpm, u8 key)
601{
602 struct subchannel *sch;
603 int rc;
604
605 sch = to_subchannel(cdev->dev.parent);
606 if (!sch->schib.pmcw.ena)
607 return -EINVAL;
608 if (cdev->private->state != DEV_STATE_ONLINE)
609 return -EIO;
610 /* Adjust requested path mask to excluded varied off paths. */
611 if (lpm) {
612 lpm &= sch->opm;
613 if (lpm == 0)
614 return -EACCES;
615 }
616 rc = cio_tm_start_key(sch, tcw, lpm, key);
617 if (rc == 0)
618 cdev->private->intparm = intparm;
619 return rc;
620}
621EXPORT_SYMBOL(ccw_device_tm_start_key);
622
623/**
624 * ccw_device_tm_start_timeout_key - perform start function
625 * @cdev: ccw device on which to perform the start function
626 * @tcw: transport-command word to be started
627 * @intparm: user defined parameter to be passed to the interrupt handler
628 * @lpm: mask of paths to use
629 * @key: storage key to use for storage access
630 * @expires: time span in jiffies after which to abort request
631 *
632 * Start the tcw on the given ccw device. Return zero on success, non-zero
633 * otherwise.
634 */
635int ccw_device_tm_start_timeout_key(struct ccw_device *cdev, struct tcw *tcw,
636 unsigned long intparm, u8 lpm, u8 key,
637 int expires)
638{
639 int ret;
640
641 ccw_device_set_timeout(cdev, expires);
642 ret = ccw_device_tm_start_key(cdev, tcw, intparm, lpm, key);
643 if (ret != 0)
644 ccw_device_set_timeout(cdev, 0);
645 return ret;
646}
647EXPORT_SYMBOL(ccw_device_tm_start_timeout_key);
648
649/**
650 * ccw_device_tm_start - perform start function
651 * @cdev: ccw device on which to perform the start function
652 * @tcw: transport-command word to be started
653 * @intparm: user defined parameter to be passed to the interrupt handler
654 * @lpm: mask of paths to use
655 *
656 * Start the tcw on the given ccw device. Return zero on success, non-zero
657 * otherwise.
658 */
659int ccw_device_tm_start(struct ccw_device *cdev, struct tcw *tcw,
660 unsigned long intparm, u8 lpm)
661{
662 return ccw_device_tm_start_key(cdev, tcw, intparm, lpm,
663 PAGE_DEFAULT_KEY);
664}
665EXPORT_SYMBOL(ccw_device_tm_start);
666
667/**
668 * ccw_device_tm_start_timeout - perform start function
669 * @cdev: ccw device on which to perform the start function
670 * @tcw: transport-command word to be started
671 * @intparm: user defined parameter to be passed to the interrupt handler
672 * @lpm: mask of paths to use
673 * @expires: time span in jiffies after which to abort request
674 *
675 * Start the tcw on the given ccw device. Return zero on success, non-zero
676 * otherwise.
677 */
678int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
679 unsigned long intparm, u8 lpm, int expires)
680{
681 return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm,
682 PAGE_DEFAULT_KEY, expires);
683}
684EXPORT_SYMBOL(ccw_device_tm_start_timeout);
685
686/**
687 * ccw_device_get_mdc - accumulate max data count
688 * @cdev: ccw device for which the max data count is accumulated
689 * @mask: mask of paths to use
690 *
691 * Return the number of 64K-bytes blocks all paths at least support
692 * for a transport command. Return values <= 0 indicate failures.
693 */
694int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
695{
696 struct subchannel *sch = to_subchannel(cdev->dev.parent);
697 struct channel_path_desc_fmt1 desc;
698 struct chp_id chpid;
699 int mdc = 0, ret, i;
700
701 /* Adjust requested path mask to excluded varied off paths. */
702 if (mask)
703 mask &= sch->lpm;
704 else
705 mask = sch->lpm;
706
707 chp_id_init(&chpid);
708 for (i = 0; i < 8; i++) {
709 if (!(mask & (0x80 >> i)))
710 continue;
711 chpid.id = sch->schib.pmcw.chpid[i];
712 ret = chsc_determine_fmt1_channel_path_desc(chpid, &desc);
713 if (ret)
714 return ret;
715 if (!desc.f)
716 return 0;
717 if (!desc.r)
718 mdc = 1;
719 mdc = mdc ? min(mdc, (int)desc.mdc) : desc.mdc;
720 }
721
722 return mdc;
723}
724EXPORT_SYMBOL(ccw_device_get_mdc);
725
726/**
727 * ccw_device_tm_intrg - perform interrogate function
728 * @cdev: ccw device on which to perform the interrogate function
729 *
730 * Perform an interrogate function on the given ccw device. Return zero on
731 * success, non-zero otherwise.
732 */
733int ccw_device_tm_intrg(struct ccw_device *cdev)
734{
735 struct subchannel *sch = to_subchannel(cdev->dev.parent);
736
737 if (!sch->schib.pmcw.ena)
738 return -EINVAL;
739 if (cdev->private->state != DEV_STATE_ONLINE)
740 return -EIO;
741 if (!scsw_is_tm(&sch->schib.scsw) ||
742 !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_START_PEND))
743 return -EINVAL;
744 return cio_tm_intrg(sch);
745}
746EXPORT_SYMBOL(ccw_device_tm_intrg);
747
748// FIXME: these have to go:
749
750int
751_ccw_device_get_subchannel_number(struct ccw_device *cdev)
752{
753 return cdev->private->schid.sch_no;
754}
755
756
757MODULE_LICENSE("GPL");
758EXPORT_SYMBOL(ccw_device_set_options_mask);
759EXPORT_SYMBOL(ccw_device_set_options);
760EXPORT_SYMBOL(ccw_device_clear_options);
761EXPORT_SYMBOL(ccw_device_clear);
762EXPORT_SYMBOL(ccw_device_halt);
763EXPORT_SYMBOL(ccw_device_resume);
764EXPORT_SYMBOL(ccw_device_start_timeout);
765EXPORT_SYMBOL(ccw_device_start);
766EXPORT_SYMBOL(ccw_device_start_timeout_key);
767EXPORT_SYMBOL(ccw_device_start_key);
768EXPORT_SYMBOL(ccw_device_get_ciw);
769EXPORT_SYMBOL(ccw_device_get_path_mask);
770EXPORT_SYMBOL(_ccw_device_get_subchannel_number);
771EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
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 */
39int 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 */
64int 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 */
91void 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 */
106int ccw_device_is_pathgroup(struct ccw_device *cdev)
107{
108 return cdev->private->flags.pgroup;
109}
110EXPORT_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 */
118int ccw_device_is_multipath(struct ccw_device *cdev)
119{
120 return cdev->private->flags.mpath;
121}
122EXPORT_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 */
137int 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 */
191int 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 */
271int 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 */
305int 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 */
343int 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 */
370int 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 */
405int 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 */
436struct 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 */
474struct 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 */
494u8 *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 */
521void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
522{
523 *dev_id = cdev->private->dev_id;
524}
525EXPORT_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 */
539int 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}
575EXPORT_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 */
588int 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}
593EXPORT_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 */
605int 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}
611EXPORT_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 */
624int 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}
630EXPORT_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 value 0 indicates failure.
639 */
640int 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}
676EXPORT_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 */
685int 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}
698EXPORT_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 */
705void 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}
711EXPORT_SYMBOL_GPL(ccw_device_get_schid);
712
713/**
714 * ccw_device_pnso() - Perform Network-Subchannel Operation
715 * @cdev: device on which PNSO is performed
716 * @pnso_area: request and response block for the operation
717 * @resume_token: resume token for multiblock response
718 * @cnc: Boolean change-notification control
719 *
720 * pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
721 *
722 * Returns 0 on success.
723 */
724int ccw_device_pnso(struct ccw_device *cdev,
725 struct chsc_pnso_area *pnso_area,
726 struct chsc_pnso_resume_token resume_token,
727 int cnc)
728{
729 struct subchannel_id schid;
730
731 ccw_device_get_schid(cdev, &schid);
732 return chsc_pnso(schid, pnso_area, resume_token, cnc);
733}
734EXPORT_SYMBOL_GPL(ccw_device_pnso);
735
736/*
737 * Allocate zeroed dma coherent 31 bit addressable memory using
738 * the subchannels dma pool. Maximal size of allocation supported
739 * is PAGE_SIZE.
740 */
741void *ccw_device_dma_zalloc(struct ccw_device *cdev, size_t size)
742{
743 return cio_gp_dma_zalloc(cdev->private->dma_pool, &cdev->dev, size);
744}
745EXPORT_SYMBOL(ccw_device_dma_zalloc);
746
747void ccw_device_dma_free(struct ccw_device *cdev, void *cpu_addr, size_t size)
748{
749 cio_gp_dma_free(cdev->private->dma_pool, cpu_addr, size);
750}
751EXPORT_SYMBOL(ccw_device_dma_free);
752
753EXPORT_SYMBOL(ccw_device_set_options_mask);
754EXPORT_SYMBOL(ccw_device_set_options);
755EXPORT_SYMBOL(ccw_device_clear_options);
756EXPORT_SYMBOL(ccw_device_clear);
757EXPORT_SYMBOL(ccw_device_halt);
758EXPORT_SYMBOL(ccw_device_resume);
759EXPORT_SYMBOL(ccw_device_start_timeout);
760EXPORT_SYMBOL(ccw_device_start);
761EXPORT_SYMBOL(ccw_device_start_timeout_key);
762EXPORT_SYMBOL(ccw_device_start_key);
763EXPORT_SYMBOL(ccw_device_get_ciw);
764EXPORT_SYMBOL(ccw_device_get_path_mask);
765EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
766EXPORT_SYMBOL_GPL(ccw_device_get_util_str);