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)
188 struct subchannel *sch;
190 sch = to_subchannel(cdev->dev.parent);
192 sch->config.mme = mme;
193 sch->config.mbfc = mbfc;
194 /* address can be either a block address or a block index */
196 sch->config.mba = address;
198 sch->config.mbi = address;
200 return cio_commit_config(sch);
203 struct set_schib_struct {
206 unsigned long address;
207 wait_queue_head_t wait;
212 static void cmf_set_schib_release(struct kref *kref)
214 struct set_schib_struct *set_data;
216 set_data = container_of(kref, struct set_schib_struct, kref);
220 #define CMF_PENDING 1
222 static int set_schib_wait(struct ccw_device *cdev, u32 mme,
223 int mbfc, unsigned long address)
225 struct set_schib_struct *set_data;
228 spin_lock_irq(cdev->ccwlock);
229 if (!cdev->private->cmb) {
233 set_data = kzalloc(sizeof(struct set_schib_struct), GFP_ATOMIC);
238 init_waitqueue_head(&set_data->wait);
239 kref_init(&set_data->kref);
241 set_data->mbfc = mbfc;
242 set_data->address = address;
244 ret = set_schib(cdev, mme, mbfc, address);
248 if (cdev->private->state != DEV_STATE_ONLINE) {
249 /* if the device is not online, don't even try again */
254 cdev->private->state = DEV_STATE_CMFCHANGE;
255 set_data->ret = CMF_PENDING;
256 cdev->private->cmb_wait = set_data;
258 spin_unlock_irq(cdev->ccwlock);
259 if (wait_event_interruptible(set_data->wait,
260 set_data->ret != CMF_PENDING)) {
261 spin_lock_irq(cdev->ccwlock);
262 if (set_data->ret == CMF_PENDING) {
263 set_data->ret = -ERESTARTSYS;
264 if (cdev->private->state == DEV_STATE_CMFCHANGE)
265 cdev->private->state = DEV_STATE_ONLINE;
267 spin_unlock_irq(cdev->ccwlock);
269 spin_lock_irq(cdev->ccwlock);
270 cdev->private->cmb_wait = NULL;
273 kref_put(&set_data->kref, cmf_set_schib_release);
275 spin_unlock_irq(cdev->ccwlock);
279 void retry_set_schib(struct ccw_device *cdev)
281 struct set_schib_struct *set_data;
283 set_data = cdev->private->cmb_wait;
288 kref_get(&set_data->kref);
289 set_data->ret = set_schib(cdev, set_data->mme, set_data->mbfc,
291 wake_up(&set_data->wait);
292 kref_put(&set_data->kref, cmf_set_schib_release);
295 static int cmf_copy_block(struct ccw_device *cdev)
297 struct subchannel *sch;
300 struct cmb_data *cmb_data;
302 sch = to_subchannel(cdev->dev.parent);
304 if (cio_update_schib(sch))
307 if (scsw_fctl(&sch->schib.scsw) & SCSW_FCTL_START_FUNC) {
308 /* Don't copy if a start function is in progress. */
309 if ((!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_SUSPENDED)) &&
310 (scsw_actl(&sch->schib.scsw) &
311 (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) &&
312 (!(scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_SEC_STATUS)))
315 cmb_data = cdev->private->cmb;
316 hw_block = cmbops->align(cmb_data->hw_block);
317 if (!memcmp(cmb_data->last_block, hw_block, cmb_data->size))
318 /* No need to copy. */
320 reference_buf = kzalloc(cmb_data->size, GFP_ATOMIC);
323 /* Ensure consistency of block copied from hardware. */
325 memcpy(cmb_data->last_block, hw_block, cmb_data->size);
326 memcpy(reference_buf, hw_block, cmb_data->size);
327 } while (memcmp(cmb_data->last_block, reference_buf, cmb_data->size));
328 cmb_data->last_update = get_clock();
329 kfree(reference_buf);
333 struct copy_block_struct {
334 wait_queue_head_t wait;
339 static void cmf_copy_block_release(struct kref *kref)
341 struct copy_block_struct *copy_block;
343 copy_block = container_of(kref, struct copy_block_struct, kref);
347 static int cmf_cmb_copy_wait(struct ccw_device *cdev)
349 struct copy_block_struct *copy_block;
353 spin_lock_irqsave(cdev->ccwlock, flags);
354 if (!cdev->private->cmb) {
358 copy_block = kzalloc(sizeof(struct copy_block_struct), GFP_ATOMIC);
363 init_waitqueue_head(©_block->wait);
364 kref_init(©_block->kref);
366 ret = cmf_copy_block(cdev);
370 if (cdev->private->state != DEV_STATE_ONLINE) {
375 cdev->private->state = DEV_STATE_CMFUPDATE;
376 copy_block->ret = CMF_PENDING;
377 cdev->private->cmb_wait = copy_block;
379 spin_unlock_irqrestore(cdev->ccwlock, flags);
380 if (wait_event_interruptible(copy_block->wait,
381 copy_block->ret != CMF_PENDING)) {
382 spin_lock_irqsave(cdev->ccwlock, flags);
383 if (copy_block->ret == CMF_PENDING) {
384 copy_block->ret = -ERESTARTSYS;
385 if (cdev->private->state == DEV_STATE_CMFUPDATE)
386 cdev->private->state = DEV_STATE_ONLINE;
388 spin_unlock_irqrestore(cdev->ccwlock, flags);
390 spin_lock_irqsave(cdev->ccwlock, flags);
391 cdev->private->cmb_wait = NULL;
392 ret = copy_block->ret;
394 kref_put(©_block->kref, cmf_copy_block_release);
396 spin_unlock_irqrestore(cdev->ccwlock, flags);
400 void cmf_retry_copy_block(struct ccw_device *cdev)
402 struct copy_block_struct *copy_block;
404 copy_block = cdev->private->cmb_wait;
409 kref_get(©_block->kref);
410 copy_block->ret = cmf_copy_block(cdev);
411 wake_up(©_block->wait);
412 kref_put(©_block->kref, cmf_copy_block_release);
415 static void cmf_generic_reset(struct ccw_device *cdev)
417 struct cmb_data *cmb_data;
419 spin_lock_irq(cdev->ccwlock);
420 cmb_data = cdev->private->cmb;
422 memset(cmb_data->last_block, 0, cmb_data->size);
424 * Need to reset hw block as well to make the hardware start
427 memset(cmbops->align(cmb_data->hw_block), 0, cmb_data->size);
428 cmb_data->last_update = 0;
430 cdev->private->cmb_start_time = get_clock();
431 spin_unlock_irq(cdev->ccwlock);
435 * struct cmb_area - container for global cmb data
437 * @mem: pointer to CMBs (only in basic measurement mode)
438 * @list: contains a linked list of all subchannels
439 * @num_channels: number of channels to be measured
440 * @lock: protect concurrent access to @mem and @list
444 struct list_head list;
449 static struct cmb_area cmb_area = {
450 .lock = __SPIN_LOCK_UNLOCKED(cmb_area.lock),
451 .list = LIST_HEAD_INIT(cmb_area.list),
452 .num_channels = 1024,
455 /* ****** old style CMB handling ********/
458 * Basic channel measurement blocks are allocated in one contiguous
459 * block of memory, which can not be moved as long as any channel
460 * is active. Therefore, a maximum number of subchannels needs to
461 * be defined somewhere. This is a module parameter, defaulting to
462 * a resonable value of 1024, or 32 kb of memory.
463 * Current kernels don't allow kmalloc with more than 128kb, so the
467 module_param_named(maxchannels, cmb_area.num_channels, uint, 0444);
470 * struct cmb - basic channel measurement block
471 * @ssch_rsch_count: number of ssch and rsch
472 * @sample_count: number of samples
473 * @device_connect_time: time of device connect
474 * @function_pending_time: time of function pending
475 * @device_disconnect_time: time of device disconnect
476 * @control_unit_queuing_time: time of control unit queuing
477 * @device_active_only_time: time of device active only
478 * @reserved: unused in basic measurement mode
480 * The measurement block as used by the hardware. The fields are described
481 * further in z/Architecture Principles of Operation, chapter 17.
483 * The cmb area made up from these blocks must be a contiguous array and may
484 * not be reallocated or freed.
485 * Only one cmb area can be present in the system.
490 u32 device_connect_time;
491 u32 function_pending_time;
492 u32 device_disconnect_time;
493 u32 control_unit_queuing_time;
494 u32 device_active_only_time;
499 * Insert a single device into the cmb_area list.
500 * Called with cmb_area.lock held from alloc_cmb.
502 static int alloc_cmb_single(struct ccw_device *cdev,
503 struct cmb_data *cmb_data)
506 struct ccw_device_private *node;
509 spin_lock_irq(cdev->ccwlock);
510 if (!list_empty(&cdev->private->cmb_list)) {
516 * Find first unused cmb in cmb_area.mem.
517 * This is a little tricky: cmb_area.list
518 * remains sorted by ->cmb->hw_data pointers.
521 list_for_each_entry(node, &cmb_area.list, cmb_list) {
522 struct cmb_data *data;
524 if ((struct cmb*)data->hw_block > cmb)
528 if (cmb - cmb_area.mem >= cmb_area.num_channels) {
534 list_add_tail(&cdev->private->cmb_list, &node->cmb_list);
535 cmb_data->hw_block = cmb;
536 cdev->private->cmb = cmb_data;
539 spin_unlock_irq(cdev->ccwlock);
543 static int alloc_cmb(struct ccw_device *cdev)
548 struct cmb_data *cmb_data;
550 /* Allocate private cmb_data. */
551 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
555 cmb_data->last_block = kzalloc(sizeof(struct cmb), GFP_KERNEL);
556 if (!cmb_data->last_block) {
560 cmb_data->size = sizeof(struct cmb);
561 spin_lock(&cmb_area.lock);
564 /* there is no user yet, so we need a new area */
565 size = sizeof(struct cmb) * cmb_area.num_channels;
566 WARN_ON(!list_empty(&cmb_area.list));
568 spin_unlock(&cmb_area.lock);
569 mem = (void*)__get_free_pages(GFP_KERNEL | GFP_DMA,
571 spin_lock(&cmb_area.lock);
574 /* ok, another thread was faster */
575 free_pages((unsigned long)mem, get_order(size));
582 memset(mem, 0, size);
584 cmf_activate(cmb_area.mem, 1);
588 /* do the actual allocation */
589 ret = alloc_cmb_single(cdev, cmb_data);
591 spin_unlock(&cmb_area.lock);
593 kfree(cmb_data->last_block);
599 static void free_cmb(struct ccw_device *cdev)
601 struct ccw_device_private *priv;
602 struct cmb_data *cmb_data;
604 spin_lock(&cmb_area.lock);
605 spin_lock_irq(cdev->ccwlock);
607 priv = cdev->private;
609 if (list_empty(&priv->cmb_list)) {
614 cmb_data = priv->cmb;
617 kfree(cmb_data->last_block);
619 list_del_init(&priv->cmb_list);
621 if (list_empty(&cmb_area.list)) {
623 size = sizeof(struct cmb) * cmb_area.num_channels;
624 cmf_activate(NULL, 0);
625 free_pages((unsigned long)cmb_area.mem, get_order(size));
629 spin_unlock_irq(cdev->ccwlock);
630 spin_unlock(&cmb_area.lock);
633 static int set_cmb(struct ccw_device *cdev, u32 mme)
636 struct cmb_data *cmb_data;
639 spin_lock_irqsave(cdev->ccwlock, flags);
640 if (!cdev->private->cmb) {
641 spin_unlock_irqrestore(cdev->ccwlock, flags);
644 cmb_data = cdev->private->cmb;
645 offset = mme ? (struct cmb *)cmb_data->hw_block - cmb_area.mem : 0;
646 spin_unlock_irqrestore(cdev->ccwlock, flags);
648 return set_schib_wait(cdev, mme, 0, offset);
651 static u64 read_cmb(struct ccw_device *cdev, int index)
658 ret = cmf_cmb_copy_wait(cdev);
662 spin_lock_irqsave(cdev->ccwlock, flags);
663 if (!cdev->private->cmb) {
667 cmb = ((struct cmb_data *)cdev->private->cmb)->last_block;
670 case cmb_ssch_rsch_count:
671 ret = cmb->ssch_rsch_count;
673 case cmb_sample_count:
674 ret = cmb->sample_count;
676 case cmb_device_connect_time:
677 val = cmb->device_connect_time;
679 case cmb_function_pending_time:
680 val = cmb->function_pending_time;
682 case cmb_device_disconnect_time:
683 val = cmb->device_disconnect_time;
685 case cmb_control_unit_queuing_time:
686 val = cmb->control_unit_queuing_time;
688 case cmb_device_active_only_time:
689 val = cmb->device_active_only_time;
695 ret = time_to_avg_nsec(val, cmb->sample_count);
697 spin_unlock_irqrestore(cdev->ccwlock, flags);
701 static int readall_cmb(struct ccw_device *cdev, struct cmbdata *data)
704 struct cmb_data *cmb_data;
709 ret = cmf_cmb_copy_wait(cdev);
712 spin_lock_irqsave(cdev->ccwlock, flags);
713 cmb_data = cdev->private->cmb;
718 if (cmb_data->last_update == 0) {
722 cmb = cmb_data->last_block;
723 time = cmb_data->last_update - cdev->private->cmb_start_time;
725 memset(data, 0, sizeof(struct cmbdata));
727 /* we only know values before device_busy_time */
728 data->size = offsetof(struct cmbdata, device_busy_time);
730 /* convert to nanoseconds */
731 data->elapsed_time = (time * 1000) >> 12;
733 /* copy data to new structure */
734 data->ssch_rsch_count = cmb->ssch_rsch_count;
735 data->sample_count = cmb->sample_count;
737 /* time fields are converted to nanoseconds while copying */
738 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
739 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
740 data->device_disconnect_time =
741 time_to_nsec(cmb->device_disconnect_time);
742 data->control_unit_queuing_time
743 = time_to_nsec(cmb->control_unit_queuing_time);
744 data->device_active_only_time
745 = time_to_nsec(cmb->device_active_only_time);
748 spin_unlock_irqrestore(cdev->ccwlock, flags);
752 static void reset_cmb(struct ccw_device *cdev)
754 cmf_generic_reset(cdev);
757 static void * align_cmb(void *area)
762 static struct attribute_group cmf_attr_group;
764 static struct cmb_operations cmbops_basic = {
769 .readall = readall_cmb,
772 .attr_group = &cmf_attr_group,
775 /* ******** extended cmb handling ********/
778 * struct cmbe - extended channel measurement block
779 * @ssch_rsch_count: number of ssch and rsch
780 * @sample_count: number of samples
781 * @device_connect_time: time of device connect
782 * @function_pending_time: time of function pending
783 * @device_disconnect_time: time of device disconnect
784 * @control_unit_queuing_time: time of control unit queuing
785 * @device_active_only_time: time of device active only
786 * @device_busy_time: time of device busy
787 * @initial_command_response_time: initial command response time
790 * The measurement block as used by the hardware. May be in any 64 bit physical
792 * The fields are described further in z/Architecture Principles of Operation,
793 * third edition, chapter 17.
798 u32 device_connect_time;
799 u32 function_pending_time;
800 u32 device_disconnect_time;
801 u32 control_unit_queuing_time;
802 u32 device_active_only_time;
803 u32 device_busy_time;
804 u32 initial_command_response_time;
809 * kmalloc only guarantees 8 byte alignment, but we need cmbe
810 * pointers to be naturally aligned. Make sure to allocate
811 * enough space for two cmbes.
813 static inline struct cmbe *cmbe_align(struct cmbe *c)
816 addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
817 ~(sizeof (struct cmbe) - sizeof(long));
818 return (struct cmbe*)addr;
821 static int alloc_cmbe(struct ccw_device *cdev)
824 struct cmb_data *cmb_data;
827 cmbe = kzalloc (sizeof (*cmbe) * 2, GFP_KERNEL);
830 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
835 cmb_data->last_block = kzalloc(sizeof(struct cmbe), GFP_KERNEL);
836 if (!cmb_data->last_block) {
840 cmb_data->size = sizeof(struct cmbe);
841 spin_lock_irq(cdev->ccwlock);
842 if (cdev->private->cmb) {
843 spin_unlock_irq(cdev->ccwlock);
847 cmb_data->hw_block = cmbe;
848 cdev->private->cmb = cmb_data;
849 spin_unlock_irq(cdev->ccwlock);
851 /* activate global measurement if this is the first channel */
852 spin_lock(&cmb_area.lock);
853 if (list_empty(&cmb_area.list))
854 cmf_activate(NULL, 1);
855 list_add_tail(&cdev->private->cmb_list, &cmb_area.list);
856 spin_unlock(&cmb_area.lock);
861 kfree(cmb_data->last_block);
867 static void free_cmbe(struct ccw_device *cdev)
869 struct cmb_data *cmb_data;
871 spin_lock_irq(cdev->ccwlock);
872 cmb_data = cdev->private->cmb;
873 cdev->private->cmb = NULL;
875 kfree(cmb_data->last_block);
877 spin_unlock_irq(cdev->ccwlock);
879 /* deactivate global measurement if this is the last channel */
880 spin_lock(&cmb_area.lock);
881 list_del_init(&cdev->private->cmb_list);
882 if (list_empty(&cmb_area.list))
883 cmf_activate(NULL, 0);
884 spin_unlock(&cmb_area.lock);
887 static int set_cmbe(struct ccw_device *cdev, u32 mme)
890 struct cmb_data *cmb_data;
893 spin_lock_irqsave(cdev->ccwlock, flags);
894 if (!cdev->private->cmb) {
895 spin_unlock_irqrestore(cdev->ccwlock, flags);
898 cmb_data = cdev->private->cmb;
899 mba = mme ? (unsigned long) cmbe_align(cmb_data->hw_block) : 0;
900 spin_unlock_irqrestore(cdev->ccwlock, flags);
902 return set_schib_wait(cdev, mme, 1, mba);
906 static u64 read_cmbe(struct ccw_device *cdev, int index)
909 struct cmb_data *cmb_data;
914 ret = cmf_cmb_copy_wait(cdev);
918 spin_lock_irqsave(cdev->ccwlock, flags);
919 cmb_data = cdev->private->cmb;
924 cmb = cmb_data->last_block;
927 case cmb_ssch_rsch_count:
928 ret = cmb->ssch_rsch_count;
930 case cmb_sample_count:
931 ret = cmb->sample_count;
933 case cmb_device_connect_time:
934 val = cmb->device_connect_time;
936 case cmb_function_pending_time:
937 val = cmb->function_pending_time;
939 case cmb_device_disconnect_time:
940 val = cmb->device_disconnect_time;
942 case cmb_control_unit_queuing_time:
943 val = cmb->control_unit_queuing_time;
945 case cmb_device_active_only_time:
946 val = cmb->device_active_only_time;
948 case cmb_device_busy_time:
949 val = cmb->device_busy_time;
951 case cmb_initial_command_response_time:
952 val = cmb->initial_command_response_time;
958 ret = time_to_avg_nsec(val, cmb->sample_count);
960 spin_unlock_irqrestore(cdev->ccwlock, flags);
964 static int readall_cmbe(struct ccw_device *cdev, struct cmbdata *data)
967 struct cmb_data *cmb_data;
972 ret = cmf_cmb_copy_wait(cdev);
975 spin_lock_irqsave(cdev->ccwlock, flags);
976 cmb_data = cdev->private->cmb;
981 if (cmb_data->last_update == 0) {
985 time = cmb_data->last_update - cdev->private->cmb_start_time;
987 memset (data, 0, sizeof(struct cmbdata));
989 /* we only know values before device_busy_time */
990 data->size = offsetof(struct cmbdata, device_busy_time);
992 /* conver to nanoseconds */
993 data->elapsed_time = (time * 1000) >> 12;
995 cmb = cmb_data->last_block;
996 /* copy data to new structure */
997 data->ssch_rsch_count = cmb->ssch_rsch_count;
998 data->sample_count = cmb->sample_count;
1000 /* time fields are converted to nanoseconds while copying */
1001 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
1002 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
1003 data->device_disconnect_time =
1004 time_to_nsec(cmb->device_disconnect_time);
1005 data->control_unit_queuing_time
1006 = time_to_nsec(cmb->control_unit_queuing_time);
1007 data->device_active_only_time
1008 = time_to_nsec(cmb->device_active_only_time);
1009 data->device_busy_time = time_to_nsec(cmb->device_busy_time);
1010 data->initial_command_response_time
1011 = time_to_nsec(cmb->initial_command_response_time);
1015 spin_unlock_irqrestore(cdev->ccwlock, flags);
1019 static void reset_cmbe(struct ccw_device *cdev)
1021 cmf_generic_reset(cdev);
1024 static void * align_cmbe(void *area)
1026 return cmbe_align(area);
1029 static struct attribute_group cmf_attr_group_ext;
1031 static struct cmb_operations cmbops_extended = {
1032 .alloc = alloc_cmbe,
1036 .readall = readall_cmbe,
1037 .reset = reset_cmbe,
1038 .align = align_cmbe,
1039 .attr_group = &cmf_attr_group_ext,
1042 static ssize_t cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
1044 return sprintf(buf, "%lld\n",
1045 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
1048 static ssize_t cmb_show_avg_sample_interval(struct device *dev,
1049 struct device_attribute *attr,
1052 struct ccw_device *cdev;
1054 unsigned long count;
1055 struct cmb_data *cmb_data;
1057 cdev = to_ccwdev(dev);
1058 count = cmf_read(cdev, cmb_sample_count);
1059 spin_lock_irq(cdev->ccwlock);
1060 cmb_data = cdev->private->cmb;
1062 interval = cmb_data->last_update -
1063 cdev->private->cmb_start_time;
1064 interval = (interval * 1000) >> 12;
1068 spin_unlock_irq(cdev->ccwlock);
1069 return sprintf(buf, "%ld\n", interval);
1072 static ssize_t cmb_show_avg_utilization(struct device *dev,
1073 struct device_attribute *attr,
1076 struct cmbdata data;
1081 ret = cmf_readall(to_ccwdev(dev), &data);
1082 if (ret == -EAGAIN || ret == -ENODEV)
1083 /* No data (yet/currently) available to use for calculation. */
1084 return sprintf(buf, "n/a\n");
1088 utilization = data.device_connect_time +
1089 data.function_pending_time +
1090 data.device_disconnect_time;
1092 /* shift to avoid long long division */
1093 while (-1ul < (data.elapsed_time | utilization)) {
1095 data.elapsed_time >>= 8;
1098 /* calculate value in 0.1 percent units */
1099 t = (unsigned long) data.elapsed_time / 1000;
1100 u = (unsigned long) utilization / t;
1102 return sprintf(buf, "%02ld.%01ld%%\n", u/ 10, u - (u/ 10) * 10);
1105 #define cmf_attr(name) \
1106 static ssize_t show_##name(struct device *dev, \
1107 struct device_attribute *attr, char *buf) \
1108 { return cmb_show_attr((dev), buf, cmb_##name); } \
1109 static DEVICE_ATTR(name, 0444, show_##name, NULL);
1111 #define cmf_attr_avg(name) \
1112 static ssize_t show_avg_##name(struct device *dev, \
1113 struct device_attribute *attr, char *buf) \
1114 { return cmb_show_attr((dev), buf, cmb_##name); } \
1115 static DEVICE_ATTR(avg_##name, 0444, show_avg_##name, NULL);
1117 cmf_attr(ssch_rsch_count);
1118 cmf_attr(sample_count);
1119 cmf_attr_avg(device_connect_time);
1120 cmf_attr_avg(function_pending_time);
1121 cmf_attr_avg(device_disconnect_time);
1122 cmf_attr_avg(control_unit_queuing_time);
1123 cmf_attr_avg(device_active_only_time);
1124 cmf_attr_avg(device_busy_time);
1125 cmf_attr_avg(initial_command_response_time);
1127 static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval,
1129 static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
1131 static struct attribute *cmf_attributes[] = {
1132 &dev_attr_avg_sample_interval.attr,
1133 &dev_attr_avg_utilization.attr,
1134 &dev_attr_ssch_rsch_count.attr,
1135 &dev_attr_sample_count.attr,
1136 &dev_attr_avg_device_connect_time.attr,
1137 &dev_attr_avg_function_pending_time.attr,
1138 &dev_attr_avg_device_disconnect_time.attr,
1139 &dev_attr_avg_control_unit_queuing_time.attr,
1140 &dev_attr_avg_device_active_only_time.attr,
1144 static struct attribute_group cmf_attr_group = {
1146 .attrs = cmf_attributes,
1149 static struct attribute *cmf_attributes_ext[] = {
1150 &dev_attr_avg_sample_interval.attr,
1151 &dev_attr_avg_utilization.attr,
1152 &dev_attr_ssch_rsch_count.attr,
1153 &dev_attr_sample_count.attr,
1154 &dev_attr_avg_device_connect_time.attr,
1155 &dev_attr_avg_function_pending_time.attr,
1156 &dev_attr_avg_device_disconnect_time.attr,
1157 &dev_attr_avg_control_unit_queuing_time.attr,
1158 &dev_attr_avg_device_active_only_time.attr,
1159 &dev_attr_avg_device_busy_time.attr,
1160 &dev_attr_avg_initial_command_response_time.attr,
1164 static struct attribute_group cmf_attr_group_ext = {
1166 .attrs = cmf_attributes_ext,
1169 static ssize_t cmb_enable_show(struct device *dev,
1170 struct device_attribute *attr,
1173 return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
1176 static ssize_t cmb_enable_store(struct device *dev,
1177 struct device_attribute *attr, const char *buf,
1180 struct ccw_device *cdev;
1184 ret = strict_strtoul(buf, 16, &val);
1188 cdev = to_ccwdev(dev);
1192 ret = disable_cmf(cdev);
1195 ret = enable_cmf(cdev);
1202 DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
1205 * enable_cmf() - switch on the channel measurement for a specific device
1206 * @cdev: The ccw device to be enabled
1208 * Returns %0 for success or a negative error value.
1213 int enable_cmf(struct ccw_device *cdev)
1217 ret = cmbops->alloc(cdev);
1218 cmbops->reset(cdev);
1221 ret = cmbops->set(cdev, 2);
1226 ret = sysfs_create_group(&cdev->dev.kobj, cmbops->attr_group);
1229 cmbops->set(cdev, 0); //FIXME: this can fail
1235 * disable_cmf() - switch off the channel measurement for a specific device
1236 * @cdev: The ccw device to be disabled
1238 * Returns %0 for success or a negative error value.
1243 int disable_cmf(struct ccw_device *cdev)
1247 ret = cmbops->set(cdev, 0);
1251 sysfs_remove_group(&cdev->dev.kobj, cmbops->attr_group);
1256 * cmf_read() - read one value from the current channel measurement block
1257 * @cdev: the channel to be read
1258 * @index: the index of the value to be read
1260 * Returns the value read or %0 if the value cannot be read.
1265 u64 cmf_read(struct ccw_device *cdev, int index)
1267 return cmbops->read(cdev, index);
1271 * cmf_readall() - read the current channel measurement block
1272 * @cdev: the channel to be read
1273 * @data: a pointer to a data block that will be filled
1275 * Returns %0 on success, a negative error value otherwise.
1280 int cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
1282 return cmbops->readall(cdev, data);
1285 /* Reenable cmf when a disconnected device becomes available again. */
1286 int cmf_reenable(struct ccw_device *cdev)
1288 cmbops->reset(cdev);
1289 return cmbops->set(cdev, 2);
1292 static int __init init_cmf(void)
1294 char *format_string;
1295 char *detect_string = "parameter";
1298 * If the user did not give a parameter, see if we are running on a
1299 * machine supporting extended measurement blocks, otherwise fall back
1302 if (format == CMF_AUTODETECT) {
1303 if (!css_general_characteristics.ext_mb) {
1306 format = CMF_EXTENDED;
1308 detect_string = "autodetected";
1310 detect_string = "parameter";
1315 format_string = "basic";
1316 cmbops = &cmbops_basic;
1319 format_string = "extended";
1320 cmbops = &cmbops_extended;
1326 printk(KERN_INFO "cio: Channel measurement facility using %s "
1327 "format (%s)\n", format_string, detect_string);
1331 module_init(init_cmf);
1334 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
1335 MODULE_LICENSE("GPL");
1336 MODULE_DESCRIPTION("channel measurement facility base driver\n"
1337 "Copyright 2003 IBM Corporation\n");
1339 EXPORT_SYMBOL_GPL(enable_cmf);
1340 EXPORT_SYMBOL_GPL(disable_cmf);
1341 EXPORT_SYMBOL_GPL(cmf_read);
1342 EXPORT_SYMBOL_GPL(cmf_readall);