1 /*
2  *  drivers/s390/cio/chp.c
3  *
4  *    Copyright IBM Corp. 1999,2010
5  *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
6  *		 Arnd Bergmann (arndb@de.ibm.com)
7  *		 Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
8  */
9 
10 #include <linux/bug.h>
11 #include <linux/workqueue.h>
12 #include <linux/spinlock.h>
13 #include <linux/export.h>
14 #include <linux/sched.h>
15 #include <linux/init.h>
16 #include <linux/jiffies.h>
17 #include <linux/wait.h>
18 #include <linux/mutex.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <asm/chpid.h>
22 #include <asm/sclp.h>
23 #include <asm/crw.h>
24 
25 #include "cio.h"
26 #include "css.h"
27 #include "ioasm.h"
28 #include "cio_debug.h"
29 #include "chp.h"
30 
31 #define to_channelpath(device) container_of(device, struct channel_path, dev)
32 #define CHP_INFO_UPDATE_INTERVAL	1*HZ
33 
34 enum cfg_task_t {
35 	cfg_none,
36 	cfg_configure,
37 	cfg_deconfigure
38 };
39 
40 /* Map for pending configure tasks. */
41 static enum cfg_task_t chp_cfg_task[__MAX_CSSID + 1][__MAX_CHPID + 1];
42 static DEFINE_MUTEX(cfg_lock);
43 static int cfg_busy;
44 
45 /* Map for channel-path status. */
46 static struct sclp_chp_info chp_info;
47 static DEFINE_MUTEX(info_lock);
48 
49 /* Time after which channel-path status may be outdated. */
50 static unsigned long chp_info_expires;
51 
52 /* Workqueue to perform pending configure tasks. */
53 static struct workqueue_struct *chp_wq;
54 static struct work_struct cfg_work;
55 
56 /* Wait queue for configure completion events. */
57 static wait_queue_head_t cfg_wait_queue;
58 
59 /* Set vary state for given chpid. */
set_chp_logically_online(struct chp_id chpid,int onoff)60 static void set_chp_logically_online(struct chp_id chpid, int onoff)
61 {
62 	chpid_to_chp(chpid)->state = onoff;
63 }
64 
65 /* On success return 0 if channel-path is varied offline, 1 if it is varied
66  * online. Return -ENODEV if channel-path is not registered. */
chp_get_status(struct chp_id chpid)67 int chp_get_status(struct chp_id chpid)
68 {
69 	return (chpid_to_chp(chpid) ? chpid_to_chp(chpid)->state : -ENODEV);
70 }
71 
72 /**
73  * chp_get_sch_opm - return opm for subchannel
74  * @sch: subchannel
75  *
76  * Calculate and return the operational path mask (opm) based on the chpids
77  * used by the subchannel and the status of the associated channel-paths.
78  */
chp_get_sch_opm(struct subchannel * sch)79 u8 chp_get_sch_opm(struct subchannel *sch)
80 {
81 	struct chp_id chpid;
82 	int opm;
83 	int i;
84 
85 	opm = 0;
86 	chp_id_init(&chpid);
87 	for (i = 0; i < 8; i++) {
88 		opm <<= 1;
89 		chpid.id = sch->schib.pmcw.chpid[i];
90 		if (chp_get_status(chpid) != 0)
91 			opm |= 1;
92 	}
93 	return opm;
94 }
95 EXPORT_SYMBOL_GPL(chp_get_sch_opm);
96 
97 /**
98  * chp_is_registered - check if a channel-path is registered
99  * @chpid: channel-path ID
100  *
101  * Return non-zero if a channel-path with the given chpid is registered,
102  * zero otherwise.
103  */
chp_is_registered(struct chp_id chpid)104 int chp_is_registered(struct chp_id chpid)
105 {
106 	return chpid_to_chp(chpid) != NULL;
107 }
108 
109 /*
110  * Function: s390_vary_chpid
111  * Varies the specified chpid online or offline
112  */
s390_vary_chpid(struct chp_id chpid,int on)113 static int s390_vary_chpid(struct chp_id chpid, int on)
114 {
115 	char dbf_text[15];
116 	int status;
117 
118 	sprintf(dbf_text, on?"varyon%x.%02x":"varyoff%x.%02x", chpid.cssid,
119 		chpid.id);
120 	CIO_TRACE_EVENT(2, dbf_text);
121 
122 	status = chp_get_status(chpid);
123 	if (!on && !status)
124 		return 0;
125 
126 	set_chp_logically_online(chpid, on);
127 	chsc_chp_vary(chpid, on);
128 	return 0;
129 }
130 
131 /*
132  * Channel measurement related functions
133  */
chp_measurement_chars_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)134 static ssize_t chp_measurement_chars_read(struct file *filp,
135 					  struct kobject *kobj,
136 					  struct bin_attribute *bin_attr,
137 					  char *buf, loff_t off, size_t count)
138 {
139 	struct channel_path *chp;
140 	struct device *device;
141 
142 	device = container_of(kobj, struct device, kobj);
143 	chp = to_channelpath(device);
144 	if (!chp->cmg_chars)
145 		return 0;
146 
147 	return memory_read_from_buffer(buf, count, &off,
148 				chp->cmg_chars, sizeof(struct cmg_chars));
149 }
150 
151 static struct bin_attribute chp_measurement_chars_attr = {
152 	.attr = {
153 		.name = "measurement_chars",
154 		.mode = S_IRUSR,
155 	},
156 	.size = sizeof(struct cmg_chars),
157 	.read = chp_measurement_chars_read,
158 };
159 
chp_measurement_copy_block(struct cmg_entry * buf,struct channel_subsystem * css,struct chp_id chpid)160 static void chp_measurement_copy_block(struct cmg_entry *buf,
161 				       struct channel_subsystem *css,
162 				       struct chp_id chpid)
163 {
164 	void *area;
165 	struct cmg_entry *entry, reference_buf;
166 	int idx;
167 
168 	if (chpid.id < 128) {
169 		area = css->cub_addr1;
170 		idx = chpid.id;
171 	} else {
172 		area = css->cub_addr2;
173 		idx = chpid.id - 128;
174 	}
175 	entry = area + (idx * sizeof(struct cmg_entry));
176 	do {
177 		memcpy(buf, entry, sizeof(*entry));
178 		memcpy(&reference_buf, entry, sizeof(*entry));
179 	} while (reference_buf.values[0] != buf->values[0]);
180 }
181 
chp_measurement_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)182 static ssize_t chp_measurement_read(struct file *filp, struct kobject *kobj,
183 				    struct bin_attribute *bin_attr,
184 				    char *buf, loff_t off, size_t count)
185 {
186 	struct channel_path *chp;
187 	struct channel_subsystem *css;
188 	struct device *device;
189 	unsigned int size;
190 
191 	device = container_of(kobj, struct device, kobj);
192 	chp = to_channelpath(device);
193 	css = to_css(chp->dev.parent);
194 
195 	size = sizeof(struct cmg_entry);
196 
197 	/* Only allow single reads. */
198 	if (off || count < size)
199 		return 0;
200 	chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->chpid);
201 	count = size;
202 	return count;
203 }
204 
205 static struct bin_attribute chp_measurement_attr = {
206 	.attr = {
207 		.name = "measurement",
208 		.mode = S_IRUSR,
209 	},
210 	.size = sizeof(struct cmg_entry),
211 	.read = chp_measurement_read,
212 };
213 
chp_remove_cmg_attr(struct channel_path * chp)214 void chp_remove_cmg_attr(struct channel_path *chp)
215 {
216 	device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
217 	device_remove_bin_file(&chp->dev, &chp_measurement_attr);
218 }
219 
chp_add_cmg_attr(struct channel_path * chp)220 int chp_add_cmg_attr(struct channel_path *chp)
221 {
222 	int ret;
223 
224 	ret = device_create_bin_file(&chp->dev, &chp_measurement_chars_attr);
225 	if (ret)
226 		return ret;
227 	ret = device_create_bin_file(&chp->dev, &chp_measurement_attr);
228 	if (ret)
229 		device_remove_bin_file(&chp->dev, &chp_measurement_chars_attr);
230 	return ret;
231 }
232 
233 /*
234  * Files for the channel path entries.
235  */
chp_status_show(struct device * dev,struct device_attribute * attr,char * buf)236 static ssize_t chp_status_show(struct device *dev,
237 			       struct device_attribute *attr, char *buf)
238 {
239 	struct channel_path *chp = to_channelpath(dev);
240 	int status;
241 
242 	mutex_lock(&chp->lock);
243 	status = chp->state;
244 	mutex_unlock(&chp->lock);
245 
246 	return status ? sprintf(buf, "online\n") : sprintf(buf, "offline\n");
247 }
248 
chp_status_write(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)249 static ssize_t chp_status_write(struct device *dev,
250 				struct device_attribute *attr,
251 				const char *buf, size_t count)
252 {
253 	struct channel_path *cp = to_channelpath(dev);
254 	char cmd[10];
255 	int num_args;
256 	int error;
257 
258 	num_args = sscanf(buf, "%5s", cmd);
259 	if (!num_args)
260 		return count;
261 
262 	if (!strnicmp(cmd, "on", 2) || !strcmp(cmd, "1")) {
263 		mutex_lock(&cp->lock);
264 		error = s390_vary_chpid(cp->chpid, 1);
265 		mutex_unlock(&cp->lock);
266 	} else if (!strnicmp(cmd, "off", 3) || !strcmp(cmd, "0")) {
267 		mutex_lock(&cp->lock);
268 		error = s390_vary_chpid(cp->chpid, 0);
269 		mutex_unlock(&cp->lock);
270 	} else
271 		error = -EINVAL;
272 
273 	return error < 0 ? error : count;
274 }
275 
276 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
277 
chp_configure_show(struct device * dev,struct device_attribute * attr,char * buf)278 static ssize_t chp_configure_show(struct device *dev,
279 				  struct device_attribute *attr, char *buf)
280 {
281 	struct channel_path *cp;
282 	int status;
283 
284 	cp = to_channelpath(dev);
285 	status = chp_info_get_status(cp->chpid);
286 	if (status < 0)
287 		return status;
288 
289 	return snprintf(buf, PAGE_SIZE, "%d\n", status);
290 }
291 
292 static int cfg_wait_idle(void);
293 
chp_configure_write(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)294 static ssize_t chp_configure_write(struct device *dev,
295 				   struct device_attribute *attr,
296 				   const char *buf, size_t count)
297 {
298 	struct channel_path *cp;
299 	int val;
300 	char delim;
301 
302 	if (sscanf(buf, "%d %c", &val, &delim) != 1)
303 		return -EINVAL;
304 	if (val != 0 && val != 1)
305 		return -EINVAL;
306 	cp = to_channelpath(dev);
307 	chp_cfg_schedule(cp->chpid, val);
308 	cfg_wait_idle();
309 
310 	return count;
311 }
312 
313 static DEVICE_ATTR(configure, 0644, chp_configure_show, chp_configure_write);
314 
chp_type_show(struct device * dev,struct device_attribute * attr,char * buf)315 static ssize_t chp_type_show(struct device *dev, struct device_attribute *attr,
316 			     char *buf)
317 {
318 	struct channel_path *chp = to_channelpath(dev);
319 	u8 type;
320 
321 	mutex_lock(&chp->lock);
322 	type = chp->desc.desc;
323 	mutex_unlock(&chp->lock);
324 	return sprintf(buf, "%x\n", type);
325 }
326 
327 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
328 
chp_cmg_show(struct device * dev,struct device_attribute * attr,char * buf)329 static ssize_t chp_cmg_show(struct device *dev, struct device_attribute *attr,
330 			    char *buf)
331 {
332 	struct channel_path *chp = to_channelpath(dev);
333 
334 	if (!chp)
335 		return 0;
336 	if (chp->cmg == -1) /* channel measurements not available */
337 		return sprintf(buf, "unknown\n");
338 	return sprintf(buf, "%x\n", chp->cmg);
339 }
340 
341 static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
342 
chp_shared_show(struct device * dev,struct device_attribute * attr,char * buf)343 static ssize_t chp_shared_show(struct device *dev,
344 			       struct device_attribute *attr, char *buf)
345 {
346 	struct channel_path *chp = to_channelpath(dev);
347 
348 	if (!chp)
349 		return 0;
350 	if (chp->shared == -1) /* channel measurements not available */
351 		return sprintf(buf, "unknown\n");
352 	return sprintf(buf, "%x\n", chp->shared);
353 }
354 
355 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
356 
357 static struct attribute *chp_attrs[] = {
358 	&dev_attr_status.attr,
359 	&dev_attr_configure.attr,
360 	&dev_attr_type.attr,
361 	&dev_attr_cmg.attr,
362 	&dev_attr_shared.attr,
363 	NULL,
364 };
365 
366 static struct attribute_group chp_attr_group = {
367 	.attrs = chp_attrs,
368 };
369 
chp_release(struct device * dev)370 static void chp_release(struct device *dev)
371 {
372 	struct channel_path *cp;
373 
374 	cp = to_channelpath(dev);
375 	kfree(cp);
376 }
377 
378 /**
379  * chp_new - register a new channel-path
380  * @chpid - channel-path ID
381  *
382  * Create and register data structure representing new channel-path. Return
383  * zero on success, non-zero otherwise.
384  */
chp_new(struct chp_id chpid)385 int chp_new(struct chp_id chpid)
386 {
387 	struct channel_path *chp;
388 	int ret;
389 
390 	if (chp_is_registered(chpid))
391 		return 0;
392 	chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
393 	if (!chp)
394 		return -ENOMEM;
395 
396 	/* fill in status, etc. */
397 	chp->chpid = chpid;
398 	chp->state = 1;
399 	chp->dev.parent = &channel_subsystems[chpid.cssid]->device;
400 	chp->dev.release = chp_release;
401 	mutex_init(&chp->lock);
402 
403 	/* Obtain channel path description and fill it in. */
404 	ret = chsc_determine_base_channel_path_desc(chpid, &chp->desc);
405 	if (ret)
406 		goto out_free;
407 	if ((chp->desc.flags & 0x80) == 0) {
408 		ret = -ENODEV;
409 		goto out_free;
410 	}
411 	/* Get channel-measurement characteristics. */
412 	if (css_chsc_characteristics.scmc && css_chsc_characteristics.secm) {
413 		ret = chsc_get_channel_measurement_chars(chp);
414 		if (ret)
415 			goto out_free;
416 	} else {
417 		chp->cmg = -1;
418 	}
419 	dev_set_name(&chp->dev, "chp%x.%02x", chpid.cssid, chpid.id);
420 
421 	/* make it known to the system */
422 	ret = device_register(&chp->dev);
423 	if (ret) {
424 		CIO_MSG_EVENT(0, "Could not register chp%x.%02x: %d\n",
425 			      chpid.cssid, chpid.id, ret);
426 		put_device(&chp->dev);
427 		goto out;
428 	}
429 	ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group);
430 	if (ret) {
431 		device_unregister(&chp->dev);
432 		goto out;
433 	}
434 	mutex_lock(&channel_subsystems[chpid.cssid]->mutex);
435 	if (channel_subsystems[chpid.cssid]->cm_enabled) {
436 		ret = chp_add_cmg_attr(chp);
437 		if (ret) {
438 			sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
439 			device_unregister(&chp->dev);
440 			mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
441 			goto out;
442 		}
443 	}
444 	channel_subsystems[chpid.cssid]->chps[chpid.id] = chp;
445 	mutex_unlock(&channel_subsystems[chpid.cssid]->mutex);
446 	goto out;
447 out_free:
448 	kfree(chp);
449 out:
450 	return ret;
451 }
452 
453 /**
454  * chp_get_chp_desc - return newly allocated channel-path description
455  * @chpid: channel-path ID
456  *
457  * On success return a newly allocated copy of the channel-path description
458  * data associated with the given channel-path ID. Return %NULL on error.
459  */
chp_get_chp_desc(struct chp_id chpid)460 void *chp_get_chp_desc(struct chp_id chpid)
461 {
462 	struct channel_path *chp;
463 	struct channel_path_desc *desc;
464 
465 	chp = chpid_to_chp(chpid);
466 	if (!chp)
467 		return NULL;
468 	desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
469 	if (!desc)
470 		return NULL;
471 
472 	mutex_lock(&chp->lock);
473 	memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
474 	mutex_unlock(&chp->lock);
475 	return desc;
476 }
477 
478 /**
479  * chp_process_crw - process channel-path status change
480  * @crw0: channel report-word to handler
481  * @crw1: second channel-report word (always NULL)
482  * @overflow: crw overflow indication
483  *
484  * Handle channel-report-words indicating that the status of a channel-path
485  * has changed.
486  */
chp_process_crw(struct crw * crw0,struct crw * crw1,int overflow)487 static void chp_process_crw(struct crw *crw0, struct crw *crw1,
488 			    int overflow)
489 {
490 	struct chp_id chpid;
491 
492 	if (overflow) {
493 		css_schedule_eval_all();
494 		return;
495 	}
496 	CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "
497 		      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
498 		      crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
499 		      crw0->erc, crw0->rsid);
500 	/*
501 	 * Check for solicited machine checks. These are
502 	 * created by reset channel path and need not be
503 	 * handled here.
504 	 */
505 	if (crw0->slct) {
506 		CIO_CRW_EVENT(2, "solicited machine check for "
507 			      "channel path %02X\n", crw0->rsid);
508 		return;
509 	}
510 	chp_id_init(&chpid);
511 	chpid.id = crw0->rsid;
512 	switch (crw0->erc) {
513 	case CRW_ERC_IPARM: /* Path has come. */
514 		if (!chp_is_registered(chpid))
515 			chp_new(chpid);
516 		chsc_chp_online(chpid);
517 		break;
518 	case CRW_ERC_PERRI: /* Path has gone. */
519 	case CRW_ERC_PERRN:
520 		chsc_chp_offline(chpid);
521 		break;
522 	default:
523 		CIO_CRW_EVENT(2, "Don't know how to handle erc=%x\n",
524 			      crw0->erc);
525 	}
526 }
527 
chp_ssd_get_mask(struct chsc_ssd_info * ssd,struct chp_link * link)528 int chp_ssd_get_mask(struct chsc_ssd_info *ssd, struct chp_link *link)
529 {
530 	int i;
531 	int mask;
532 
533 	for (i = 0; i < 8; i++) {
534 		mask = 0x80 >> i;
535 		if (!(ssd->path_mask & mask))
536 			continue;
537 		if (!chp_id_is_equal(&ssd->chpid[i], &link->chpid))
538 			continue;
539 		if ((ssd->fla_valid_mask & mask) &&
540 		    ((ssd->fla[i] & link->fla_mask) != link->fla))
541 			continue;
542 		return mask;
543 	}
544 	return 0;
545 }
546 EXPORT_SYMBOL_GPL(chp_ssd_get_mask);
547 
info_bit_num(struct chp_id id)548 static inline int info_bit_num(struct chp_id id)
549 {
550 	return id.id + id.cssid * (__MAX_CHPID + 1);
551 }
552 
553 /* Force chp_info refresh on next call to info_validate(). */
info_expire(void)554 static void info_expire(void)
555 {
556 	mutex_lock(&info_lock);
557 	chp_info_expires = jiffies - 1;
558 	mutex_unlock(&info_lock);
559 }
560 
561 /* Ensure that chp_info is up-to-date. */
info_update(void)562 static int info_update(void)
563 {
564 	int rc;
565 
566 	mutex_lock(&info_lock);
567 	rc = 0;
568 	if (time_after(jiffies, chp_info_expires)) {
569 		/* Data is too old, update. */
570 		rc = sclp_chp_read_info(&chp_info);
571 		chp_info_expires = jiffies + CHP_INFO_UPDATE_INTERVAL ;
572 	}
573 	mutex_unlock(&info_lock);
574 
575 	return rc;
576 }
577 
578 /**
579  * chp_info_get_status - retrieve configure status of a channel-path
580  * @chpid: channel-path ID
581  *
582  * On success, return 0 for standby, 1 for configured, 2 for reserved,
583  * 3 for not recognized. Return negative error code on error.
584  */
chp_info_get_status(struct chp_id chpid)585 int chp_info_get_status(struct chp_id chpid)
586 {
587 	int rc;
588 	int bit;
589 
590 	rc = info_update();
591 	if (rc)
592 		return rc;
593 
594 	bit = info_bit_num(chpid);
595 	mutex_lock(&info_lock);
596 	if (!chp_test_bit(chp_info.recognized, bit))
597 		rc = CHP_STATUS_NOT_RECOGNIZED;
598 	else if (chp_test_bit(chp_info.configured, bit))
599 		rc = CHP_STATUS_CONFIGURED;
600 	else if (chp_test_bit(chp_info.standby, bit))
601 		rc = CHP_STATUS_STANDBY;
602 	else
603 		rc = CHP_STATUS_RESERVED;
604 	mutex_unlock(&info_lock);
605 
606 	return rc;
607 }
608 
609 /* Return configure task for chpid. */
cfg_get_task(struct chp_id chpid)610 static enum cfg_task_t cfg_get_task(struct chp_id chpid)
611 {
612 	return chp_cfg_task[chpid.cssid][chpid.id];
613 }
614 
615 /* Set configure task for chpid. */
cfg_set_task(struct chp_id chpid,enum cfg_task_t cfg)616 static void cfg_set_task(struct chp_id chpid, enum cfg_task_t cfg)
617 {
618 	chp_cfg_task[chpid.cssid][chpid.id] = cfg;
619 }
620 
621 /* Perform one configure/deconfigure request. Reschedule work function until
622  * last request. */
cfg_func(struct work_struct * work)623 static void cfg_func(struct work_struct *work)
624 {
625 	struct chp_id chpid;
626 	enum cfg_task_t t;
627 	int rc;
628 
629 	mutex_lock(&cfg_lock);
630 	t = cfg_none;
631 	chp_id_for_each(&chpid) {
632 		t = cfg_get_task(chpid);
633 		if (t != cfg_none) {
634 			cfg_set_task(chpid, cfg_none);
635 			break;
636 		}
637 	}
638 	mutex_unlock(&cfg_lock);
639 
640 	switch (t) {
641 	case cfg_configure:
642 		rc = sclp_chp_configure(chpid);
643 		if (rc)
644 			CIO_MSG_EVENT(2, "chp: sclp_chp_configure(%x.%02x)="
645 				      "%d\n", chpid.cssid, chpid.id, rc);
646 		else {
647 			info_expire();
648 			chsc_chp_online(chpid);
649 		}
650 		break;
651 	case cfg_deconfigure:
652 		rc = sclp_chp_deconfigure(chpid);
653 		if (rc)
654 			CIO_MSG_EVENT(2, "chp: sclp_chp_deconfigure(%x.%02x)="
655 				      "%d\n", chpid.cssid, chpid.id, rc);
656 		else {
657 			info_expire();
658 			chsc_chp_offline(chpid);
659 		}
660 		break;
661 	case cfg_none:
662 		/* Get updated information after last change. */
663 		info_update();
664 		mutex_lock(&cfg_lock);
665 		cfg_busy = 0;
666 		mutex_unlock(&cfg_lock);
667 		wake_up_interruptible(&cfg_wait_queue);
668 		return;
669 	}
670 	queue_work(chp_wq, &cfg_work);
671 }
672 
673 /**
674  * chp_cfg_schedule - schedule chpid configuration request
675  * @chpid - channel-path ID
676  * @configure - Non-zero for configure, zero for deconfigure
677  *
678  * Schedule a channel-path configuration/deconfiguration request.
679  */
chp_cfg_schedule(struct chp_id chpid,int configure)680 void chp_cfg_schedule(struct chp_id chpid, int configure)
681 {
682 	CIO_MSG_EVENT(2, "chp_cfg_sched%x.%02x=%d\n", chpid.cssid, chpid.id,
683 		      configure);
684 	mutex_lock(&cfg_lock);
685 	cfg_set_task(chpid, configure ? cfg_configure : cfg_deconfigure);
686 	cfg_busy = 1;
687 	mutex_unlock(&cfg_lock);
688 	queue_work(chp_wq, &cfg_work);
689 }
690 
691 /**
692  * chp_cfg_cancel_deconfigure - cancel chpid deconfiguration request
693  * @chpid - channel-path ID
694  *
695  * Cancel an active channel-path deconfiguration request if it has not yet
696  * been performed.
697  */
chp_cfg_cancel_deconfigure(struct chp_id chpid)698 void chp_cfg_cancel_deconfigure(struct chp_id chpid)
699 {
700 	CIO_MSG_EVENT(2, "chp_cfg_cancel:%x.%02x\n", chpid.cssid, chpid.id);
701 	mutex_lock(&cfg_lock);
702 	if (cfg_get_task(chpid) == cfg_deconfigure)
703 		cfg_set_task(chpid, cfg_none);
704 	mutex_unlock(&cfg_lock);
705 }
706 
cfg_wait_idle(void)707 static int cfg_wait_idle(void)
708 {
709 	if (wait_event_interruptible(cfg_wait_queue, !cfg_busy))
710 		return -ERESTARTSYS;
711 	return 0;
712 }
713 
chp_init(void)714 static int __init chp_init(void)
715 {
716 	struct chp_id chpid;
717 	int ret;
718 
719 	ret = crw_register_handler(CRW_RSC_CPATH, chp_process_crw);
720 	if (ret)
721 		return ret;
722 	chp_wq = create_singlethread_workqueue("cio_chp");
723 	if (!chp_wq) {
724 		crw_unregister_handler(CRW_RSC_CPATH);
725 		return -ENOMEM;
726 	}
727 	INIT_WORK(&cfg_work, cfg_func);
728 	init_waitqueue_head(&cfg_wait_queue);
729 	if (info_update())
730 		return 0;
731 	/* Register available channel-paths. */
732 	chp_id_for_each(&chpid) {
733 		if (chp_info_get_status(chpid) != CHP_STATUS_NOT_RECOGNIZED)
734 			chp_new(chpid);
735 	}
736 
737 	return 0;
738 }
739 
740 subsys_initcall(chp_init);
741