2 * linux/drivers/s390/cio/cmf.c
4 * Linux on zSeries Channel Measurement Facility support
6 * Copyright 2000,2006 IBM Corporation
8 * Authors: Arnd Bergmann <arndb@de.ibm.com>
9 * Cornelia Huck <cornelia.huck@de.ibm.com>
11 * original idea from Natarajan Krishnaswami <nkrishna@us.ibm.com>
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2, or (at your option)
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <linux/bootmem.h>
29 #include <linux/device.h>
30 #include <linux/init.h>
31 #include <linux/list.h>
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/slab.h>
35 #include <linux/timex.h> /* get_clock() */
37 #include <asm/ccwdev.h>
40 #include <asm/div64.h>
49 * parameter to enable cmf during boot, possible uses are:
50 * "s390cmf" -- enable cmf and allocate 2 MB of ram so measuring can be
51 * used on any subchannel
52 * "s390cmf=<num>" -- enable cmf and allocate enough memory to measure
53 * <num> subchannel, where <num> is an integer
54 * between 1 and 65535, default is 1024
56 #define ARGSTRING "s390cmf"
58 /* indices for READCMB */
60 /* basic and exended format: */
63 cmb_device_connect_time,
64 cmb_function_pending_time,
65 cmb_device_disconnect_time,
66 cmb_control_unit_queuing_time,
67 cmb_device_active_only_time,
68 /* extended format only: */
70 cmb_initial_command_response_time,
74 * enum cmb_format - types of supported measurement block formats
76 * @CMF_BASIC: traditional channel measurement blocks supported
77 * by all machines that we run on
78 * @CMF_EXTENDED: improved format that was introduced with the z990
80 * @CMF_AUTODETECT: default: use extended format when running on a machine
81 * supporting extended format, otherwise fall back to
91 * format - actual format for all measurement blocks
93 * The format module parameter can be set to a value of 0 (zero)
94 * or 1, indicating basic or extended format as described for
97 static int format = CMF_AUTODETECT;
98 module_param(format, bool, 0444);
101 * struct cmb_operations - functions to use depending on cmb_format
103 * Most of these functions operate on a struct ccw_device. There is only
104 * one instance of struct cmb_operations because the format of the measurement
105 * data is guaranteed to be the same for every ccw_device.
107 * @alloc: allocate memory for a channel measurement block,
108 * either with the help of a special pool or with kmalloc
109 * @free: free memory allocated with @alloc
110 * @set: enable or disable measurement
111 * @read: read a measurement entry at an index
112 * @readall: read a measurement block in a common format
113 * @reset: clear the data in the associated measurement block and
114 * reset its time stamp
115 * @align: align an allocated block so that the hardware can use it
117 struct cmb_operations {
118 int (*alloc) (struct ccw_device *);
119 void (*free) (struct ccw_device *);
120 int (*set) (struct ccw_device *, u32);
121 u64 (*read) (struct ccw_device *, int);
122 int (*readall)(struct ccw_device *, struct cmbdata *);
123 void (*reset) (struct ccw_device *);
124 void *(*align) (void *);
126 struct attribute_group *attr_group;
128 static struct cmb_operations *cmbops;
131 void *hw_block; /* Pointer to block updated by hardware */
132 void *last_block; /* Last changed block copied from hardware block */
133 int size; /* Size of hw_block and last_block */
134 unsigned long long last_update; /* when last_block was updated */
138 * Our user interface is designed in terms of nanoseconds,
139 * while the hardware measures total times in its own
142 static inline u64 time_to_nsec(u32 value)
144 return ((u64)value) * 128000ull;
148 * Users are usually interested in average times,
149 * not accumulated time.
150 * This also helps us with atomicity problems
151 * when reading sinlge values.
153 static inline u64 time_to_avg_nsec(u32 value, u32 count)
157 /* no samples yet, avoid division by 0 */
161 /* value comes in units of 128 µsec */
162 ret = time_to_nsec(value);
169 * Activate or deactivate the channel monitor. When area is NULL,
170 * the monitor is deactivated. The channel monitor needs to
171 * be active in order to measure subchannels, which also need
174 static inline void cmf_activate(void *area, unsigned int onoff)
176 register void * __gpr2 asm("2");
177 register long __gpr1 asm("1");
180 __gpr1 = onoff ? 2 : 0;
181 /* activate channel measurement */
182 asm("schm" : : "d" (__gpr2), "d" (__gpr1) );
185 static int set_schib(struct ccw_device *cdev, u32 mme, int mbfc,
186 unsigned long address)
190 struct subchannel *sch;
193 sch = to_subchannel(cdev->dev.parent);
195 /* msch can silently fail, so do it again if necessary */
196 for (retry = 0; retry < 3; retry++) {
198 stsch(sch->schid, schib);
199 schib->pmcw.mme = mme;
200 schib->pmcw.mbfc = mbfc;
201 /* address can be either a block address or a block index */
203 schib->mba = address;
205 schib->pmcw.mbi = address;
207 /* try to submit it */
208 switch(ret = msch_err(sch->schid, schib)) {
212 case 2: /* in I/O or status pending */
215 case 3: /* subchannel is no longer valid */
218 default: /* msch caught an exception */
222 stsch(sch->schid, schib); /* restore the schib */
227 /* check if it worked */
228 if (schib->pmcw.mme == mme &&
229 schib->pmcw.mbfc == mbfc &&
230 (mbfc ? (schib->mba == address)
231 : (schib->pmcw.mbi == address)))
240 struct set_schib_struct {
243 unsigned long address;
244 wait_queue_head_t wait;
249 static void cmf_set_schib_release(struct kref *kref)
251 struct set_schib_struct *set_data;
253 set_data = container_of(kref, struct set_schib_struct, kref);
257 #define CMF_PENDING 1
259 static int set_schib_wait(struct ccw_device *cdev, u32 mme,
260 int mbfc, unsigned long address)
262 struct set_schib_struct *set_data;
265 spin_lock_irq(cdev->ccwlock);
266 if (!cdev->private->cmb) {
270 set_data = kzalloc(sizeof(struct set_schib_struct), GFP_ATOMIC);
275 init_waitqueue_head(&set_data->wait);
276 kref_init(&set_data->kref);
278 set_data->mbfc = mbfc;
279 set_data->address = address;
281 ret = set_schib(cdev, mme, mbfc, address);
285 if (cdev->private->state != DEV_STATE_ONLINE) {
286 /* if the device is not online, don't even try again */
291 cdev->private->state = DEV_STATE_CMFCHANGE;
292 set_data->ret = CMF_PENDING;
293 cdev->private->cmb_wait = set_data;
295 spin_unlock_irq(cdev->ccwlock);
296 if (wait_event_interruptible(set_data->wait,
297 set_data->ret != CMF_PENDING)) {
298 spin_lock_irq(cdev->ccwlock);
299 if (set_data->ret == CMF_PENDING) {
300 set_data->ret = -ERESTARTSYS;
301 if (cdev->private->state == DEV_STATE_CMFCHANGE)
302 cdev->private->state = DEV_STATE_ONLINE;
304 spin_unlock_irq(cdev->ccwlock);
306 spin_lock_irq(cdev->ccwlock);
307 cdev->private->cmb_wait = NULL;
310 kref_put(&set_data->kref, cmf_set_schib_release);
312 spin_unlock_irq(cdev->ccwlock);
316 void retry_set_schib(struct ccw_device *cdev)
318 struct set_schib_struct *set_data;
320 set_data = cdev->private->cmb_wait;
325 kref_get(&set_data->kref);
326 set_data->ret = set_schib(cdev, set_data->mme, set_data->mbfc,
328 wake_up(&set_data->wait);
329 kref_put(&set_data->kref, cmf_set_schib_release);
332 static int cmf_copy_block(struct ccw_device *cdev)
334 struct subchannel *sch;
337 struct cmb_data *cmb_data;
339 sch = to_subchannel(cdev->dev.parent);
341 if (stsch(sch->schid, &sch->schib))
344 if (sch->schib.scsw.fctl & SCSW_FCTL_START_FUNC) {
345 /* Don't copy if a start function is in progress. */
346 if ((!sch->schib.scsw.actl & SCSW_ACTL_SUSPENDED) &&
347 (sch->schib.scsw.actl &
348 (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) &&
349 (!sch->schib.scsw.stctl & SCSW_STCTL_SEC_STATUS))
352 cmb_data = cdev->private->cmb;
353 hw_block = cmbops->align(cmb_data->hw_block);
354 if (!memcmp(cmb_data->last_block, hw_block, cmb_data->size))
355 /* No need to copy. */
357 reference_buf = kzalloc(cmb_data->size, GFP_ATOMIC);
360 /* Ensure consistency of block copied from hardware. */
362 memcpy(cmb_data->last_block, hw_block, cmb_data->size);
363 memcpy(reference_buf, hw_block, cmb_data->size);
364 } while (memcmp(cmb_data->last_block, reference_buf, cmb_data->size));
365 cmb_data->last_update = get_clock();
366 kfree(reference_buf);
370 struct copy_block_struct {
371 wait_queue_head_t wait;
376 static void cmf_copy_block_release(struct kref *kref)
378 struct copy_block_struct *copy_block;
380 copy_block = container_of(kref, struct copy_block_struct, kref);
384 static int cmf_cmb_copy_wait(struct ccw_device *cdev)
386 struct copy_block_struct *copy_block;
390 spin_lock_irqsave(cdev->ccwlock, flags);
391 if (!cdev->private->cmb) {
395 copy_block = kzalloc(sizeof(struct copy_block_struct), GFP_ATOMIC);
400 init_waitqueue_head(©_block->wait);
401 kref_init(©_block->kref);
403 ret = cmf_copy_block(cdev);
407 if (cdev->private->state != DEV_STATE_ONLINE) {
412 cdev->private->state = DEV_STATE_CMFUPDATE;
413 copy_block->ret = CMF_PENDING;
414 cdev->private->cmb_wait = copy_block;
416 spin_unlock_irqrestore(cdev->ccwlock, flags);
417 if (wait_event_interruptible(copy_block->wait,
418 copy_block->ret != CMF_PENDING)) {
419 spin_lock_irqsave(cdev->ccwlock, flags);
420 if (copy_block->ret == CMF_PENDING) {
421 copy_block->ret = -ERESTARTSYS;
422 if (cdev->private->state == DEV_STATE_CMFUPDATE)
423 cdev->private->state = DEV_STATE_ONLINE;
425 spin_unlock_irqrestore(cdev->ccwlock, flags);
427 spin_lock_irqsave(cdev->ccwlock, flags);
428 cdev->private->cmb_wait = NULL;
429 ret = copy_block->ret;
431 kref_put(©_block->kref, cmf_copy_block_release);
433 spin_unlock_irqrestore(cdev->ccwlock, flags);
437 void cmf_retry_copy_block(struct ccw_device *cdev)
439 struct copy_block_struct *copy_block;
441 copy_block = cdev->private->cmb_wait;
446 kref_get(©_block->kref);
447 copy_block->ret = cmf_copy_block(cdev);
448 wake_up(©_block->wait);
449 kref_put(©_block->kref, cmf_copy_block_release);
452 static void cmf_generic_reset(struct ccw_device *cdev)
454 struct cmb_data *cmb_data;
456 spin_lock_irq(cdev->ccwlock);
457 cmb_data = cdev->private->cmb;
459 memset(cmb_data->last_block, 0, cmb_data->size);
461 * Need to reset hw block as well to make the hardware start
464 memset(cmbops->align(cmb_data->hw_block), 0, cmb_data->size);
465 cmb_data->last_update = 0;
467 cdev->private->cmb_start_time = get_clock();
468 spin_unlock_irq(cdev->ccwlock);
472 * struct cmb_area - container for global cmb data
474 * @mem: pointer to CMBs (only in basic measurement mode)
475 * @list: contains a linked list of all subchannels
476 * @num_channels: number of channels to be measured
477 * @lock: protect concurrent access to @mem and @list
481 struct list_head list;
486 static struct cmb_area cmb_area = {
487 .lock = __SPIN_LOCK_UNLOCKED(cmb_area.lock),
488 .list = LIST_HEAD_INIT(cmb_area.list),
489 .num_channels = 1024,
493 /* ****** old style CMB handling ********/
496 * Basic channel measurement blocks are allocated in one contiguous
497 * block of memory, which can not be moved as long as any channel
498 * is active. Therefore, a maximum number of subchannels needs to
499 * be defined somewhere. This is a module parameter, defaulting to
500 * a resonable value of 1024, or 32 kb of memory.
501 * Current kernels don't allow kmalloc with more than 128kb, so the
505 module_param_named(maxchannels, cmb_area.num_channels, uint, 0444);
508 * struct cmb - basic channel measurement block
509 * @ssch_rsch_count: number of ssch and rsch
510 * @sample_count: number of samples
511 * @device_connect_time: time of device connect
512 * @function_pending_time: time of function pending
513 * @device_disconnect_time: time of device disconnect
514 * @control_unit_queuing_time: time of control unit queuing
515 * @device_active_only_time: time of device active only
516 * @reserved: unused in basic measurement mode
518 * The measurement block as used by the hardware. The fields are described
519 * further in z/Architecture Principles of Operation, chapter 17.
521 * The cmb area made up from these blocks must be a contiguous array and may
522 * not be reallocated or freed.
523 * Only one cmb area can be present in the system.
528 u32 device_connect_time;
529 u32 function_pending_time;
530 u32 device_disconnect_time;
531 u32 control_unit_queuing_time;
532 u32 device_active_only_time;
537 * Insert a single device into the cmb_area list.
538 * Called with cmb_area.lock held from alloc_cmb.
540 static int alloc_cmb_single(struct ccw_device *cdev,
541 struct cmb_data *cmb_data)
544 struct ccw_device_private *node;
547 spin_lock_irq(cdev->ccwlock);
548 if (!list_empty(&cdev->private->cmb_list)) {
554 * Find first unused cmb in cmb_area.mem.
555 * This is a little tricky: cmb_area.list
556 * remains sorted by ->cmb->hw_data pointers.
559 list_for_each_entry(node, &cmb_area.list, cmb_list) {
560 struct cmb_data *data;
562 if ((struct cmb*)data->hw_block > cmb)
566 if (cmb - cmb_area.mem >= cmb_area.num_channels) {
572 list_add_tail(&cdev->private->cmb_list, &node->cmb_list);
573 cmb_data->hw_block = cmb;
574 cdev->private->cmb = cmb_data;
577 spin_unlock_irq(cdev->ccwlock);
581 static int alloc_cmb(struct ccw_device *cdev)
586 struct cmb_data *cmb_data;
588 /* Allocate private cmb_data. */
589 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
593 cmb_data->last_block = kzalloc(sizeof(struct cmb), GFP_KERNEL);
594 if (!cmb_data->last_block) {
598 cmb_data->size = sizeof(struct cmb);
599 spin_lock(&cmb_area.lock);
602 /* there is no user yet, so we need a new area */
603 size = sizeof(struct cmb) * cmb_area.num_channels;
604 WARN_ON(!list_empty(&cmb_area.list));
606 spin_unlock(&cmb_area.lock);
607 mem = (void*)__get_free_pages(GFP_KERNEL | GFP_DMA,
609 spin_lock(&cmb_area.lock);
612 /* ok, another thread was faster */
613 free_pages((unsigned long)mem, get_order(size));
616 printk(KERN_WARNING "cio: failed to allocate area "
617 "for measuring %d subchannels\n",
618 cmb_area.num_channels);
623 memset(mem, 0, size);
625 cmf_activate(cmb_area.mem, 1);
629 /* do the actual allocation */
630 ret = alloc_cmb_single(cdev, cmb_data);
632 spin_unlock(&cmb_area.lock);
634 kfree(cmb_data->last_block);
640 static void free_cmb(struct ccw_device *cdev)
642 struct ccw_device_private *priv;
643 struct cmb_data *cmb_data;
645 spin_lock(&cmb_area.lock);
646 spin_lock_irq(cdev->ccwlock);
648 priv = cdev->private;
650 if (list_empty(&priv->cmb_list)) {
655 cmb_data = priv->cmb;
658 kfree(cmb_data->last_block);
660 list_del_init(&priv->cmb_list);
662 if (list_empty(&cmb_area.list)) {
664 size = sizeof(struct cmb) * cmb_area.num_channels;
665 cmf_activate(NULL, 0);
666 free_pages((unsigned long)cmb_area.mem, get_order(size));
670 spin_unlock_irq(cdev->ccwlock);
671 spin_unlock(&cmb_area.lock);
674 static int set_cmb(struct ccw_device *cdev, u32 mme)
677 struct cmb_data *cmb_data;
680 spin_lock_irqsave(cdev->ccwlock, flags);
681 if (!cdev->private->cmb) {
682 spin_unlock_irqrestore(cdev->ccwlock, flags);
685 cmb_data = cdev->private->cmb;
686 offset = mme ? (struct cmb *)cmb_data->hw_block - cmb_area.mem : 0;
687 spin_unlock_irqrestore(cdev->ccwlock, flags);
689 return set_schib_wait(cdev, mme, 0, offset);
692 static u64 read_cmb(struct ccw_device *cdev, int index)
699 ret = cmf_cmb_copy_wait(cdev);
703 spin_lock_irqsave(cdev->ccwlock, flags);
704 if (!cdev->private->cmb) {
708 cmb = ((struct cmb_data *)cdev->private->cmb)->last_block;
711 case cmb_ssch_rsch_count:
712 ret = cmb->ssch_rsch_count;
714 case cmb_sample_count:
715 ret = cmb->sample_count;
717 case cmb_device_connect_time:
718 val = cmb->device_connect_time;
720 case cmb_function_pending_time:
721 val = cmb->function_pending_time;
723 case cmb_device_disconnect_time:
724 val = cmb->device_disconnect_time;
726 case cmb_control_unit_queuing_time:
727 val = cmb->control_unit_queuing_time;
729 case cmb_device_active_only_time:
730 val = cmb->device_active_only_time;
736 ret = time_to_avg_nsec(val, cmb->sample_count);
738 spin_unlock_irqrestore(cdev->ccwlock, flags);
742 static int readall_cmb(struct ccw_device *cdev, struct cmbdata *data)
745 struct cmb_data *cmb_data;
750 ret = cmf_cmb_copy_wait(cdev);
753 spin_lock_irqsave(cdev->ccwlock, flags);
754 cmb_data = cdev->private->cmb;
759 if (cmb_data->last_update == 0) {
763 cmb = cmb_data->last_block;
764 time = cmb_data->last_update - cdev->private->cmb_start_time;
766 memset(data, 0, sizeof(struct cmbdata));
768 /* we only know values before device_busy_time */
769 data->size = offsetof(struct cmbdata, device_busy_time);
771 /* convert to nanoseconds */
772 data->elapsed_time = (time * 1000) >> 12;
774 /* copy data to new structure */
775 data->ssch_rsch_count = cmb->ssch_rsch_count;
776 data->sample_count = cmb->sample_count;
778 /* time fields are converted to nanoseconds while copying */
779 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
780 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
781 data->device_disconnect_time =
782 time_to_nsec(cmb->device_disconnect_time);
783 data->control_unit_queuing_time
784 = time_to_nsec(cmb->control_unit_queuing_time);
785 data->device_active_only_time
786 = time_to_nsec(cmb->device_active_only_time);
789 spin_unlock_irqrestore(cdev->ccwlock, flags);
793 static void reset_cmb(struct ccw_device *cdev)
795 cmf_generic_reset(cdev);
798 static void * align_cmb(void *area)
803 static struct attribute_group cmf_attr_group;
805 static struct cmb_operations cmbops_basic = {
810 .readall = readall_cmb,
813 .attr_group = &cmf_attr_group,
816 /* ******** extended cmb handling ********/
819 * struct cmbe - extended channel measurement block
820 * @ssch_rsch_count: number of ssch and rsch
821 * @sample_count: number of samples
822 * @device_connect_time: time of device connect
823 * @function_pending_time: time of function pending
824 * @device_disconnect_time: time of device disconnect
825 * @control_unit_queuing_time: time of control unit queuing
826 * @device_active_only_time: time of device active only
827 * @device_busy_time: time of device busy
828 * @initial_command_response_time: initial command response time
831 * The measurement block as used by the hardware. May be in any 64 bit physical
833 * The fields are described further in z/Architecture Principles of Operation,
834 * third edition, chapter 17.
839 u32 device_connect_time;
840 u32 function_pending_time;
841 u32 device_disconnect_time;
842 u32 control_unit_queuing_time;
843 u32 device_active_only_time;
844 u32 device_busy_time;
845 u32 initial_command_response_time;
850 * kmalloc only guarantees 8 byte alignment, but we need cmbe
851 * pointers to be naturally aligned. Make sure to allocate
852 * enough space for two cmbes.
854 static inline struct cmbe *cmbe_align(struct cmbe *c)
857 addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
858 ~(sizeof (struct cmbe) - sizeof(long));
859 return (struct cmbe*)addr;
862 static int alloc_cmbe(struct ccw_device *cdev)
865 struct cmb_data *cmb_data;
868 cmbe = kzalloc (sizeof (*cmbe) * 2, GFP_KERNEL);
871 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
876 cmb_data->last_block = kzalloc(sizeof(struct cmbe), GFP_KERNEL);
877 if (!cmb_data->last_block) {
881 cmb_data->size = sizeof(struct cmbe);
882 spin_lock_irq(cdev->ccwlock);
883 if (cdev->private->cmb) {
884 spin_unlock_irq(cdev->ccwlock);
888 cmb_data->hw_block = cmbe;
889 cdev->private->cmb = cmb_data;
890 spin_unlock_irq(cdev->ccwlock);
892 /* activate global measurement if this is the first channel */
893 spin_lock(&cmb_area.lock);
894 if (list_empty(&cmb_area.list))
895 cmf_activate(NULL, 1);
896 list_add_tail(&cdev->private->cmb_list, &cmb_area.list);
897 spin_unlock(&cmb_area.lock);
902 kfree(cmb_data->last_block);
908 static void free_cmbe(struct ccw_device *cdev)
910 struct cmb_data *cmb_data;
912 spin_lock_irq(cdev->ccwlock);
913 cmb_data = cdev->private->cmb;
914 cdev->private->cmb = NULL;
916 kfree(cmb_data->last_block);
918 spin_unlock_irq(cdev->ccwlock);
920 /* deactivate global measurement if this is the last channel */
921 spin_lock(&cmb_area.lock);
922 list_del_init(&cdev->private->cmb_list);
923 if (list_empty(&cmb_area.list))
924 cmf_activate(NULL, 0);
925 spin_unlock(&cmb_area.lock);
928 static int set_cmbe(struct ccw_device *cdev, u32 mme)
931 struct cmb_data *cmb_data;
934 spin_lock_irqsave(cdev->ccwlock, flags);
935 if (!cdev->private->cmb) {
936 spin_unlock_irqrestore(cdev->ccwlock, flags);
939 cmb_data = cdev->private->cmb;
940 mba = mme ? (unsigned long) cmbe_align(cmb_data->hw_block) : 0;
941 spin_unlock_irqrestore(cdev->ccwlock, flags);
943 return set_schib_wait(cdev, mme, 1, mba);
947 static u64 read_cmbe(struct ccw_device *cdev, int index)
950 struct cmb_data *cmb_data;
955 ret = cmf_cmb_copy_wait(cdev);
959 spin_lock_irqsave(cdev->ccwlock, flags);
960 cmb_data = cdev->private->cmb;
965 cmb = cmb_data->last_block;
968 case cmb_ssch_rsch_count:
969 ret = cmb->ssch_rsch_count;
971 case cmb_sample_count:
972 ret = cmb->sample_count;
974 case cmb_device_connect_time:
975 val = cmb->device_connect_time;
977 case cmb_function_pending_time:
978 val = cmb->function_pending_time;
980 case cmb_device_disconnect_time:
981 val = cmb->device_disconnect_time;
983 case cmb_control_unit_queuing_time:
984 val = cmb->control_unit_queuing_time;
986 case cmb_device_active_only_time:
987 val = cmb->device_active_only_time;
989 case cmb_device_busy_time:
990 val = cmb->device_busy_time;
992 case cmb_initial_command_response_time:
993 val = cmb->initial_command_response_time;
999 ret = time_to_avg_nsec(val, cmb->sample_count);
1001 spin_unlock_irqrestore(cdev->ccwlock, flags);
1005 static int readall_cmbe(struct ccw_device *cdev, struct cmbdata *data)
1008 struct cmb_data *cmb_data;
1010 unsigned long flags;
1013 ret = cmf_cmb_copy_wait(cdev);
1016 spin_lock_irqsave(cdev->ccwlock, flags);
1017 cmb_data = cdev->private->cmb;
1022 if (cmb_data->last_update == 0) {
1026 time = cmb_data->last_update - cdev->private->cmb_start_time;
1028 memset (data, 0, sizeof(struct cmbdata));
1030 /* we only know values before device_busy_time */
1031 data->size = offsetof(struct cmbdata, device_busy_time);
1033 /* conver to nanoseconds */
1034 data->elapsed_time = (time * 1000) >> 12;
1036 cmb = cmb_data->last_block;
1037 /* copy data to new structure */
1038 data->ssch_rsch_count = cmb->ssch_rsch_count;
1039 data->sample_count = cmb->sample_count;
1041 /* time fields are converted to nanoseconds while copying */
1042 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
1043 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
1044 data->device_disconnect_time =
1045 time_to_nsec(cmb->device_disconnect_time);
1046 data->control_unit_queuing_time
1047 = time_to_nsec(cmb->control_unit_queuing_time);
1048 data->device_active_only_time
1049 = time_to_nsec(cmb->device_active_only_time);
1050 data->device_busy_time = time_to_nsec(cmb->device_busy_time);
1051 data->initial_command_response_time
1052 = time_to_nsec(cmb->initial_command_response_time);
1056 spin_unlock_irqrestore(cdev->ccwlock, flags);
1060 static void reset_cmbe(struct ccw_device *cdev)
1062 cmf_generic_reset(cdev);
1065 static void * align_cmbe(void *area)
1067 return cmbe_align(area);
1070 static struct attribute_group cmf_attr_group_ext;
1072 static struct cmb_operations cmbops_extended = {
1073 .alloc = alloc_cmbe,
1077 .readall = readall_cmbe,
1078 .reset = reset_cmbe,
1079 .align = align_cmbe,
1080 .attr_group = &cmf_attr_group_ext,
1084 static ssize_t cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
1086 return sprintf(buf, "%lld\n",
1087 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
1090 static ssize_t cmb_show_avg_sample_interval(struct device *dev,
1091 struct device_attribute *attr,
1094 struct ccw_device *cdev;
1096 unsigned long count;
1097 struct cmb_data *cmb_data;
1099 cdev = to_ccwdev(dev);
1100 count = cmf_read(cdev, cmb_sample_count);
1101 spin_lock_irq(cdev->ccwlock);
1102 cmb_data = cdev->private->cmb;
1104 interval = cmb_data->last_update -
1105 cdev->private->cmb_start_time;
1106 interval = (interval * 1000) >> 12;
1110 spin_unlock_irq(cdev->ccwlock);
1111 return sprintf(buf, "%ld\n", interval);
1114 static ssize_t cmb_show_avg_utilization(struct device *dev,
1115 struct device_attribute *attr,
1118 struct cmbdata data;
1123 ret = cmf_readall(to_ccwdev(dev), &data);
1124 if (ret == -EAGAIN || ret == -ENODEV)
1125 /* No data (yet/currently) available to use for calculation. */
1126 return sprintf(buf, "n/a\n");
1130 utilization = data.device_connect_time +
1131 data.function_pending_time +
1132 data.device_disconnect_time;
1134 /* shift to avoid long long division */
1135 while (-1ul < (data.elapsed_time | utilization)) {
1137 data.elapsed_time >>= 8;
1140 /* calculate value in 0.1 percent units */
1141 t = (unsigned long) data.elapsed_time / 1000;
1142 u = (unsigned long) utilization / t;
1144 return sprintf(buf, "%02ld.%01ld%%\n", u/ 10, u - (u/ 10) * 10);
1147 #define cmf_attr(name) \
1148 static ssize_t show_##name(struct device *dev, \
1149 struct device_attribute *attr, char *buf) \
1150 { return cmb_show_attr((dev), buf, cmb_##name); } \
1151 static DEVICE_ATTR(name, 0444, show_##name, NULL);
1153 #define cmf_attr_avg(name) \
1154 static ssize_t show_avg_##name(struct device *dev, \
1155 struct device_attribute *attr, char *buf) \
1156 { return cmb_show_attr((dev), buf, cmb_##name); } \
1157 static DEVICE_ATTR(avg_##name, 0444, show_avg_##name, NULL);
1159 cmf_attr(ssch_rsch_count);
1160 cmf_attr(sample_count);
1161 cmf_attr_avg(device_connect_time);
1162 cmf_attr_avg(function_pending_time);
1163 cmf_attr_avg(device_disconnect_time);
1164 cmf_attr_avg(control_unit_queuing_time);
1165 cmf_attr_avg(device_active_only_time);
1166 cmf_attr_avg(device_busy_time);
1167 cmf_attr_avg(initial_command_response_time);
1169 static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval,
1171 static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
1173 static struct attribute *cmf_attributes[] = {
1174 &dev_attr_avg_sample_interval.attr,
1175 &dev_attr_avg_utilization.attr,
1176 &dev_attr_ssch_rsch_count.attr,
1177 &dev_attr_sample_count.attr,
1178 &dev_attr_avg_device_connect_time.attr,
1179 &dev_attr_avg_function_pending_time.attr,
1180 &dev_attr_avg_device_disconnect_time.attr,
1181 &dev_attr_avg_control_unit_queuing_time.attr,
1182 &dev_attr_avg_device_active_only_time.attr,
1186 static struct attribute_group cmf_attr_group = {
1188 .attrs = cmf_attributes,
1191 static struct attribute *cmf_attributes_ext[] = {
1192 &dev_attr_avg_sample_interval.attr,
1193 &dev_attr_avg_utilization.attr,
1194 &dev_attr_ssch_rsch_count.attr,
1195 &dev_attr_sample_count.attr,
1196 &dev_attr_avg_device_connect_time.attr,
1197 &dev_attr_avg_function_pending_time.attr,
1198 &dev_attr_avg_device_disconnect_time.attr,
1199 &dev_attr_avg_control_unit_queuing_time.attr,
1200 &dev_attr_avg_device_active_only_time.attr,
1201 &dev_attr_avg_device_busy_time.attr,
1202 &dev_attr_avg_initial_command_response_time.attr,
1206 static struct attribute_group cmf_attr_group_ext = {
1208 .attrs = cmf_attributes_ext,
1211 static ssize_t cmb_enable_show(struct device *dev,
1212 struct device_attribute *attr,
1215 return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
1218 static ssize_t cmb_enable_store(struct device *dev,
1219 struct device_attribute *attr, const char *buf,
1222 struct ccw_device *cdev;
1225 cdev = to_ccwdev(dev);
1229 ret = disable_cmf(cdev);
1231 dev_info(&cdev->dev, "disable_cmf failed (%d)\n", ret);
1234 ret = enable_cmf(cdev);
1235 if (ret && ret != -EBUSY)
1236 dev_info(&cdev->dev, "enable_cmf failed (%d)\n", ret);
1243 DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
1246 * enable_cmf() - switch on the channel measurement for a specific device
1247 * @cdev: The ccw device to be enabled
1249 * Returns %0 for success or a negative error value.
1254 int enable_cmf(struct ccw_device *cdev)
1258 ret = cmbops->alloc(cdev);
1259 cmbops->reset(cdev);
1262 ret = cmbops->set(cdev, 2);
1267 ret = sysfs_create_group(&cdev->dev.kobj, cmbops->attr_group);
1270 cmbops->set(cdev, 0); //FIXME: this can fail
1276 * disable_cmf() - switch off the channel measurement for a specific device
1277 * @cdev: The ccw device to be disabled
1279 * Returns %0 for success or a negative error value.
1284 int disable_cmf(struct ccw_device *cdev)
1288 ret = cmbops->set(cdev, 0);
1292 sysfs_remove_group(&cdev->dev.kobj, cmbops->attr_group);
1297 * cmf_read() - read one value from the current channel measurement block
1298 * @cdev: the channel to be read
1299 * @index: the index of the value to be read
1301 * Returns the value read or %0 if the value cannot be read.
1306 u64 cmf_read(struct ccw_device *cdev, int index)
1308 return cmbops->read(cdev, index);
1312 * cmf_readall() - read the current channel measurement block
1313 * @cdev: the channel to be read
1314 * @data: a pointer to a data block that will be filled
1316 * Returns %0 on success, a negative error value otherwise.
1321 int cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
1323 return cmbops->readall(cdev, data);
1326 /* Reenable cmf when a disconnected device becomes available again. */
1327 int cmf_reenable(struct ccw_device *cdev)
1329 cmbops->reset(cdev);
1330 return cmbops->set(cdev, 2);
1333 static int __init init_cmf(void)
1335 char *format_string;
1336 char *detect_string = "parameter";
1339 * If the user did not give a parameter, see if we are running on a
1340 * machine supporting extended measurement blocks, otherwise fall back
1343 if (format == CMF_AUTODETECT) {
1344 if (!css_characteristics_avail ||
1345 !css_general_characteristics.ext_mb) {
1348 format = CMF_EXTENDED;
1350 detect_string = "autodetected";
1352 detect_string = "parameter";
1357 format_string = "basic";
1358 cmbops = &cmbops_basic;
1361 format_string = "extended";
1362 cmbops = &cmbops_extended;
1365 printk(KERN_ERR "cio: Invalid format %d for channel "
1366 "measurement facility\n", format);
1370 printk(KERN_INFO "cio: Channel measurement facility using %s "
1371 "format (%s)\n", format_string, detect_string);
1375 module_init(init_cmf);
1378 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
1379 MODULE_LICENSE("GPL");
1380 MODULE_DESCRIPTION("channel measurement facility base driver\n"
1381 "Copyright 2003 IBM Corporation\n");
1383 EXPORT_SYMBOL_GPL(enable_cmf);
1384 EXPORT_SYMBOL_GPL(disable_cmf);
1385 EXPORT_SYMBOL_GPL(cmf_read);
1386 EXPORT_SYMBOL_GPL(cmf_readall);