2 * drivers/s390/cio/chp.c
4 * Copyright IBM Corp. 1999,2007
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>
10 #include <linux/bug.h>
11 #include <linux/workqueue.h>
12 #include <linux/spinlock.h>
13 #include <linux/init.h>
14 #include <linux/jiffies.h>
15 #include <linux/wait.h>
16 #include <linux/mutex.h>
17 #include <linux/errno.h>
18 #include <asm/chpid.h>
21 #include "../s390mach.h"
25 #include "cio_debug.h"
28 #define to_channelpath(device) container_of(device, struct channel_path, dev)
29 #define CHP_INFO_UPDATE_INTERVAL 1*HZ
37 /* Map for pending configure tasks. */
38 static enum cfg_task_t chp_cfg_task
[__MAX_CSSID
+ 1][__MAX_CHPID
+ 1];
39 static DEFINE_MUTEX(cfg_lock
);
42 /* Map for channel-path status. */
43 static struct sclp_chp_info chp_info
;
44 static DEFINE_MUTEX(info_lock
);
46 /* Time after which channel-path status may be outdated. */
47 static unsigned long chp_info_expires
;
49 /* Workqueue to perform pending configure tasks. */
50 static struct workqueue_struct
*chp_wq
;
51 static struct work_struct cfg_work
;
53 /* Wait queue for configure completion events. */
54 static wait_queue_head_t cfg_wait_queue
;
56 /* Return channel_path struct for given chpid. */
57 static inline struct channel_path
*chpid_to_chp(struct chp_id chpid
)
59 return channel_subsystems
[chpid
.cssid
]->chps
[chpid
.id
];
62 /* Set vary state for given chpid. */
63 static void set_chp_logically_online(struct chp_id chpid
, int onoff
)
65 chpid_to_chp(chpid
)->state
= onoff
;
68 /* On succes return 0 if channel-path is varied offline, 1 if it is varied
69 * online. Return -ENODEV if channel-path is not registered. */
70 int chp_get_status(struct chp_id chpid
)
72 return (chpid_to_chp(chpid
) ? chpid_to_chp(chpid
)->state
: -ENODEV
);
76 * chp_get_sch_opm - return opm for subchannel
79 * Calculate and return the operational path mask (opm) based on the chpids
80 * used by the subchannel and the status of the associated channel-paths.
82 u8
chp_get_sch_opm(struct subchannel
*sch
)
90 for (i
= 0; i
< 8; i
++) {
92 chpid
.id
= sch
->schib
.pmcw
.chpid
[i
];
93 if (chp_get_status(chpid
) != 0)
98 EXPORT_SYMBOL_GPL(chp_get_sch_opm
);
101 * chp_is_registered - check if a channel-path is registered
102 * @chpid: channel-path ID
104 * Return non-zero if a channel-path with the given chpid is registered,
107 int chp_is_registered(struct chp_id chpid
)
109 return chpid_to_chp(chpid
) != NULL
;
113 * Function: s390_vary_chpid
114 * Varies the specified chpid online or offline
116 static int s390_vary_chpid(struct chp_id chpid
, int on
)
121 sprintf(dbf_text
, on
?"varyon%x.%02x":"varyoff%x.%02x", chpid
.cssid
,
123 CIO_TRACE_EVENT(2, dbf_text
);
125 status
= chp_get_status(chpid
);
126 if (!on
&& !status
) {
127 printk(KERN_ERR
"cio: chpid %x.%02x is already offline\n",
128 chpid
.cssid
, chpid
.id
);
132 set_chp_logically_online(chpid
, on
);
133 chsc_chp_vary(chpid
, on
);
138 * Channel measurement related functions
140 static ssize_t
chp_measurement_chars_read(struct kobject
*kobj
,
141 struct bin_attribute
*bin_attr
,
142 char *buf
, loff_t off
, size_t count
)
144 struct channel_path
*chp
;
145 struct device
*device
;
148 device
= container_of(kobj
, struct device
, kobj
);
149 chp
= to_channelpath(device
);
153 size
= sizeof(struct cmg_chars
);
157 if (off
+ count
> size
)
159 memcpy(buf
, chp
->cmg_chars
+ off
, count
);
163 static struct bin_attribute chp_measurement_chars_attr
= {
165 .name
= "measurement_chars",
168 .size
= sizeof(struct cmg_chars
),
169 .read
= chp_measurement_chars_read
,
172 static void chp_measurement_copy_block(struct cmg_entry
*buf
,
173 struct channel_subsystem
*css
,
177 struct cmg_entry
*entry
, reference_buf
;
180 if (chpid
.id
< 128) {
181 area
= css
->cub_addr1
;
184 area
= css
->cub_addr2
;
185 idx
= chpid
.id
- 128;
187 entry
= area
+ (idx
* sizeof(struct cmg_entry
));
189 memcpy(buf
, entry
, sizeof(*entry
));
190 memcpy(&reference_buf
, entry
, sizeof(*entry
));
191 } while (reference_buf
.values
[0] != buf
->values
[0]);
194 static ssize_t
chp_measurement_read(struct kobject
*kobj
,
195 struct bin_attribute
*bin_attr
,
196 char *buf
, loff_t off
, size_t count
)
198 struct channel_path
*chp
;
199 struct channel_subsystem
*css
;
200 struct device
*device
;
203 device
= container_of(kobj
, struct device
, kobj
);
204 chp
= to_channelpath(device
);
205 css
= to_css(chp
->dev
.parent
);
207 size
= sizeof(struct cmg_entry
);
209 /* Only allow single reads. */
210 if (off
|| count
< size
)
212 chp_measurement_copy_block((struct cmg_entry
*)buf
, css
, chp
->chpid
);
217 static struct bin_attribute chp_measurement_attr
= {
219 .name
= "measurement",
222 .size
= sizeof(struct cmg_entry
),
223 .read
= chp_measurement_read
,
226 void chp_remove_cmg_attr(struct channel_path
*chp
)
228 device_remove_bin_file(&chp
->dev
, &chp_measurement_chars_attr
);
229 device_remove_bin_file(&chp
->dev
, &chp_measurement_attr
);
232 int chp_add_cmg_attr(struct channel_path
*chp
)
236 ret
= device_create_bin_file(&chp
->dev
, &chp_measurement_chars_attr
);
239 ret
= device_create_bin_file(&chp
->dev
, &chp_measurement_attr
);
241 device_remove_bin_file(&chp
->dev
, &chp_measurement_chars_attr
);
246 * Files for the channel path entries.
248 static ssize_t
chp_status_show(struct device
*dev
,
249 struct device_attribute
*attr
, char *buf
)
251 struct channel_path
*chp
= to_channelpath(dev
);
255 return (chp_get_status(chp
->chpid
) ? sprintf(buf
, "online\n") :
256 sprintf(buf
, "offline\n"));
259 static ssize_t
chp_status_write(struct device
*dev
,
260 struct device_attribute
*attr
,
261 const char *buf
, size_t count
)
263 struct channel_path
*cp
= to_channelpath(dev
);
268 num_args
= sscanf(buf
, "%5s", cmd
);
272 if (!strnicmp(cmd
, "on", 2) || !strcmp(cmd
, "1"))
273 error
= s390_vary_chpid(cp
->chpid
, 1);
274 else if (!strnicmp(cmd
, "off", 3) || !strcmp(cmd
, "0"))
275 error
= s390_vary_chpid(cp
->chpid
, 0);
279 return error
< 0 ? error
: count
;
283 static DEVICE_ATTR(status
, 0644, chp_status_show
, chp_status_write
);
285 static ssize_t
chp_configure_show(struct device
*dev
,
286 struct device_attribute
*attr
, char *buf
)
288 struct channel_path
*cp
;
291 cp
= to_channelpath(dev
);
292 status
= chp_info_get_status(cp
->chpid
);
296 return snprintf(buf
, PAGE_SIZE
, "%d\n", status
);
299 static int cfg_wait_idle(void);
301 static ssize_t
chp_configure_write(struct device
*dev
,
302 struct device_attribute
*attr
,
303 const char *buf
, size_t count
)
305 struct channel_path
*cp
;
309 if (sscanf(buf
, "%d %c", &val
, &delim
) != 1)
311 if (val
!= 0 && val
!= 1)
313 cp
= to_channelpath(dev
);
314 chp_cfg_schedule(cp
->chpid
, val
);
320 static DEVICE_ATTR(configure
, 0644, chp_configure_show
, chp_configure_write
);
322 static ssize_t
chp_type_show(struct device
*dev
, struct device_attribute
*attr
,
325 struct channel_path
*chp
= to_channelpath(dev
);
329 return sprintf(buf
, "%x\n", chp
->desc
.desc
);
332 static DEVICE_ATTR(type
, 0444, chp_type_show
, NULL
);
334 static ssize_t
chp_cmg_show(struct device
*dev
, struct device_attribute
*attr
,
337 struct channel_path
*chp
= to_channelpath(dev
);
341 if (chp
->cmg
== -1) /* channel measurements not available */
342 return sprintf(buf
, "unknown\n");
343 return sprintf(buf
, "%x\n", chp
->cmg
);
346 static DEVICE_ATTR(cmg
, 0444, chp_cmg_show
, NULL
);
348 static ssize_t
chp_shared_show(struct device
*dev
,
349 struct device_attribute
*attr
, char *buf
)
351 struct channel_path
*chp
= to_channelpath(dev
);
355 if (chp
->shared
== -1) /* channel measurements not available */
356 return sprintf(buf
, "unknown\n");
357 return sprintf(buf
, "%x\n", chp
->shared
);
360 static DEVICE_ATTR(shared
, 0444, chp_shared_show
, NULL
);
362 static struct attribute
*chp_attrs
[] = {
363 &dev_attr_status
.attr
,
364 &dev_attr_configure
.attr
,
367 &dev_attr_shared
.attr
,
371 static struct attribute_group chp_attr_group
= {
375 static void chp_release(struct device
*dev
)
377 struct channel_path
*cp
;
379 cp
= to_channelpath(dev
);
384 * chp_new - register a new channel-path
385 * @chpid - channel-path ID
387 * Create and register data structure representing new channel-path. Return
388 * zero on success, non-zero otherwise.
390 int chp_new(struct chp_id chpid
)
392 struct channel_path
*chp
;
395 if (chp_is_registered(chpid
))
397 chp
= kzalloc(sizeof(struct channel_path
), GFP_KERNEL
);
401 /* fill in status, etc. */
404 chp
->dev
.parent
= &channel_subsystems
[chpid
.cssid
]->device
;
405 chp
->dev
.release
= chp_release
;
406 snprintf(chp
->dev
.bus_id
, BUS_ID_SIZE
, "chp%x.%02x", chpid
.cssid
,
409 /* Obtain channel path description and fill it in. */
410 ret
= chsc_determine_channel_path_description(chpid
, &chp
->desc
);
413 if ((chp
->desc
.flags
& 0x80) == 0) {
417 /* Get channel-measurement characteristics. */
418 if (css_chsc_characteristics
.scmc
&& css_chsc_characteristics
.secm
) {
419 ret
= chsc_get_channel_measurement_chars(chp
);
426 /* make it known to the system */
427 ret
= device_register(&chp
->dev
);
429 CIO_MSG_EVENT(0, "Could not register chp%x.%02x: %d\n",
430 chpid
.cssid
, chpid
.id
, ret
);
433 ret
= sysfs_create_group(&chp
->dev
.kobj
, &chp_attr_group
);
435 device_unregister(&chp
->dev
);
438 mutex_lock(&channel_subsystems
[chpid
.cssid
]->mutex
);
439 if (channel_subsystems
[chpid
.cssid
]->cm_enabled
) {
440 ret
= chp_add_cmg_attr(chp
);
442 sysfs_remove_group(&chp
->dev
.kobj
, &chp_attr_group
);
443 device_unregister(&chp
->dev
);
444 mutex_unlock(&channel_subsystems
[chpid
.cssid
]->mutex
);
448 channel_subsystems
[chpid
.cssid
]->chps
[chpid
.id
] = chp
;
449 mutex_unlock(&channel_subsystems
[chpid
.cssid
]->mutex
);
457 * chp_get_chp_desc - return newly allocated channel-path description
458 * @chpid: channel-path ID
460 * On success return a newly allocated copy of the channel-path description
461 * data associated with the given channel-path ID. Return %NULL on error.
463 void *chp_get_chp_desc(struct chp_id chpid
)
465 struct channel_path
*chp
;
466 struct channel_path_desc
*desc
;
468 chp
= chpid_to_chp(chpid
);
471 desc
= kmalloc(sizeof(struct channel_path_desc
), GFP_KERNEL
);
474 memcpy(desc
, &chp
->desc
, sizeof(struct channel_path_desc
));
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
484 * Handle channel-report-words indicating that the status of a channel-path
487 static void chp_process_crw(struct crw
*crw0
, struct crw
*crw1
,
493 css_schedule_eval_all();
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
);
501 * Check for solicited machine checks. These are
502 * created by reset channel path and need not be
506 CIO_CRW_EVENT(2, "solicited machine check for "
507 "channel path %02X\n", crw0
->rsid
);
511 chpid
.id
= crw0
->rsid
;
513 case CRW_ERC_IPARM
: /* Path has come. */
514 if (!chp_is_registered(chpid
))
516 chsc_chp_online(chpid
);
518 case CRW_ERC_PERRI
: /* Path has gone. */
520 chsc_chp_offline(chpid
);
523 CIO_CRW_EVENT(2, "Don't know how to handle erc=%x\n",
528 int chp_ssd_get_mask(struct chsc_ssd_info
*ssd
, struct chp_link
*link
)
533 for (i
= 0; i
< 8; i
++) {
535 if (!(ssd
->path_mask
& mask
))
537 if (!chp_id_is_equal(&ssd
->chpid
[i
], &link
->chpid
))
539 if ((ssd
->fla_valid_mask
& mask
) &&
540 ((ssd
->fla
[i
] & link
->fla_mask
) != link
->fla
))
546 EXPORT_SYMBOL_GPL(chp_ssd_get_mask
);
548 static inline int info_bit_num(struct chp_id id
)
550 return id
.id
+ id
.cssid
* (__MAX_CHPID
+ 1);
553 /* Force chp_info refresh on next call to info_validate(). */
554 static void info_expire(void)
556 mutex_lock(&info_lock
);
557 chp_info_expires
= jiffies
- 1;
558 mutex_unlock(&info_lock
);
561 /* Ensure that chp_info is up-to-date. */
562 static int info_update(void)
566 mutex_lock(&info_lock
);
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
;
573 mutex_unlock(&info_lock
);
579 * chp_info_get_status - retrieve configure status of a channel-path
580 * @chpid: channel-path ID
582 * On success, return 0 for standby, 1 for configured, 2 for reserved,
583 * 3 for not recognized. Return negative error code on error.
585 int chp_info_get_status(struct chp_id chpid
)
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
;
603 rc
= CHP_STATUS_RESERVED
;
604 mutex_unlock(&info_lock
);
609 /* Return configure task for chpid. */
610 static enum cfg_task_t
cfg_get_task(struct chp_id chpid
)
612 return chp_cfg_task
[chpid
.cssid
][chpid
.id
];
615 /* Set configure task for chpid. */
616 static void cfg_set_task(struct chp_id chpid
, enum cfg_task_t cfg
)
618 chp_cfg_task
[chpid
.cssid
][chpid
.id
] = cfg
;
621 /* Perform one configure/deconfigure request. Reschedule work function until
623 static void cfg_func(struct work_struct
*work
)
629 mutex_lock(&cfg_lock
);
631 chp_id_for_each(&chpid
) {
632 t
= cfg_get_task(chpid
);
634 cfg_set_task(chpid
, cfg_none
);
638 mutex_unlock(&cfg_lock
);
642 rc
= sclp_chp_configure(chpid
);
644 CIO_MSG_EVENT(2, "chp: sclp_chp_configure(%x.%02x)="
645 "%d\n", chpid
.cssid
, chpid
.id
, rc
);
648 chsc_chp_online(chpid
);
651 case cfg_deconfigure
:
652 rc
= sclp_chp_deconfigure(chpid
);
654 CIO_MSG_EVENT(2, "chp: sclp_chp_deconfigure(%x.%02x)="
655 "%d\n", chpid
.cssid
, chpid
.id
, rc
);
658 chsc_chp_offline(chpid
);
662 /* Get updated information after last change. */
664 mutex_lock(&cfg_lock
);
666 mutex_unlock(&cfg_lock
);
667 wake_up_interruptible(&cfg_wait_queue
);
670 queue_work(chp_wq
, &cfg_work
);
674 * chp_cfg_schedule - schedule chpid configuration request
675 * @chpid - channel-path ID
676 * @configure - Non-zero for configure, zero for deconfigure
678 * Schedule a channel-path configuration/deconfiguration request.
680 void chp_cfg_schedule(struct chp_id chpid
, int configure
)
682 CIO_MSG_EVENT(2, "chp_cfg_sched%x.%02x=%d\n", chpid
.cssid
, chpid
.id
,
684 mutex_lock(&cfg_lock
);
685 cfg_set_task(chpid
, configure
? cfg_configure
: cfg_deconfigure
);
687 mutex_unlock(&cfg_lock
);
688 queue_work(chp_wq
, &cfg_work
);
692 * chp_cfg_cancel_deconfigure - cancel chpid deconfiguration request
693 * @chpid - channel-path ID
695 * Cancel an active channel-path deconfiguration request if it has not yet
698 void chp_cfg_cancel_deconfigure(struct chp_id chpid
)
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
);
707 static int cfg_wait_idle(void)
709 if (wait_event_interruptible(cfg_wait_queue
, !cfg_busy
))
714 static int __init
chp_init(void)
719 ret
= s390_register_crw_handler(CRW_RSC_CPATH
, chp_process_crw
);
722 chp_wq
= create_singlethread_workqueue("cio_chp");
724 s390_unregister_crw_handler(CRW_RSC_CPATH
);
727 INIT_WORK(&cfg_work
, cfg_func
);
728 init_waitqueue_head(&cfg_wait_queue
);
731 /* Register available channel-paths. */
732 chp_id_for_each(&chpid
) {
733 if (chp_info_get_status(chpid
) != CHP_STATUS_NOT_RECOGNIZED
)
740 subsys_initcall(chp_init
);