]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/s390/cio/chp.c
s390: add missing module.h/export.h includes
[mirror_ubuntu-artful-kernel.git] / drivers / s390 / cio / chp.c
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. */
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. */
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 */
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 */
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 */
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 */
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
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
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
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
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 */
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
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
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
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
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
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
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
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 */
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 */
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 */
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
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
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(). */
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. */
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 */
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. */
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. */
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. */
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 */
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 */
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
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
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);