1/*
2 *  drivers/s390/cio/device_ops.c
3 *
4 *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
5 *			 IBM Corporation
6 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
7 *               Cornelia Huck (cornelia.huck@de.ibm.com)
8 */
9#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/errno.h>
12#include <linux/slab.h>
13#include <linux/list.h>
14#include <linux/device.h>
15#include <linux/delay.h>
16
17#include <asm/ccwdev.h>
18#include <asm/idals.h>
19#include <asm/chpid.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
28int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
29{
30       /*
31	* The flag usage is mutal exclusive ...
32	*/
33	if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
34	    (flags & CCWDEV_REPORT_ALL))
35		return -EINVAL;
36	cdev->private->options.fast = (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
37	cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
38	cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
39	cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
40	return 0;
41}
42
43int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
44{
45       /*
46	* The flag usage is mutal exclusive ...
47	*/
48	if (((flags & CCWDEV_EARLY_NOTIFICATION) &&
49	    (flags & CCWDEV_REPORT_ALL)) ||
50	    ((flags & CCWDEV_EARLY_NOTIFICATION) &&
51	     cdev->private->options.repall) ||
52	    ((flags & CCWDEV_REPORT_ALL) &&
53	     cdev->private->options.fast))
54		return -EINVAL;
55	cdev->private->options.fast |= (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
56	cdev->private->options.repall |= (flags & CCWDEV_REPORT_ALL) != 0;
57	cdev->private->options.pgroup |= (flags & CCWDEV_DO_PATHGROUP) != 0;
58	cdev->private->options.force |= (flags & CCWDEV_ALLOW_FORCE) != 0;
59	return 0;
60}
61
62void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
63{
64	cdev->private->options.fast &= (flags & CCWDEV_EARLY_NOTIFICATION) == 0;
65	cdev->private->options.repall &= (flags & CCWDEV_REPORT_ALL) == 0;
66	cdev->private->options.pgroup &= (flags & CCWDEV_DO_PATHGROUP) == 0;
67	cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
68}
69
70int
71ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
72{
73	struct subchannel *sch;
74	int ret;
75
76	if (!cdev)
77		return -ENODEV;
78	if (cdev->private->state == DEV_STATE_NOT_OPER)
79		return -ENODEV;
80	if (cdev->private->state != DEV_STATE_ONLINE &&
81	    cdev->private->state != DEV_STATE_W4SENSE)
82		return -EINVAL;
83	sch = to_subchannel(cdev->dev.parent);
84	if (!sch)
85		return -ENODEV;
86	ret = cio_clear(sch);
87	if (ret == 0)
88		cdev->private->intparm = intparm;
89	return ret;
90}
91
92int
93ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
94		     unsigned long intparm, __u8 lpm, __u8 key,
95		     unsigned long flags)
96{
97	struct subchannel *sch;
98	int ret;
99
100	if (!cdev)
101		return -ENODEV;
102	sch = to_subchannel(cdev->dev.parent);
103	if (!sch)
104		return -ENODEV;
105	if (cdev->private->state == DEV_STATE_NOT_OPER)
106		return -ENODEV;
107	if (cdev->private->state == DEV_STATE_VERIFY ||
108	    cdev->private->state == DEV_STATE_CLEAR_VERIFY) {
109		/* Remember to fake irb when finished. */
110		if (!cdev->private->flags.fake_irb) {
111			cdev->private->flags.fake_irb = 1;
112			cdev->private->intparm = intparm;
113			return 0;
114		} else
115			/* There's already a fake I/O around. */
116			return -EBUSY;
117	}
118	if (cdev->private->state != DEV_STATE_ONLINE ||
119	    ((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
120	     !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
121	    cdev->private->flags.doverify)
122		return -EBUSY;
123	ret = cio_set_options (sch, flags);
124	if (ret)
125		return ret;
126	/* Adjust requested path mask to excluded varied off paths. */
127	if (lpm) {
128		lpm &= sch->opm;
129		if (lpm == 0)
130			return -EACCES;
131	}
132	ret = cio_start_key (sch, cpa, lpm, key);
133	if (ret == 0)
134		cdev->private->intparm = intparm;
135	return ret;
136}
137
138
139int
140ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
141			     unsigned long intparm, __u8 lpm, __u8 key,
142			     unsigned long flags, int expires)
143{
144	int ret;
145
146	if (!cdev)
147		return -ENODEV;
148	ccw_device_set_timeout(cdev, expires);
149	ret = ccw_device_start_key(cdev, cpa, intparm, lpm, key, flags);
150	if (ret != 0)
151		ccw_device_set_timeout(cdev, 0);
152	return ret;
153}
154
155int
156ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
157		 unsigned long intparm, __u8 lpm, unsigned long flags)
158{
159	return ccw_device_start_key(cdev, cpa, intparm, lpm,
160				    PAGE_DEFAULT_KEY, flags);
161}
162
163int
164ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
165			 unsigned long intparm, __u8 lpm, unsigned long flags,
166			 int expires)
167{
168	return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
169					    PAGE_DEFAULT_KEY, flags,
170					    expires);
171}
172
173
174int
175ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
176{
177	struct subchannel *sch;
178	int ret;
179
180	if (!cdev)
181		return -ENODEV;
182	if (cdev->private->state == DEV_STATE_NOT_OPER)
183		return -ENODEV;
184	if (cdev->private->state != DEV_STATE_ONLINE &&
185	    cdev->private->state != DEV_STATE_W4SENSE)
186		return -EINVAL;
187	sch = to_subchannel(cdev->dev.parent);
188	if (!sch)
189		return -ENODEV;
190	ret = cio_halt(sch);
191	if (ret == 0)
192		cdev->private->intparm = intparm;
193	return ret;
194}
195
196int
197ccw_device_resume(struct ccw_device *cdev)
198{
199	struct subchannel *sch;
200
201	if (!cdev)
202		return -ENODEV;
203	sch = to_subchannel(cdev->dev.parent);
204	if (!sch)
205		return -ENODEV;
206	if (cdev->private->state == DEV_STATE_NOT_OPER)
207		return -ENODEV;
208	if (cdev->private->state != DEV_STATE_ONLINE ||
209	    !(sch->schib.scsw.actl & SCSW_ACTL_SUSPENDED))
210		return -EINVAL;
211	return cio_resume(sch);
212}
213
214/*
215 * Pass interrupt to device driver.
216 */
217int
218ccw_device_call_handler(struct ccw_device *cdev)
219{
220	struct subchannel *sch;
221	unsigned int stctl;
222	int ending_status;
223
224	sch = to_subchannel(cdev->dev.parent);
225
226	/*
227	 * we allow for the device action handler if .
228	 *  - we received ending status
229	 *  - the action handler requested to see all interrupts
230	 *  - we received an intermediate status
231	 *  - fast notification was requested (primary status)
232	 *  - unsolicited interrupts
233	 */
234	stctl = cdev->private->irb.scsw.stctl;
235	ending_status = (stctl & SCSW_STCTL_SEC_STATUS) ||
236		(stctl == (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)) ||
237		(stctl == SCSW_STCTL_STATUS_PEND);
238	if (!ending_status &&
239	    !cdev->private->options.repall &&
240	    !(stctl & SCSW_STCTL_INTER_STATUS) &&
241	    !(cdev->private->options.fast &&
242	      (stctl & SCSW_STCTL_PRIM_STATUS)))
243		return 0;
244
245	/* Clear pending timers for device driver initiated I/O. */
246	if (ending_status)
247		ccw_device_set_timeout(cdev, 0);
248	/*
249	 * Now we are ready to call the device driver interrupt handler.
250	 */
251	if (cdev->handler)
252		cdev->handler(cdev, cdev->private->intparm,
253			      &cdev->private->irb);
254
255	/*
256	 * Clear the old and now useless interrupt response block.
257	 */
258	memset(&cdev->private->irb, 0, sizeof(struct irb));
259
260	return 1;
261}
262
263/*
264 * Search for CIW command in extended sense data.
265 */
266struct ciw *
267ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
268{
269	int ciw_cnt;
270
271	if (cdev->private->flags.esid == 0)
272		return NULL;
273	for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
274		if (cdev->private->senseid.ciw[ciw_cnt].ct == ct)
275			return cdev->private->senseid.ciw + ciw_cnt;
276	return NULL;
277}
278
279__u8
280ccw_device_get_path_mask(struct ccw_device *cdev)
281{
282	struct subchannel *sch;
283
284	sch = to_subchannel(cdev->dev.parent);
285	if (!sch)
286		return 0;
287	else
288		return sch->lpm;
289}
290
291static void
292ccw_device_wake_up(struct ccw_device *cdev, unsigned long ip, struct irb *irb)
293{
294	if (!ip)
295		/* unsolicited interrupt */
296		return;
297
298	/* Abuse intparm for error reporting. */
299	if (IS_ERR(irb))
300		cdev->private->intparm = -EIO;
301	else if (irb->scsw.cc == 1)
302		/* Retry for deferred condition code. */
303		cdev->private->intparm = -EAGAIN;
304	else if ((irb->scsw.dstat !=
305		  (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
306		 (irb->scsw.cstat != 0)) {
307		/*
308		 * We didn't get channel end / device end. Check if path
309		 * verification has been started; we can retry after it has
310		 * finished. We also retry unit checks except for command reject
311		 * or intervention required. Also check for long busy
312		 * conditions.
313		 */
314		 if (cdev->private->flags.doverify ||
315			 cdev->private->state == DEV_STATE_VERIFY)
316			 cdev->private->intparm = -EAGAIN;
317		else if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
318			 !(irb->ecw[0] &
319			   (SNS0_CMD_REJECT | SNS0_INTERVENTION_REQ)))
320			cdev->private->intparm = -EAGAIN;
321		else if ((irb->scsw.dstat & DEV_STAT_ATTENTION) &&
322			 (irb->scsw.dstat & DEV_STAT_DEV_END) &&
323			 (irb->scsw.dstat & DEV_STAT_UNIT_EXCEP))
324			cdev->private->intparm = -EAGAIN;
325		 else
326			 cdev->private->intparm = -EIO;
327
328	} else
329		cdev->private->intparm = 0;
330	wake_up(&cdev->private->wait_q);
331}
332
333static int
334__ccw_device_retry_loop(struct ccw_device *cdev, struct ccw1 *ccw, long magic, __u8 lpm)
335{
336	int ret;
337	struct subchannel *sch;
338
339	sch = to_subchannel(cdev->dev.parent);
340	do {
341		ccw_device_set_timeout(cdev, 60 * HZ);
342		ret = cio_start (sch, ccw, lpm);
343		if (ret != 0)
344			ccw_device_set_timeout(cdev, 0);
345		if (ret == -EBUSY) {
346			/* Try again later. */
347			spin_unlock_irq(sch->lock);
348			msleep(10);
349			spin_lock_irq(sch->lock);
350			continue;
351		}
352		if (ret != 0)
353			/* Non-retryable error. */
354			break;
355		/* Wait for end of request. */
356		cdev->private->intparm = magic;
357		spin_unlock_irq(sch->lock);
358		wait_event(cdev->private->wait_q,
359			   (cdev->private->intparm == -EIO) ||
360			   (cdev->private->intparm == -EAGAIN) ||
361			   (cdev->private->intparm == 0));
362		spin_lock_irq(sch->lock);
363		/* Check at least for channel end / device end */
364		if (cdev->private->intparm == -EIO) {
365			/* Non-retryable error. */
366			ret = -EIO;
367			break;
368		}
369		if (cdev->private->intparm == 0)
370			/* Success. */
371			break;
372		/* Try again later. */
373		spin_unlock_irq(sch->lock);
374		msleep(10);
375		spin_lock_irq(sch->lock);
376	} while (1);
377
378	return ret;
379}
380
381/**
382 * read_dev_chars() - read device characteristics
383 * @param cdev   target ccw device
384 * @param buffer pointer to buffer for rdc data
385 * @param length size of rdc data
386 * @returns 0 for success, negative error value on failure
387 *
388 * Context:
389 *   called for online device, lock not held
390 **/
391int
392read_dev_chars (struct ccw_device *cdev, void **buffer, int length)
393{
394	void (*handler)(struct ccw_device *, unsigned long, struct irb *);
395	struct subchannel *sch;
396	int ret;
397	struct ccw1 *rdc_ccw;
398
399	if (!cdev)
400		return -ENODEV;
401	if (!buffer || !length)
402		return -EINVAL;
403	sch = to_subchannel(cdev->dev.parent);
404
405	CIO_TRACE_EVENT (4, "rddevch");
406	CIO_TRACE_EVENT (4, sch->dev.bus_id);
407
408	rdc_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
409	if (!rdc_ccw)
410		return -ENOMEM;
411	rdc_ccw->cmd_code = CCW_CMD_RDC;
412	rdc_ccw->count = length;
413	rdc_ccw->flags = CCW_FLAG_SLI;
414	ret = set_normalized_cda (rdc_ccw, (*buffer));
415	if (ret != 0) {
416		kfree(rdc_ccw);
417		return ret;
418	}
419
420	spin_lock_irq(sch->lock);
421	/* Save interrupt handler. */
422	handler = cdev->handler;
423	/* Temporarily install own handler. */
424	cdev->handler = ccw_device_wake_up;
425	if (cdev->private->state != DEV_STATE_ONLINE)
426		ret = -ENODEV;
427	else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
428		  !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
429		 cdev->private->flags.doverify)
430		ret = -EBUSY;
431	else
432		/* 0x00D9C4C3 == ebcdic "RDC" */
433		ret = __ccw_device_retry_loop(cdev, rdc_ccw, 0x00D9C4C3, 0);
434
435	/* Restore interrupt handler. */
436	cdev->handler = handler;
437	spin_unlock_irq(sch->lock);
438
439	clear_normalized_cda (rdc_ccw);
440	kfree(rdc_ccw);
441
442	return ret;
443}
444
445/*
446 *  Read Configuration data using path mask
447 */
448int
449read_conf_data_lpm (struct ccw_device *cdev, void **buffer, int *length, __u8 lpm)
450{
451	void (*handler)(struct ccw_device *, unsigned long, struct irb *);
452	struct subchannel *sch;
453	struct ciw *ciw;
454	char *rcd_buf;
455	int ret;
456	struct ccw1 *rcd_ccw;
457
458	if (!cdev)
459		return -ENODEV;
460	if (!buffer || !length)
461		return -EINVAL;
462	sch = to_subchannel(cdev->dev.parent);
463
464	CIO_TRACE_EVENT (4, "rdconf");
465	CIO_TRACE_EVENT (4, sch->dev.bus_id);
466
467	/*
468	 * scan for RCD command in extended SenseID data
469	 */
470	ciw = ccw_device_get_ciw(cdev, CIW_TYPE_RCD);
471	if (!ciw || ciw->cmd == 0)
472		return -EOPNOTSUPP;
473
474	/* Adjust requested path mask to excluded varied off paths. */
475	if (lpm) {
476		lpm &= sch->opm;
477		if (lpm == 0)
478			return -EACCES;
479	}
480
481	rcd_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
482	if (!rcd_ccw)
483		return -ENOMEM;
484	rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA);
485 	if (!rcd_buf) {
486		kfree(rcd_ccw);
487		return -ENOMEM;
488	}
489	rcd_ccw->cmd_code = ciw->cmd;
490	rcd_ccw->cda = (__u32) __pa (rcd_buf);
491	rcd_ccw->count = ciw->count;
492	rcd_ccw->flags = CCW_FLAG_SLI;
493
494	spin_lock_irq(sch->lock);
495	/* Save interrupt handler. */
496	handler = cdev->handler;
497	/* Temporarily install own handler. */
498	cdev->handler = ccw_device_wake_up;
499	if (cdev->private->state != DEV_STATE_ONLINE)
500		ret = -ENODEV;
501	else if (((sch->schib.scsw.stctl & SCSW_STCTL_PRIM_STATUS) &&
502		  !(sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS)) ||
503		 cdev->private->flags.doverify)
504		ret = -EBUSY;
505	else
506		/* 0x00D9C3C4 == ebcdic "RCD" */
507		ret = __ccw_device_retry_loop(cdev, rcd_ccw, 0x00D9C3C4, lpm);
508
509	/* Restore interrupt handler. */
510	cdev->handler = handler;
511	spin_unlock_irq(sch->lock);
512
513 	/*
514 	 * on success we update the user input parms
515 	 */
516 	if (ret) {
517 		kfree (rcd_buf);
518 		*buffer = NULL;
519 		*length = 0;
520 	} else {
521		*length = ciw->count;
522		*buffer = rcd_buf;
523	}
524	kfree(rcd_ccw);
525
526	return ret;
527}
528
529/*
530 *  Read Configuration data
531 */
532int
533read_conf_data (struct ccw_device *cdev, void **buffer, int *length)
534{
535	return read_conf_data_lpm (cdev, buffer, length, 0);
536}
537
538/*
539 * Try to break the lock on a boxed device.
540 */
541int
542ccw_device_stlck(struct ccw_device *cdev)
543{
544	void *buf, *buf2;
545	unsigned long flags;
546	struct subchannel *sch;
547	int ret;
548
549	if (!cdev)
550		return -ENODEV;
551
552	if (cdev->drv && !cdev->private->options.force)
553		return -EINVAL;
554
555	sch = to_subchannel(cdev->dev.parent);
556
557	CIO_TRACE_EVENT(2, "stl lock");
558	CIO_TRACE_EVENT(2, cdev->dev.bus_id);
559
560	buf = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
561	if (!buf)
562		return -ENOMEM;
563	buf2 = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
564	if (!buf2) {
565		kfree(buf);
566		return -ENOMEM;
567	}
568	spin_lock_irqsave(sch->lock, flags);
569	ret = cio_enable_subchannel(sch, 3);
570	if (ret)
571		goto out_unlock;
572	/*
573	 * Setup ccw. We chain an unconditional reserve and a release so we
574	 * only break the lock.
575	 */
576	cdev->private->iccws[0].cmd_code = CCW_CMD_STLCK;
577	cdev->private->iccws[0].cda = (__u32) __pa(buf);
578	cdev->private->iccws[0].count = 32;
579	cdev->private->iccws[0].flags = CCW_FLAG_CC;
580	cdev->private->iccws[1].cmd_code = CCW_CMD_RELEASE;
581	cdev->private->iccws[1].cda = (__u32) __pa(buf2);
582	cdev->private->iccws[1].count = 32;
583	cdev->private->iccws[1].flags = 0;
584	ret = cio_start(sch, cdev->private->iccws, 0);
585	if (ret) {
586		cio_disable_subchannel(sch);
587		goto out_unlock;
588	}
589	cdev->private->irb.scsw.actl |= SCSW_ACTL_START_PEND;
590	spin_unlock_irqrestore(sch->lock, flags);
591	wait_event(cdev->private->wait_q, cdev->private->irb.scsw.actl == 0);
592	spin_lock_irqsave(sch->lock, flags);
593	cio_disable_subchannel(sch);
594	if ((cdev->private->irb.scsw.dstat !=
595	     (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
596	    (cdev->private->irb.scsw.cstat != 0))
597		ret = -EIO;
598	/* Clear irb. */
599	memset(&cdev->private->irb, 0, sizeof(struct irb));
600out_unlock:
601	kfree(buf);
602	kfree(buf2);
603	spin_unlock_irqrestore(sch->lock, flags);
604	return ret;
605}
606
607void *
608ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
609{
610	struct subchannel *sch;
611	struct chp_id chpid;
612
613	sch = to_subchannel(cdev->dev.parent);
614	chp_id_init(&chpid);
615	chpid.id = sch->schib.pmcw.chpid[chp_no];
616	return chp_get_chp_desc(chpid);
617}
618
619/**
620 * ccw_device_get_id - obtain a ccw device id
621 * @cdev: device to obtain the id for
622 * @dev_id: where to fill in the values
623 */
624void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
625{
626	*dev_id = cdev->private->dev_id;
627}
628EXPORT_SYMBOL(ccw_device_get_id);
629
630
631int
632_ccw_device_get_subchannel_number(struct ccw_device *cdev)
633{
634	return cdev->private->schid.sch_no;
635}
636
637int
638_ccw_device_get_device_number(struct ccw_device *cdev)
639{
640	return cdev->private->dev_id.devno;
641}
642
643
644MODULE_LICENSE("GPL");
645EXPORT_SYMBOL(ccw_device_set_options_mask);
646EXPORT_SYMBOL(ccw_device_set_options);
647EXPORT_SYMBOL(ccw_device_clear_options);
648EXPORT_SYMBOL(ccw_device_clear);
649EXPORT_SYMBOL(ccw_device_halt);
650EXPORT_SYMBOL(ccw_device_resume);
651EXPORT_SYMBOL(ccw_device_start_timeout);
652EXPORT_SYMBOL(ccw_device_start);
653EXPORT_SYMBOL(ccw_device_start_timeout_key);
654EXPORT_SYMBOL(ccw_device_start_key);
655EXPORT_SYMBOL(ccw_device_get_ciw);
656EXPORT_SYMBOL(ccw_device_get_path_mask);
657EXPORT_SYMBOL(read_conf_data);
658EXPORT_SYMBOL(read_dev_chars);
659EXPORT_SYMBOL(_ccw_device_get_subchannel_number);
660EXPORT_SYMBOL(_ccw_device_get_device_number);
661EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
662EXPORT_SYMBOL_GPL(read_conf_data_lpm);
663