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 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);
215 return 0;
216 } else
217 /* There's already a fake I/O around. */
218 return -EBUSY;
219 }
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)))
223 return -EBUSY;
224 ret = cio_set_options (sch, flags);
225 if (ret)
226 return ret;
227 /* Adjust requested path mask to exclude unusable paths. */
228 if (lpm) {
229 lpm &= sch->lpm;
230 if (lpm == 0)
231 return -EACCES;
232 }
233 ret = cio_start_key (sch, cpa, lpm, key);
234 switch (ret) {
235 case 0:
236 cdev->private->intparm = intparm;
237 if (expires)
238 ccw_device_set_timeout(cdev, expires);
239 break;
240 case -EACCES:
241 case -ENODEV:
242 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
243 break;
244 }
245 return ret;
246}
247
248/**
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
259 * processing.
260 *
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().
267 * Returns:
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.
272 * Context:
273 * Interrupts disabled, ccw device lock held
274 */
275int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
276 unsigned long intparm, __u8 lpm, __u8 key,
277 unsigned long flags)
278{
279 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm, key,
280 flags, 0);
281}
282
283/**
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
293 * processing.
294 *
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().
301 * Returns:
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.
306 * Context:
307 * Interrupts disabled, ccw device lock held
308 */
309int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
310 unsigned long intparm, __u8 lpm, unsigned long flags)
311{
312 return ccw_device_start_key(cdev, cpa, intparm, lpm,
313 PAGE_DEFAULT_KEY, flags);
314}
315
316/**
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
326 * processing.
327 * @expires: timeout value in jiffies
328 *
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().
339 * Returns:
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.
344 * Context:
345 * Interrupts disabled, ccw device lock held
346 */
347int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
348 unsigned long intparm, __u8 lpm,
349 unsigned long flags, int expires)
350{
351 return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
352 PAGE_DEFAULT_KEY, flags,
353 expires);
354}
355
356
357/**
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
361 *
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().
366 * Returns:
367 * %0 on success,
368 * -%ENODEV on device not operational,
369 * -%EINVAL on invalid device state,
370 * -%EBUSY on device busy or interrupt pending.
371 * Context:
372 * Interrupts disabled, ccw device lock held
373 */
374int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
375{
376 struct subchannel *sch;
377 int ret;
378
379 if (!cdev || !cdev->dev.parent)
380 return -ENODEV;
381 sch = to_subchannel(cdev->dev.parent);
382 if (!sch->schib.pmcw.ena)
383 return -EINVAL;
384 if (cdev->private->state == DEV_STATE_NOT_OPER)
385 return -ENODEV;
386 if (cdev->private->state != DEV_STATE_ONLINE &&
387 cdev->private->state != DEV_STATE_W4SENSE)
388 return -EINVAL;
389
390 ret = cio_halt(sch);
391 if (ret == 0)
392 cdev->private->intparm = intparm;
393 return ret;
394}
395
396/**
397 * ccw_device_resume() - resume channel program execution
398 * @cdev: target ccw device
399 *
400 * ccw_device_resume() calls rsch on @cdev's subchannel.
401 * Returns:
402 * %0 on success,
403 * -%ENODEV on device not operational,
404 * -%EINVAL on invalid device state,
405 * -%EBUSY on device busy or interrupt pending.
406 * Context:
407 * Interrupts disabled, ccw device lock held
408 */
409int ccw_device_resume(struct ccw_device *cdev)
410{
411 struct subchannel *sch;
412
413 if (!cdev || !cdev->dev.parent)
414 return -ENODEV;
415 sch = to_subchannel(cdev->dev.parent);
416 if (!sch->schib.pmcw.ena)
417 return -EINVAL;
418 if (cdev->private->state == DEV_STATE_NOT_OPER)
419 return -ENODEV;
420 if (cdev->private->state != DEV_STATE_ONLINE ||
421 !(sch->schib.scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
422 return -EINVAL;
423 return cio_resume(sch);
424}
425
426/**
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
430 *
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.
435 * Returns:
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.
439 */
440struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
441{
442 int ciw_cnt;
443
444 if (cdev->private->flags.esid == 0)
445 return NULL;
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;
449 return NULL;
450}
451
452/**
453 * ccw_device_get_path_mask() - get currently available paths
454 * @cdev: ccw device to be queried
455 * Returns:
456 * %0 if no subchannel for the device is available,
457 * else the mask of currently available paths for the ccw device's subchannel.
458 */
459__u8 ccw_device_get_path_mask(struct ccw_device *cdev)
460{
461 struct subchannel *sch;
462
463 if (!cdev->dev.parent)
464 return 0;
465
466 sch = to_subchannel(cdev->dev.parent);
467 return sch->lpm;
468}
469
470/**
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
474 *
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.
477 */
478struct channel_path_desc_fmt0 *ccw_device_get_chp_desc(struct ccw_device *cdev,
479 int chp_idx)
480{
481 struct subchannel *sch;
482 struct chp_id chpid;
483
484 sch = to_subchannel(cdev->dev.parent);
485 chp_id_init(&chpid);
486 chpid.id = sch->schib.pmcw.chpid[chp_idx];
487 return chp_get_chp_desc(chpid);
488}
489
490/**
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
494 *
495 * On success return a newly allocated copy of the utility strings
496 * associated with the given channel path. Return %NULL on error.
497 */
498u8 *ccw_device_get_util_str(struct ccw_device *cdev, int chp_idx)
499{
500 struct subchannel *sch = to_subchannel(cdev->dev.parent);
501 struct channel_path *chp;
502 struct chp_id chpid;
503 u8 *util_str;
504
505 chp_id_init(&chpid);
506 chpid.id = sch->schib.pmcw.chpid[chp_idx];
507 chp = chpid_to_chp(chpid);
508
509 util_str = kmalloc(sizeof(chp->desc_fmt3.util_str), GFP_KERNEL);
510 if (!util_str)
511 return NULL;
512
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);
516
517 return util_str;
518}
519
520/**
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
524 */
525void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
526{
527 *dev_id = cdev->private->dev_id;
528}
529EXPORT_SYMBOL(ccw_device_get_id);
530
531/**
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
539 *
540 * Start the tcw on the given ccw device. Return zero on success, non-zero
541 * otherwise.
542 */
543int ccw_device_tm_start_timeout_key(struct ccw_device *cdev, struct tcw *tcw,
544 unsigned long intparm, u8 lpm, u8 key,
545 int expires)
546{
547 struct subchannel *sch;
548 int rc;
549
550 sch = to_subchannel(cdev->dev.parent);
551 if (!sch->schib.pmcw.ena)
552 return -EINVAL;
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);
562 return 0;
563 } else
564 /* There's already a fake I/O around. */
565 return -EBUSY;
566 }
567 if (cdev->private->state != DEV_STATE_ONLINE)
568 return -EIO;
569 /* Adjust requested path mask to exclude unusable paths. */
570 if (lpm) {
571 lpm &= sch->lpm;
572 if (lpm == 0)
573 return -EACCES;
574 }
575 rc = cio_tm_start_key(sch, tcw, lpm, key);
576 if (rc == 0) {
577 cdev->private->intparm = intparm;
578 if (expires)
579 ccw_device_set_timeout(cdev, expires);
580 }
581 return rc;
582}
583EXPORT_SYMBOL(ccw_device_tm_start_timeout_key);
584
585/**
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
592 *
593 * Start the tcw on the given ccw device. Return zero on success, non-zero
594 * otherwise.
595 */
596int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw,
597 unsigned long intparm, u8 lpm, u8 key)
598{
599 return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm, key, 0);
600}
601EXPORT_SYMBOL(ccw_device_tm_start_key);
602
603/**
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
609 *
610 * Start the tcw on the given ccw device. Return zero on success, non-zero
611 * otherwise.
612 */
613int ccw_device_tm_start(struct ccw_device *cdev, struct tcw *tcw,
614 unsigned long intparm, u8 lpm)
615{
616 return ccw_device_tm_start_key(cdev, tcw, intparm, lpm,
617 PAGE_DEFAULT_KEY);
618}
619EXPORT_SYMBOL(ccw_device_tm_start);
620
621/**
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
628 *
629 * Start the tcw on the given ccw device. Return zero on success, non-zero
630 * otherwise.
631 */
632int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
633 unsigned long intparm, u8 lpm, int expires)
634{
635 return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm,
636 PAGE_DEFAULT_KEY, expires);
637}
638EXPORT_SYMBOL(ccw_device_tm_start_timeout);
639
640/**
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
644 *
645 * Return the number of 64K-bytes blocks all paths at least support
646 * for a transport command. Return value 0 indicates failure.
647 */
648int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
649{
650 struct subchannel *sch = to_subchannel(cdev->dev.parent);
651 struct channel_path *chp;
652 struct chp_id chpid;
653 int mdc = 0, i;
654
655 /* Adjust requested path mask to excluded varied off paths. */
656 if (mask)
657 mask &= sch->lpm;
658 else
659 mask = sch->lpm;
660
661 chp_id_init(&chpid);
662 for (i = 0; i < 8; i++) {
663 if (!(mask & (0x80 >> i)))
664 continue;
665 chpid.id = sch->schib.pmcw.chpid[i];
666 chp = chpid_to_chp(chpid);
667 if (!chp)
668 continue;
669
670 mutex_lock(&chp->lock);
671 if (!chp->desc_fmt1.f) {
672 mutex_unlock(&chp->lock);
673 return 0;
674 }
675 if (!chp->desc_fmt1.r)
676 mdc = 1;
677 mdc = mdc ? min_t(int, mdc, chp->desc_fmt1.mdc) :
678 chp->desc_fmt1.mdc;
679 mutex_unlock(&chp->lock);
680 }
681
682 return mdc;
683}
684EXPORT_SYMBOL(ccw_device_get_mdc);
685
686/**
687 * ccw_device_tm_intrg() - perform interrogate function
688 * @cdev: ccw device on which to perform the interrogate function
689 *
690 * Perform an interrogate function on the given ccw device. Return zero on
691 * success, non-zero otherwise.
692 */
693int ccw_device_tm_intrg(struct ccw_device *cdev)
694{
695 struct subchannel *sch = to_subchannel(cdev->dev.parent);
696
697 if (!sch->schib.pmcw.ena)
698 return -EINVAL;
699 if (cdev->private->state != DEV_STATE_ONLINE)
700 return -EIO;
701 if (!scsw_is_tm(&sch->schib.scsw) ||
702 !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_START_PEND))
703 return -EINVAL;
704 return cio_tm_intrg(sch);
705}
706EXPORT_SYMBOL(ccw_device_tm_intrg);
707
708/**
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
712 */
713void ccw_device_get_schid(struct ccw_device *cdev, struct subchannel_id *schid)
714{
715 struct subchannel *sch = to_subchannel(cdev->dev.parent);
716
717 *schid = sch->schid;
718}
719EXPORT_SYMBOL_GPL(ccw_device_get_schid);
720
721/**
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
728 *
729 * pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
730 *
731 * Returns 0 on success.
732 */
733int 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)
736{
737 struct subchannel_id schid;
738
739 ccw_device_get_schid(cdev, &schid);
740 return chsc_pnso(schid, pnso_area, oc, resume_token, cnc);
741}
742EXPORT_SYMBOL_GPL(ccw_device_pnso);
743
744/**
745 * ccw_device_get_cssid() - obtain Channel Subsystem ID
746 * @cdev: device to obtain the CSSID for
747 * @cssid: The resulting Channel Subsystem ID
748 */
749int ccw_device_get_cssid(struct ccw_device *cdev, u8 *cssid)
750{
751 struct device *sch_dev = cdev->dev.parent;
752 struct channel_subsystem *css = to_css(sch_dev->parent);
753
754 if (css->id_valid)
755 *cssid = css->cssid;
756 return css->id_valid ? 0 : -ENODEV;
757}
758EXPORT_SYMBOL_GPL(ccw_device_get_cssid);
759
760/**
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
764 */
765int ccw_device_get_iid(struct ccw_device *cdev, u8 *iid)
766{
767 struct device *sch_dev = cdev->dev.parent;
768 struct channel_subsystem *css = to_css(sch_dev->parent);
769
770 if (css->id_valid)
771 *iid = css->iid;
772 return css->id_valid ? 0 : -ENODEV;
773}
774EXPORT_SYMBOL_GPL(ccw_device_get_iid);
775
776/**
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
781 */
782int ccw_device_get_chpid(struct ccw_device *cdev, int chp_idx, u8 *chpid)
783{
784 struct subchannel *sch = to_subchannel(cdev->dev.parent);
785 int mask;
786
787 if ((chp_idx < 0) || (chp_idx > 7))
788 return -EINVAL;
789 mask = 0x80 >> chp_idx;
790 if (!(sch->schib.pmcw.pim & mask))
791 return -ENODEV;
792
793 *chpid = sch->schib.pmcw.chpid[chp_idx];
794 return 0;
795}
796EXPORT_SYMBOL_GPL(ccw_device_get_chpid);
797
798/**
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
803 */
804int ccw_device_get_chid(struct ccw_device *cdev, int chp_idx, u16 *chid)
805{
806 struct chp_id cssid_chpid;
807 struct channel_path *chp;
808 int rc;
809
810 chp_id_init(&cssid_chpid);
811 rc = ccw_device_get_chpid(cdev, chp_idx, &cssid_chpid.id);
812 if (rc)
813 return rc;
814 chp = chpid_to_chp(cssid_chpid);
815 if (!chp)
816 return -ENODEV;
817
818 mutex_lock(&chp->lock);
819 if (chp->desc_fmt1.flags & 0x10)
820 *chid = chp->desc_fmt1.chid;
821 else
822 rc = -ENODEV;
823 mutex_unlock(&chp->lock);
824
825 return rc;
826}
827EXPORT_SYMBOL_GPL(ccw_device_get_chid);
828
829/*
830 * Allocate zeroed dma coherent 31 bit addressable memory using
831 * the subchannels dma pool. Maximal size of allocation supported
832 * is PAGE_SIZE.
833 */
834void *ccw_device_dma_zalloc(struct ccw_device *cdev, size_t size,
835 dma32_t *dma_handle)
836{
837 void *addr;
838
839 if (!get_device(&cdev->dev))
840 return NULL;
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);
844 return addr;
845}
846EXPORT_SYMBOL(ccw_device_dma_zalloc);
847
848void ccw_device_dma_free(struct ccw_device *cdev, void *cpu_addr, size_t size)
849{
850 if (!cpu_addr)
851 return;
852 cio_gp_dma_free(cdev->private->dma_pool, cpu_addr, size);
853 put_device(&cdev->dev);
854}
855EXPORT_SYMBOL(ccw_device_dma_free);
856
857EXPORT_SYMBOL(ccw_device_set_options_mask);
858EXPORT_SYMBOL(ccw_device_set_options);
859EXPORT_SYMBOL(ccw_device_clear_options);
860EXPORT_SYMBOL(ccw_device_clear);
861EXPORT_SYMBOL(ccw_device_halt);
862EXPORT_SYMBOL(ccw_device_resume);
863EXPORT_SYMBOL(ccw_device_start_timeout);
864EXPORT_SYMBOL(ccw_device_start);
865EXPORT_SYMBOL(ccw_device_start_timeout_key);
866EXPORT_SYMBOL(ccw_device_start_key);
867EXPORT_SYMBOL(ccw_device_get_ciw);
868EXPORT_SYMBOL(ccw_device_get_path_mask);
869EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
870EXPORT_SYMBOL_GPL(ccw_device_get_util_str);