Loading...
1/*
2 * linux/drivers/s390/cio/cmf.c
3 *
4 * Linux on zSeries Channel Measurement Facility support
5 *
6 * Copyright 2000,2006 IBM Corporation
7 *
8 * Authors: Arnd Bergmann <arndb@de.ibm.com>
9 * Cornelia Huck <cornelia.huck@de.ibm.com>
10 *
11 * original idea from Natarajan Krishnaswami <nkrishna@us.ibm.com>
12 *
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)
16 * any later version.
17 *
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.
22 *
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.
26 */
27
28#define KMSG_COMPONENT "cio"
29#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
30
31#include <linux/bootmem.h>
32#include <linux/device.h>
33#include <linux/init.h>
34#include <linux/list.h>
35#include <linux/module.h>
36#include <linux/moduleparam.h>
37#include <linux/slab.h>
38#include <linux/timex.h> /* get_clock() */
39
40#include <asm/ccwdev.h>
41#include <asm/cio.h>
42#include <asm/cmb.h>
43#include <asm/div64.h>
44
45#include "cio.h"
46#include "css.h"
47#include "device.h"
48#include "ioasm.h"
49#include "chsc.h"
50
51/*
52 * parameter to enable cmf during boot, possible uses are:
53 * "s390cmf" -- enable cmf and allocate 2 MB of ram so measuring can be
54 * used on any subchannel
55 * "s390cmf=<num>" -- enable cmf and allocate enough memory to measure
56 * <num> subchannel, where <num> is an integer
57 * between 1 and 65535, default is 1024
58 */
59#define ARGSTRING "s390cmf"
60
61/* indices for READCMB */
62enum cmb_index {
63 /* basic and exended format: */
64 cmb_ssch_rsch_count,
65 cmb_sample_count,
66 cmb_device_connect_time,
67 cmb_function_pending_time,
68 cmb_device_disconnect_time,
69 cmb_control_unit_queuing_time,
70 cmb_device_active_only_time,
71 /* extended format only: */
72 cmb_device_busy_time,
73 cmb_initial_command_response_time,
74};
75
76/**
77 * enum cmb_format - types of supported measurement block formats
78 *
79 * @CMF_BASIC: traditional channel measurement blocks supported
80 * by all machines that we run on
81 * @CMF_EXTENDED: improved format that was introduced with the z990
82 * machine
83 * @CMF_AUTODETECT: default: use extended format when running on a machine
84 * supporting extended format, otherwise fall back to
85 * basic format
86 */
87enum cmb_format {
88 CMF_BASIC,
89 CMF_EXTENDED,
90 CMF_AUTODETECT = -1,
91};
92
93/*
94 * format - actual format for all measurement blocks
95 *
96 * The format module parameter can be set to a value of 0 (zero)
97 * or 1, indicating basic or extended format as described for
98 * enum cmb_format.
99 */
100static int format = CMF_AUTODETECT;
101module_param(format, bool, 0444);
102
103/**
104 * struct cmb_operations - functions to use depending on cmb_format
105 *
106 * Most of these functions operate on a struct ccw_device. There is only
107 * one instance of struct cmb_operations because the format of the measurement
108 * data is guaranteed to be the same for every ccw_device.
109 *
110 * @alloc: allocate memory for a channel measurement block,
111 * either with the help of a special pool or with kmalloc
112 * @free: free memory allocated with @alloc
113 * @set: enable or disable measurement
114 * @read: read a measurement entry at an index
115 * @readall: read a measurement block in a common format
116 * @reset: clear the data in the associated measurement block and
117 * reset its time stamp
118 * @align: align an allocated block so that the hardware can use it
119 */
120struct cmb_operations {
121 int (*alloc) (struct ccw_device *);
122 void (*free) (struct ccw_device *);
123 int (*set) (struct ccw_device *, u32);
124 u64 (*read) (struct ccw_device *, int);
125 int (*readall)(struct ccw_device *, struct cmbdata *);
126 void (*reset) (struct ccw_device *);
127 void *(*align) (void *);
128/* private: */
129 struct attribute_group *attr_group;
130};
131static struct cmb_operations *cmbops;
132
133struct cmb_data {
134 void *hw_block; /* Pointer to block updated by hardware */
135 void *last_block; /* Last changed block copied from hardware block */
136 int size; /* Size of hw_block and last_block */
137 unsigned long long last_update; /* when last_block was updated */
138};
139
140/*
141 * Our user interface is designed in terms of nanoseconds,
142 * while the hardware measures total times in its own
143 * unit.
144 */
145static inline u64 time_to_nsec(u32 value)
146{
147 return ((u64)value) * 128000ull;
148}
149
150/*
151 * Users are usually interested in average times,
152 * not accumulated time.
153 * This also helps us with atomicity problems
154 * when reading sinlge values.
155 */
156static inline u64 time_to_avg_nsec(u32 value, u32 count)
157{
158 u64 ret;
159
160 /* no samples yet, avoid division by 0 */
161 if (count == 0)
162 return 0;
163
164 /* value comes in units of 128 µsec */
165 ret = time_to_nsec(value);
166 do_div(ret, count);
167
168 return ret;
169}
170
171/*
172 * Activate or deactivate the channel monitor. When area is NULL,
173 * the monitor is deactivated. The channel monitor needs to
174 * be active in order to measure subchannels, which also need
175 * to be enabled.
176 */
177static inline void cmf_activate(void *area, unsigned int onoff)
178{
179 register void * __gpr2 asm("2");
180 register long __gpr1 asm("1");
181
182 __gpr2 = area;
183 __gpr1 = onoff ? 2 : 0;
184 /* activate channel measurement */
185 asm("schm" : : "d" (__gpr2), "d" (__gpr1) );
186}
187
188static int set_schib(struct ccw_device *cdev, u32 mme, int mbfc,
189 unsigned long address)
190{
191 struct subchannel *sch;
192
193 sch = to_subchannel(cdev->dev.parent);
194
195 sch->config.mme = mme;
196 sch->config.mbfc = mbfc;
197 /* address can be either a block address or a block index */
198 if (mbfc)
199 sch->config.mba = address;
200 else
201 sch->config.mbi = address;
202
203 return cio_commit_config(sch);
204}
205
206struct set_schib_struct {
207 u32 mme;
208 int mbfc;
209 unsigned long address;
210 wait_queue_head_t wait;
211 int ret;
212 struct kref kref;
213};
214
215static void cmf_set_schib_release(struct kref *kref)
216{
217 struct set_schib_struct *set_data;
218
219 set_data = container_of(kref, struct set_schib_struct, kref);
220 kfree(set_data);
221}
222
223#define CMF_PENDING 1
224
225static int set_schib_wait(struct ccw_device *cdev, u32 mme,
226 int mbfc, unsigned long address)
227{
228 struct set_schib_struct *set_data;
229 int ret;
230
231 spin_lock_irq(cdev->ccwlock);
232 if (!cdev->private->cmb) {
233 ret = -ENODEV;
234 goto out;
235 }
236 set_data = kzalloc(sizeof(struct set_schib_struct), GFP_ATOMIC);
237 if (!set_data) {
238 ret = -ENOMEM;
239 goto out;
240 }
241 init_waitqueue_head(&set_data->wait);
242 kref_init(&set_data->kref);
243 set_data->mme = mme;
244 set_data->mbfc = mbfc;
245 set_data->address = address;
246
247 ret = set_schib(cdev, mme, mbfc, address);
248 if (ret != -EBUSY)
249 goto out_put;
250
251 if (cdev->private->state != DEV_STATE_ONLINE) {
252 /* if the device is not online, don't even try again */
253 ret = -EBUSY;
254 goto out_put;
255 }
256
257 cdev->private->state = DEV_STATE_CMFCHANGE;
258 set_data->ret = CMF_PENDING;
259 cdev->private->cmb_wait = set_data;
260
261 spin_unlock_irq(cdev->ccwlock);
262 if (wait_event_interruptible(set_data->wait,
263 set_data->ret != CMF_PENDING)) {
264 spin_lock_irq(cdev->ccwlock);
265 if (set_data->ret == CMF_PENDING) {
266 set_data->ret = -ERESTARTSYS;
267 if (cdev->private->state == DEV_STATE_CMFCHANGE)
268 cdev->private->state = DEV_STATE_ONLINE;
269 }
270 spin_unlock_irq(cdev->ccwlock);
271 }
272 spin_lock_irq(cdev->ccwlock);
273 cdev->private->cmb_wait = NULL;
274 ret = set_data->ret;
275out_put:
276 kref_put(&set_data->kref, cmf_set_schib_release);
277out:
278 spin_unlock_irq(cdev->ccwlock);
279 return ret;
280}
281
282void retry_set_schib(struct ccw_device *cdev)
283{
284 struct set_schib_struct *set_data;
285
286 set_data = cdev->private->cmb_wait;
287 if (!set_data) {
288 WARN_ON(1);
289 return;
290 }
291 kref_get(&set_data->kref);
292 set_data->ret = set_schib(cdev, set_data->mme, set_data->mbfc,
293 set_data->address);
294 wake_up(&set_data->wait);
295 kref_put(&set_data->kref, cmf_set_schib_release);
296}
297
298static int cmf_copy_block(struct ccw_device *cdev)
299{
300 struct subchannel *sch;
301 void *reference_buf;
302 void *hw_block;
303 struct cmb_data *cmb_data;
304
305 sch = to_subchannel(cdev->dev.parent);
306
307 if (cio_update_schib(sch))
308 return -ENODEV;
309
310 if (scsw_fctl(&sch->schib.scsw) & SCSW_FCTL_START_FUNC) {
311 /* Don't copy if a start function is in progress. */
312 if ((!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_SUSPENDED)) &&
313 (scsw_actl(&sch->schib.scsw) &
314 (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) &&
315 (!(scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_SEC_STATUS)))
316 return -EBUSY;
317 }
318 cmb_data = cdev->private->cmb;
319 hw_block = cmbops->align(cmb_data->hw_block);
320 if (!memcmp(cmb_data->last_block, hw_block, cmb_data->size))
321 /* No need to copy. */
322 return 0;
323 reference_buf = kzalloc(cmb_data->size, GFP_ATOMIC);
324 if (!reference_buf)
325 return -ENOMEM;
326 /* Ensure consistency of block copied from hardware. */
327 do {
328 memcpy(cmb_data->last_block, hw_block, cmb_data->size);
329 memcpy(reference_buf, hw_block, cmb_data->size);
330 } while (memcmp(cmb_data->last_block, reference_buf, cmb_data->size));
331 cmb_data->last_update = get_clock();
332 kfree(reference_buf);
333 return 0;
334}
335
336struct copy_block_struct {
337 wait_queue_head_t wait;
338 int ret;
339 struct kref kref;
340};
341
342static void cmf_copy_block_release(struct kref *kref)
343{
344 struct copy_block_struct *copy_block;
345
346 copy_block = container_of(kref, struct copy_block_struct, kref);
347 kfree(copy_block);
348}
349
350static int cmf_cmb_copy_wait(struct ccw_device *cdev)
351{
352 struct copy_block_struct *copy_block;
353 int ret;
354 unsigned long flags;
355
356 spin_lock_irqsave(cdev->ccwlock, flags);
357 if (!cdev->private->cmb) {
358 ret = -ENODEV;
359 goto out;
360 }
361 copy_block = kzalloc(sizeof(struct copy_block_struct), GFP_ATOMIC);
362 if (!copy_block) {
363 ret = -ENOMEM;
364 goto out;
365 }
366 init_waitqueue_head(©_block->wait);
367 kref_init(©_block->kref);
368
369 ret = cmf_copy_block(cdev);
370 if (ret != -EBUSY)
371 goto out_put;
372
373 if (cdev->private->state != DEV_STATE_ONLINE) {
374 ret = -EBUSY;
375 goto out_put;
376 }
377
378 cdev->private->state = DEV_STATE_CMFUPDATE;
379 copy_block->ret = CMF_PENDING;
380 cdev->private->cmb_wait = copy_block;
381
382 spin_unlock_irqrestore(cdev->ccwlock, flags);
383 if (wait_event_interruptible(copy_block->wait,
384 copy_block->ret != CMF_PENDING)) {
385 spin_lock_irqsave(cdev->ccwlock, flags);
386 if (copy_block->ret == CMF_PENDING) {
387 copy_block->ret = -ERESTARTSYS;
388 if (cdev->private->state == DEV_STATE_CMFUPDATE)
389 cdev->private->state = DEV_STATE_ONLINE;
390 }
391 spin_unlock_irqrestore(cdev->ccwlock, flags);
392 }
393 spin_lock_irqsave(cdev->ccwlock, flags);
394 cdev->private->cmb_wait = NULL;
395 ret = copy_block->ret;
396out_put:
397 kref_put(©_block->kref, cmf_copy_block_release);
398out:
399 spin_unlock_irqrestore(cdev->ccwlock, flags);
400 return ret;
401}
402
403void cmf_retry_copy_block(struct ccw_device *cdev)
404{
405 struct copy_block_struct *copy_block;
406
407 copy_block = cdev->private->cmb_wait;
408 if (!copy_block) {
409 WARN_ON(1);
410 return;
411 }
412 kref_get(©_block->kref);
413 copy_block->ret = cmf_copy_block(cdev);
414 wake_up(©_block->wait);
415 kref_put(©_block->kref, cmf_copy_block_release);
416}
417
418static void cmf_generic_reset(struct ccw_device *cdev)
419{
420 struct cmb_data *cmb_data;
421
422 spin_lock_irq(cdev->ccwlock);
423 cmb_data = cdev->private->cmb;
424 if (cmb_data) {
425 memset(cmb_data->last_block, 0, cmb_data->size);
426 /*
427 * Need to reset hw block as well to make the hardware start
428 * from 0 again.
429 */
430 memset(cmbops->align(cmb_data->hw_block), 0, cmb_data->size);
431 cmb_data->last_update = 0;
432 }
433 cdev->private->cmb_start_time = get_clock();
434 spin_unlock_irq(cdev->ccwlock);
435}
436
437/**
438 * struct cmb_area - container for global cmb data
439 *
440 * @mem: pointer to CMBs (only in basic measurement mode)
441 * @list: contains a linked list of all subchannels
442 * @num_channels: number of channels to be measured
443 * @lock: protect concurrent access to @mem and @list
444 */
445struct cmb_area {
446 struct cmb *mem;
447 struct list_head list;
448 int num_channels;
449 spinlock_t lock;
450};
451
452static struct cmb_area cmb_area = {
453 .lock = __SPIN_LOCK_UNLOCKED(cmb_area.lock),
454 .list = LIST_HEAD_INIT(cmb_area.list),
455 .num_channels = 1024,
456};
457
458/* ****** old style CMB handling ********/
459
460/*
461 * Basic channel measurement blocks are allocated in one contiguous
462 * block of memory, which can not be moved as long as any channel
463 * is active. Therefore, a maximum number of subchannels needs to
464 * be defined somewhere. This is a module parameter, defaulting to
465 * a reasonable value of 1024, or 32 kb of memory.
466 * Current kernels don't allow kmalloc with more than 128kb, so the
467 * maximum is 4096.
468 */
469
470module_param_named(maxchannels, cmb_area.num_channels, uint, 0444);
471
472/**
473 * struct cmb - basic channel measurement block
474 * @ssch_rsch_count: number of ssch and rsch
475 * @sample_count: number of samples
476 * @device_connect_time: time of device connect
477 * @function_pending_time: time of function pending
478 * @device_disconnect_time: time of device disconnect
479 * @control_unit_queuing_time: time of control unit queuing
480 * @device_active_only_time: time of device active only
481 * @reserved: unused in basic measurement mode
482 *
483 * The measurement block as used by the hardware. The fields are described
484 * further in z/Architecture Principles of Operation, chapter 17.
485 *
486 * The cmb area made up from these blocks must be a contiguous array and may
487 * not be reallocated or freed.
488 * Only one cmb area can be present in the system.
489 */
490struct cmb {
491 u16 ssch_rsch_count;
492 u16 sample_count;
493 u32 device_connect_time;
494 u32 function_pending_time;
495 u32 device_disconnect_time;
496 u32 control_unit_queuing_time;
497 u32 device_active_only_time;
498 u32 reserved[2];
499};
500
501/*
502 * Insert a single device into the cmb_area list.
503 * Called with cmb_area.lock held from alloc_cmb.
504 */
505static int alloc_cmb_single(struct ccw_device *cdev,
506 struct cmb_data *cmb_data)
507{
508 struct cmb *cmb;
509 struct ccw_device_private *node;
510 int ret;
511
512 spin_lock_irq(cdev->ccwlock);
513 if (!list_empty(&cdev->private->cmb_list)) {
514 ret = -EBUSY;
515 goto out;
516 }
517
518 /*
519 * Find first unused cmb in cmb_area.mem.
520 * This is a little tricky: cmb_area.list
521 * remains sorted by ->cmb->hw_data pointers.
522 */
523 cmb = cmb_area.mem;
524 list_for_each_entry(node, &cmb_area.list, cmb_list) {
525 struct cmb_data *data;
526 data = node->cmb;
527 if ((struct cmb*)data->hw_block > cmb)
528 break;
529 cmb++;
530 }
531 if (cmb - cmb_area.mem >= cmb_area.num_channels) {
532 ret = -ENOMEM;
533 goto out;
534 }
535
536 /* insert new cmb */
537 list_add_tail(&cdev->private->cmb_list, &node->cmb_list);
538 cmb_data->hw_block = cmb;
539 cdev->private->cmb = cmb_data;
540 ret = 0;
541out:
542 spin_unlock_irq(cdev->ccwlock);
543 return ret;
544}
545
546static int alloc_cmb(struct ccw_device *cdev)
547{
548 int ret;
549 struct cmb *mem;
550 ssize_t size;
551 struct cmb_data *cmb_data;
552
553 /* Allocate private cmb_data. */
554 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
555 if (!cmb_data)
556 return -ENOMEM;
557
558 cmb_data->last_block = kzalloc(sizeof(struct cmb), GFP_KERNEL);
559 if (!cmb_data->last_block) {
560 kfree(cmb_data);
561 return -ENOMEM;
562 }
563 cmb_data->size = sizeof(struct cmb);
564 spin_lock(&cmb_area.lock);
565
566 if (!cmb_area.mem) {
567 /* there is no user yet, so we need a new area */
568 size = sizeof(struct cmb) * cmb_area.num_channels;
569 WARN_ON(!list_empty(&cmb_area.list));
570
571 spin_unlock(&cmb_area.lock);
572 mem = (void*)__get_free_pages(GFP_KERNEL | GFP_DMA,
573 get_order(size));
574 spin_lock(&cmb_area.lock);
575
576 if (cmb_area.mem) {
577 /* ok, another thread was faster */
578 free_pages((unsigned long)mem, get_order(size));
579 } else if (!mem) {
580 /* no luck */
581 ret = -ENOMEM;
582 goto out;
583 } else {
584 /* everything ok */
585 memset(mem, 0, size);
586 cmb_area.mem = mem;
587 cmf_activate(cmb_area.mem, 1);
588 }
589 }
590
591 /* do the actual allocation */
592 ret = alloc_cmb_single(cdev, cmb_data);
593out:
594 spin_unlock(&cmb_area.lock);
595 if (ret) {
596 kfree(cmb_data->last_block);
597 kfree(cmb_data);
598 }
599 return ret;
600}
601
602static void free_cmb(struct ccw_device *cdev)
603{
604 struct ccw_device_private *priv;
605 struct cmb_data *cmb_data;
606
607 spin_lock(&cmb_area.lock);
608 spin_lock_irq(cdev->ccwlock);
609
610 priv = cdev->private;
611
612 if (list_empty(&priv->cmb_list)) {
613 /* already freed */
614 goto out;
615 }
616
617 cmb_data = priv->cmb;
618 priv->cmb = NULL;
619 if (cmb_data)
620 kfree(cmb_data->last_block);
621 kfree(cmb_data);
622 list_del_init(&priv->cmb_list);
623
624 if (list_empty(&cmb_area.list)) {
625 ssize_t size;
626 size = sizeof(struct cmb) * cmb_area.num_channels;
627 cmf_activate(NULL, 0);
628 free_pages((unsigned long)cmb_area.mem, get_order(size));
629 cmb_area.mem = NULL;
630 }
631out:
632 spin_unlock_irq(cdev->ccwlock);
633 spin_unlock(&cmb_area.lock);
634}
635
636static int set_cmb(struct ccw_device *cdev, u32 mme)
637{
638 u16 offset;
639 struct cmb_data *cmb_data;
640 unsigned long flags;
641
642 spin_lock_irqsave(cdev->ccwlock, flags);
643 if (!cdev->private->cmb) {
644 spin_unlock_irqrestore(cdev->ccwlock, flags);
645 return -EINVAL;
646 }
647 cmb_data = cdev->private->cmb;
648 offset = mme ? (struct cmb *)cmb_data->hw_block - cmb_area.mem : 0;
649 spin_unlock_irqrestore(cdev->ccwlock, flags);
650
651 return set_schib_wait(cdev, mme, 0, offset);
652}
653
654static u64 read_cmb(struct ccw_device *cdev, int index)
655{
656 struct cmb *cmb;
657 u32 val;
658 int ret;
659 unsigned long flags;
660
661 ret = cmf_cmb_copy_wait(cdev);
662 if (ret < 0)
663 return 0;
664
665 spin_lock_irqsave(cdev->ccwlock, flags);
666 if (!cdev->private->cmb) {
667 ret = 0;
668 goto out;
669 }
670 cmb = ((struct cmb_data *)cdev->private->cmb)->last_block;
671
672 switch (index) {
673 case cmb_ssch_rsch_count:
674 ret = cmb->ssch_rsch_count;
675 goto out;
676 case cmb_sample_count:
677 ret = cmb->sample_count;
678 goto out;
679 case cmb_device_connect_time:
680 val = cmb->device_connect_time;
681 break;
682 case cmb_function_pending_time:
683 val = cmb->function_pending_time;
684 break;
685 case cmb_device_disconnect_time:
686 val = cmb->device_disconnect_time;
687 break;
688 case cmb_control_unit_queuing_time:
689 val = cmb->control_unit_queuing_time;
690 break;
691 case cmb_device_active_only_time:
692 val = cmb->device_active_only_time;
693 break;
694 default:
695 ret = 0;
696 goto out;
697 }
698 ret = time_to_avg_nsec(val, cmb->sample_count);
699out:
700 spin_unlock_irqrestore(cdev->ccwlock, flags);
701 return ret;
702}
703
704static int readall_cmb(struct ccw_device *cdev, struct cmbdata *data)
705{
706 struct cmb *cmb;
707 struct cmb_data *cmb_data;
708 u64 time;
709 unsigned long flags;
710 int ret;
711
712 ret = cmf_cmb_copy_wait(cdev);
713 if (ret < 0)
714 return ret;
715 spin_lock_irqsave(cdev->ccwlock, flags);
716 cmb_data = cdev->private->cmb;
717 if (!cmb_data) {
718 ret = -ENODEV;
719 goto out;
720 }
721 if (cmb_data->last_update == 0) {
722 ret = -EAGAIN;
723 goto out;
724 }
725 cmb = cmb_data->last_block;
726 time = cmb_data->last_update - cdev->private->cmb_start_time;
727
728 memset(data, 0, sizeof(struct cmbdata));
729
730 /* we only know values before device_busy_time */
731 data->size = offsetof(struct cmbdata, device_busy_time);
732
733 /* convert to nanoseconds */
734 data->elapsed_time = (time * 1000) >> 12;
735
736 /* copy data to new structure */
737 data->ssch_rsch_count = cmb->ssch_rsch_count;
738 data->sample_count = cmb->sample_count;
739
740 /* time fields are converted to nanoseconds while copying */
741 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
742 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
743 data->device_disconnect_time =
744 time_to_nsec(cmb->device_disconnect_time);
745 data->control_unit_queuing_time
746 = time_to_nsec(cmb->control_unit_queuing_time);
747 data->device_active_only_time
748 = time_to_nsec(cmb->device_active_only_time);
749 ret = 0;
750out:
751 spin_unlock_irqrestore(cdev->ccwlock, flags);
752 return ret;
753}
754
755static void reset_cmb(struct ccw_device *cdev)
756{
757 cmf_generic_reset(cdev);
758}
759
760static void * align_cmb(void *area)
761{
762 return area;
763}
764
765static struct attribute_group cmf_attr_group;
766
767static struct cmb_operations cmbops_basic = {
768 .alloc = alloc_cmb,
769 .free = free_cmb,
770 .set = set_cmb,
771 .read = read_cmb,
772 .readall = readall_cmb,
773 .reset = reset_cmb,
774 .align = align_cmb,
775 .attr_group = &cmf_attr_group,
776};
777
778/* ******** extended cmb handling ********/
779
780/**
781 * struct cmbe - extended channel measurement block
782 * @ssch_rsch_count: number of ssch and rsch
783 * @sample_count: number of samples
784 * @device_connect_time: time of device connect
785 * @function_pending_time: time of function pending
786 * @device_disconnect_time: time of device disconnect
787 * @control_unit_queuing_time: time of control unit queuing
788 * @device_active_only_time: time of device active only
789 * @device_busy_time: time of device busy
790 * @initial_command_response_time: initial command response time
791 * @reserved: unused
792 *
793 * The measurement block as used by the hardware. May be in any 64 bit physical
794 * location.
795 * The fields are described further in z/Architecture Principles of Operation,
796 * third edition, chapter 17.
797 */
798struct cmbe {
799 u32 ssch_rsch_count;
800 u32 sample_count;
801 u32 device_connect_time;
802 u32 function_pending_time;
803 u32 device_disconnect_time;
804 u32 control_unit_queuing_time;
805 u32 device_active_only_time;
806 u32 device_busy_time;
807 u32 initial_command_response_time;
808 u32 reserved[7];
809};
810
811/*
812 * kmalloc only guarantees 8 byte alignment, but we need cmbe
813 * pointers to be naturally aligned. Make sure to allocate
814 * enough space for two cmbes.
815 */
816static inline struct cmbe *cmbe_align(struct cmbe *c)
817{
818 unsigned long addr;
819 addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
820 ~(sizeof (struct cmbe) - sizeof(long));
821 return (struct cmbe*)addr;
822}
823
824static int alloc_cmbe(struct ccw_device *cdev)
825{
826 struct cmbe *cmbe;
827 struct cmb_data *cmb_data;
828 int ret;
829
830 cmbe = kzalloc (sizeof (*cmbe) * 2, GFP_KERNEL);
831 if (!cmbe)
832 return -ENOMEM;
833 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
834 if (!cmb_data) {
835 ret = -ENOMEM;
836 goto out_free;
837 }
838 cmb_data->last_block = kzalloc(sizeof(struct cmbe), GFP_KERNEL);
839 if (!cmb_data->last_block) {
840 ret = -ENOMEM;
841 goto out_free;
842 }
843 cmb_data->size = sizeof(struct cmbe);
844 spin_lock_irq(cdev->ccwlock);
845 if (cdev->private->cmb) {
846 spin_unlock_irq(cdev->ccwlock);
847 ret = -EBUSY;
848 goto out_free;
849 }
850 cmb_data->hw_block = cmbe;
851 cdev->private->cmb = cmb_data;
852 spin_unlock_irq(cdev->ccwlock);
853
854 /* activate global measurement if this is the first channel */
855 spin_lock(&cmb_area.lock);
856 if (list_empty(&cmb_area.list))
857 cmf_activate(NULL, 1);
858 list_add_tail(&cdev->private->cmb_list, &cmb_area.list);
859 spin_unlock(&cmb_area.lock);
860
861 return 0;
862out_free:
863 if (cmb_data)
864 kfree(cmb_data->last_block);
865 kfree(cmb_data);
866 kfree(cmbe);
867 return ret;
868}
869
870static void free_cmbe(struct ccw_device *cdev)
871{
872 struct cmb_data *cmb_data;
873
874 spin_lock_irq(cdev->ccwlock);
875 cmb_data = cdev->private->cmb;
876 cdev->private->cmb = NULL;
877 if (cmb_data)
878 kfree(cmb_data->last_block);
879 kfree(cmb_data);
880 spin_unlock_irq(cdev->ccwlock);
881
882 /* deactivate global measurement if this is the last channel */
883 spin_lock(&cmb_area.lock);
884 list_del_init(&cdev->private->cmb_list);
885 if (list_empty(&cmb_area.list))
886 cmf_activate(NULL, 0);
887 spin_unlock(&cmb_area.lock);
888}
889
890static int set_cmbe(struct ccw_device *cdev, u32 mme)
891{
892 unsigned long mba;
893 struct cmb_data *cmb_data;
894 unsigned long flags;
895
896 spin_lock_irqsave(cdev->ccwlock, flags);
897 if (!cdev->private->cmb) {
898 spin_unlock_irqrestore(cdev->ccwlock, flags);
899 return -EINVAL;
900 }
901 cmb_data = cdev->private->cmb;
902 mba = mme ? (unsigned long) cmbe_align(cmb_data->hw_block) : 0;
903 spin_unlock_irqrestore(cdev->ccwlock, flags);
904
905 return set_schib_wait(cdev, mme, 1, mba);
906}
907
908
909static u64 read_cmbe(struct ccw_device *cdev, int index)
910{
911 struct cmbe *cmb;
912 struct cmb_data *cmb_data;
913 u32 val;
914 int ret;
915 unsigned long flags;
916
917 ret = cmf_cmb_copy_wait(cdev);
918 if (ret < 0)
919 return 0;
920
921 spin_lock_irqsave(cdev->ccwlock, flags);
922 cmb_data = cdev->private->cmb;
923 if (!cmb_data) {
924 ret = 0;
925 goto out;
926 }
927 cmb = cmb_data->last_block;
928
929 switch (index) {
930 case cmb_ssch_rsch_count:
931 ret = cmb->ssch_rsch_count;
932 goto out;
933 case cmb_sample_count:
934 ret = cmb->sample_count;
935 goto out;
936 case cmb_device_connect_time:
937 val = cmb->device_connect_time;
938 break;
939 case cmb_function_pending_time:
940 val = cmb->function_pending_time;
941 break;
942 case cmb_device_disconnect_time:
943 val = cmb->device_disconnect_time;
944 break;
945 case cmb_control_unit_queuing_time:
946 val = cmb->control_unit_queuing_time;
947 break;
948 case cmb_device_active_only_time:
949 val = cmb->device_active_only_time;
950 break;
951 case cmb_device_busy_time:
952 val = cmb->device_busy_time;
953 break;
954 case cmb_initial_command_response_time:
955 val = cmb->initial_command_response_time;
956 break;
957 default:
958 ret = 0;
959 goto out;
960 }
961 ret = time_to_avg_nsec(val, cmb->sample_count);
962out:
963 spin_unlock_irqrestore(cdev->ccwlock, flags);
964 return ret;
965}
966
967static int readall_cmbe(struct ccw_device *cdev, struct cmbdata *data)
968{
969 struct cmbe *cmb;
970 struct cmb_data *cmb_data;
971 u64 time;
972 unsigned long flags;
973 int ret;
974
975 ret = cmf_cmb_copy_wait(cdev);
976 if (ret < 0)
977 return ret;
978 spin_lock_irqsave(cdev->ccwlock, flags);
979 cmb_data = cdev->private->cmb;
980 if (!cmb_data) {
981 ret = -ENODEV;
982 goto out;
983 }
984 if (cmb_data->last_update == 0) {
985 ret = -EAGAIN;
986 goto out;
987 }
988 time = cmb_data->last_update - cdev->private->cmb_start_time;
989
990 memset (data, 0, sizeof(struct cmbdata));
991
992 /* we only know values before device_busy_time */
993 data->size = offsetof(struct cmbdata, device_busy_time);
994
995 /* conver to nanoseconds */
996 data->elapsed_time = (time * 1000) >> 12;
997
998 cmb = cmb_data->last_block;
999 /* copy data to new structure */
1000 data->ssch_rsch_count = cmb->ssch_rsch_count;
1001 data->sample_count = cmb->sample_count;
1002
1003 /* time fields are converted to nanoseconds while copying */
1004 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
1005 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
1006 data->device_disconnect_time =
1007 time_to_nsec(cmb->device_disconnect_time);
1008 data->control_unit_queuing_time
1009 = time_to_nsec(cmb->control_unit_queuing_time);
1010 data->device_active_only_time
1011 = time_to_nsec(cmb->device_active_only_time);
1012 data->device_busy_time = time_to_nsec(cmb->device_busy_time);
1013 data->initial_command_response_time
1014 = time_to_nsec(cmb->initial_command_response_time);
1015
1016 ret = 0;
1017out:
1018 spin_unlock_irqrestore(cdev->ccwlock, flags);
1019 return ret;
1020}
1021
1022static void reset_cmbe(struct ccw_device *cdev)
1023{
1024 cmf_generic_reset(cdev);
1025}
1026
1027static void * align_cmbe(void *area)
1028{
1029 return cmbe_align(area);
1030}
1031
1032static struct attribute_group cmf_attr_group_ext;
1033
1034static struct cmb_operations cmbops_extended = {
1035 .alloc = alloc_cmbe,
1036 .free = free_cmbe,
1037 .set = set_cmbe,
1038 .read = read_cmbe,
1039 .readall = readall_cmbe,
1040 .reset = reset_cmbe,
1041 .align = align_cmbe,
1042 .attr_group = &cmf_attr_group_ext,
1043};
1044
1045static ssize_t cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
1046{
1047 return sprintf(buf, "%lld\n",
1048 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
1049}
1050
1051static ssize_t cmb_show_avg_sample_interval(struct device *dev,
1052 struct device_attribute *attr,
1053 char *buf)
1054{
1055 struct ccw_device *cdev;
1056 long interval;
1057 unsigned long count;
1058 struct cmb_data *cmb_data;
1059
1060 cdev = to_ccwdev(dev);
1061 count = cmf_read(cdev, cmb_sample_count);
1062 spin_lock_irq(cdev->ccwlock);
1063 cmb_data = cdev->private->cmb;
1064 if (count) {
1065 interval = cmb_data->last_update -
1066 cdev->private->cmb_start_time;
1067 interval = (interval * 1000) >> 12;
1068 interval /= count;
1069 } else
1070 interval = -1;
1071 spin_unlock_irq(cdev->ccwlock);
1072 return sprintf(buf, "%ld\n", interval);
1073}
1074
1075static ssize_t cmb_show_avg_utilization(struct device *dev,
1076 struct device_attribute *attr,
1077 char *buf)
1078{
1079 struct cmbdata data;
1080 u64 utilization;
1081 unsigned long t, u;
1082 int ret;
1083
1084 ret = cmf_readall(to_ccwdev(dev), &data);
1085 if (ret == -EAGAIN || ret == -ENODEV)
1086 /* No data (yet/currently) available to use for calculation. */
1087 return sprintf(buf, "n/a\n");
1088 else if (ret)
1089 return ret;
1090
1091 utilization = data.device_connect_time +
1092 data.function_pending_time +
1093 data.device_disconnect_time;
1094
1095 /* shift to avoid long long division */
1096 while (-1ul < (data.elapsed_time | utilization)) {
1097 utilization >>= 8;
1098 data.elapsed_time >>= 8;
1099 }
1100
1101 /* calculate value in 0.1 percent units */
1102 t = (unsigned long) data.elapsed_time / 1000;
1103 u = (unsigned long) utilization / t;
1104
1105 return sprintf(buf, "%02ld.%01ld%%\n", u/ 10, u - (u/ 10) * 10);
1106}
1107
1108#define cmf_attr(name) \
1109static ssize_t show_##name(struct device *dev, \
1110 struct device_attribute *attr, char *buf) \
1111{ return cmb_show_attr((dev), buf, cmb_##name); } \
1112static DEVICE_ATTR(name, 0444, show_##name, NULL);
1113
1114#define cmf_attr_avg(name) \
1115static ssize_t show_avg_##name(struct device *dev, \
1116 struct device_attribute *attr, char *buf) \
1117{ return cmb_show_attr((dev), buf, cmb_##name); } \
1118static DEVICE_ATTR(avg_##name, 0444, show_avg_##name, NULL);
1119
1120cmf_attr(ssch_rsch_count);
1121cmf_attr(sample_count);
1122cmf_attr_avg(device_connect_time);
1123cmf_attr_avg(function_pending_time);
1124cmf_attr_avg(device_disconnect_time);
1125cmf_attr_avg(control_unit_queuing_time);
1126cmf_attr_avg(device_active_only_time);
1127cmf_attr_avg(device_busy_time);
1128cmf_attr_avg(initial_command_response_time);
1129
1130static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval,
1131 NULL);
1132static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
1133
1134static struct attribute *cmf_attributes[] = {
1135 &dev_attr_avg_sample_interval.attr,
1136 &dev_attr_avg_utilization.attr,
1137 &dev_attr_ssch_rsch_count.attr,
1138 &dev_attr_sample_count.attr,
1139 &dev_attr_avg_device_connect_time.attr,
1140 &dev_attr_avg_function_pending_time.attr,
1141 &dev_attr_avg_device_disconnect_time.attr,
1142 &dev_attr_avg_control_unit_queuing_time.attr,
1143 &dev_attr_avg_device_active_only_time.attr,
1144 NULL,
1145};
1146
1147static struct attribute_group cmf_attr_group = {
1148 .name = "cmf",
1149 .attrs = cmf_attributes,
1150};
1151
1152static struct attribute *cmf_attributes_ext[] = {
1153 &dev_attr_avg_sample_interval.attr,
1154 &dev_attr_avg_utilization.attr,
1155 &dev_attr_ssch_rsch_count.attr,
1156 &dev_attr_sample_count.attr,
1157 &dev_attr_avg_device_connect_time.attr,
1158 &dev_attr_avg_function_pending_time.attr,
1159 &dev_attr_avg_device_disconnect_time.attr,
1160 &dev_attr_avg_control_unit_queuing_time.attr,
1161 &dev_attr_avg_device_active_only_time.attr,
1162 &dev_attr_avg_device_busy_time.attr,
1163 &dev_attr_avg_initial_command_response_time.attr,
1164 NULL,
1165};
1166
1167static struct attribute_group cmf_attr_group_ext = {
1168 .name = "cmf",
1169 .attrs = cmf_attributes_ext,
1170};
1171
1172static ssize_t cmb_enable_show(struct device *dev,
1173 struct device_attribute *attr,
1174 char *buf)
1175{
1176 return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
1177}
1178
1179static ssize_t cmb_enable_store(struct device *dev,
1180 struct device_attribute *attr, const char *buf,
1181 size_t c)
1182{
1183 struct ccw_device *cdev;
1184 int ret;
1185 unsigned long val;
1186
1187 ret = strict_strtoul(buf, 16, &val);
1188 if (ret)
1189 return ret;
1190
1191 cdev = to_ccwdev(dev);
1192
1193 switch (val) {
1194 case 0:
1195 ret = disable_cmf(cdev);
1196 break;
1197 case 1:
1198 ret = enable_cmf(cdev);
1199 break;
1200 }
1201
1202 return c;
1203}
1204
1205DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
1206
1207int ccw_set_cmf(struct ccw_device *cdev, int enable)
1208{
1209 return cmbops->set(cdev, enable ? 2 : 0);
1210}
1211
1212/**
1213 * enable_cmf() - switch on the channel measurement for a specific device
1214 * @cdev: The ccw device to be enabled
1215 *
1216 * Returns %0 for success or a negative error value.
1217 *
1218 * Context:
1219 * non-atomic
1220 */
1221int enable_cmf(struct ccw_device *cdev)
1222{
1223 int ret;
1224
1225 ret = cmbops->alloc(cdev);
1226 cmbops->reset(cdev);
1227 if (ret)
1228 return ret;
1229 ret = cmbops->set(cdev, 2);
1230 if (ret) {
1231 cmbops->free(cdev);
1232 return ret;
1233 }
1234 ret = sysfs_create_group(&cdev->dev.kobj, cmbops->attr_group);
1235 if (!ret)
1236 return 0;
1237 cmbops->set(cdev, 0); //FIXME: this can fail
1238 cmbops->free(cdev);
1239 return ret;
1240}
1241
1242/**
1243 * disable_cmf() - switch off the channel measurement for a specific device
1244 * @cdev: The ccw device to be disabled
1245 *
1246 * Returns %0 for success or a negative error value.
1247 *
1248 * Context:
1249 * non-atomic
1250 */
1251int disable_cmf(struct ccw_device *cdev)
1252{
1253 int ret;
1254
1255 ret = cmbops->set(cdev, 0);
1256 if (ret)
1257 return ret;
1258 cmbops->free(cdev);
1259 sysfs_remove_group(&cdev->dev.kobj, cmbops->attr_group);
1260 return ret;
1261}
1262
1263/**
1264 * cmf_read() - read one value from the current channel measurement block
1265 * @cdev: the channel to be read
1266 * @index: the index of the value to be read
1267 *
1268 * Returns the value read or %0 if the value cannot be read.
1269 *
1270 * Context:
1271 * any
1272 */
1273u64 cmf_read(struct ccw_device *cdev, int index)
1274{
1275 return cmbops->read(cdev, index);
1276}
1277
1278/**
1279 * cmf_readall() - read the current channel measurement block
1280 * @cdev: the channel to be read
1281 * @data: a pointer to a data block that will be filled
1282 *
1283 * Returns %0 on success, a negative error value otherwise.
1284 *
1285 * Context:
1286 * any
1287 */
1288int cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
1289{
1290 return cmbops->readall(cdev, data);
1291}
1292
1293/* Reenable cmf when a disconnected device becomes available again. */
1294int cmf_reenable(struct ccw_device *cdev)
1295{
1296 cmbops->reset(cdev);
1297 return cmbops->set(cdev, 2);
1298}
1299
1300static int __init init_cmf(void)
1301{
1302 char *format_string;
1303 char *detect_string = "parameter";
1304
1305 /*
1306 * If the user did not give a parameter, see if we are running on a
1307 * machine supporting extended measurement blocks, otherwise fall back
1308 * to basic mode.
1309 */
1310 if (format == CMF_AUTODETECT) {
1311 if (!css_general_characteristics.ext_mb) {
1312 format = CMF_BASIC;
1313 } else {
1314 format = CMF_EXTENDED;
1315 }
1316 detect_string = "autodetected";
1317 } else {
1318 detect_string = "parameter";
1319 }
1320
1321 switch (format) {
1322 case CMF_BASIC:
1323 format_string = "basic";
1324 cmbops = &cmbops_basic;
1325 break;
1326 case CMF_EXTENDED:
1327 format_string = "extended";
1328 cmbops = &cmbops_extended;
1329 break;
1330 default:
1331 return 1;
1332 }
1333 pr_info("Channel measurement facility initialized using format "
1334 "%s (mode %s)\n", format_string, detect_string);
1335 return 0;
1336}
1337
1338module_init(init_cmf);
1339
1340
1341MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
1342MODULE_LICENSE("GPL");
1343MODULE_DESCRIPTION("channel measurement facility base driver\n"
1344 "Copyright 2003 IBM Corporation\n");
1345
1346EXPORT_SYMBOL_GPL(enable_cmf);
1347EXPORT_SYMBOL_GPL(disable_cmf);
1348EXPORT_SYMBOL_GPL(cmf_read);
1349EXPORT_SYMBOL_GPL(cmf_readall);
1/*
2 * Linux on zSeries Channel Measurement Facility support
3 *
4 * Copyright IBM Corp. 2000, 2006
5 *
6 * Authors: Arnd Bergmann <arndb@de.ibm.com>
7 * Cornelia Huck <cornelia.huck@de.ibm.com>
8 *
9 * original idea from Natarajan Krishnaswami <nkrishna@us.ibm.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26#define KMSG_COMPONENT "cio"
27#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
28
29#include <linux/bootmem.h>
30#include <linux/device.h>
31#include <linux/init.h>
32#include <linux/list.h>
33#include <linux/module.h>
34#include <linux/moduleparam.h>
35#include <linux/slab.h>
36#include <linux/timex.h> /* get_tod_clock() */
37
38#include <asm/ccwdev.h>
39#include <asm/cio.h>
40#include <asm/cmb.h>
41#include <asm/div64.h>
42
43#include "cio.h"
44#include "css.h"
45#include "device.h"
46#include "ioasm.h"
47#include "chsc.h"
48
49/*
50 * parameter to enable cmf during boot, possible uses are:
51 * "s390cmf" -- enable cmf and allocate 2 MB of ram so measuring can be
52 * used on any subchannel
53 * "s390cmf=<num>" -- enable cmf and allocate enough memory to measure
54 * <num> subchannel, where <num> is an integer
55 * between 1 and 65535, default is 1024
56 */
57#define ARGSTRING "s390cmf"
58
59/* indices for READCMB */
60enum cmb_index {
61 /* basic and exended format: */
62 cmb_ssch_rsch_count,
63 cmb_sample_count,
64 cmb_device_connect_time,
65 cmb_function_pending_time,
66 cmb_device_disconnect_time,
67 cmb_control_unit_queuing_time,
68 cmb_device_active_only_time,
69 /* extended format only: */
70 cmb_device_busy_time,
71 cmb_initial_command_response_time,
72};
73
74/**
75 * enum cmb_format - types of supported measurement block formats
76 *
77 * @CMF_BASIC: traditional channel measurement blocks supported
78 * by all machines that we run on
79 * @CMF_EXTENDED: improved format that was introduced with the z990
80 * machine
81 * @CMF_AUTODETECT: default: use extended format when running on a machine
82 * supporting extended format, otherwise fall back to
83 * basic format
84 */
85enum cmb_format {
86 CMF_BASIC,
87 CMF_EXTENDED,
88 CMF_AUTODETECT = -1,
89};
90
91/*
92 * format - actual format for all measurement blocks
93 *
94 * The format module parameter can be set to a value of 0 (zero)
95 * or 1, indicating basic or extended format as described for
96 * enum cmb_format.
97 */
98static int format = CMF_AUTODETECT;
99module_param(format, bint, 0444);
100
101/**
102 * struct cmb_operations - functions to use depending on cmb_format
103 *
104 * Most of these functions operate on a struct ccw_device. There is only
105 * one instance of struct cmb_operations because the format of the measurement
106 * data is guaranteed to be the same for every ccw_device.
107 *
108 * @alloc: allocate memory for a channel measurement block,
109 * either with the help of a special pool or with kmalloc
110 * @free: free memory allocated with @alloc
111 * @set: enable or disable measurement
112 * @read: read a measurement entry at an index
113 * @readall: read a measurement block in a common format
114 * @reset: clear the data in the associated measurement block and
115 * reset its time stamp
116 * @align: align an allocated block so that the hardware can use it
117 */
118struct cmb_operations {
119 int (*alloc) (struct ccw_device *);
120 void (*free) (struct ccw_device *);
121 int (*set) (struct ccw_device *, u32);
122 u64 (*read) (struct ccw_device *, int);
123 int (*readall)(struct ccw_device *, struct cmbdata *);
124 void (*reset) (struct ccw_device *);
125 void *(*align) (void *);
126/* private: */
127 struct attribute_group *attr_group;
128};
129static struct cmb_operations *cmbops;
130
131struct cmb_data {
132 void *hw_block; /* Pointer to block updated by hardware */
133 void *last_block; /* Last changed block copied from hardware block */
134 int size; /* Size of hw_block and last_block */
135 unsigned long long last_update; /* when last_block was updated */
136};
137
138/*
139 * Our user interface is designed in terms of nanoseconds,
140 * while the hardware measures total times in its own
141 * unit.
142 */
143static inline u64 time_to_nsec(u32 value)
144{
145 return ((u64)value) * 128000ull;
146}
147
148/*
149 * Users are usually interested in average times,
150 * not accumulated time.
151 * This also helps us with atomicity problems
152 * when reading sinlge values.
153 */
154static inline u64 time_to_avg_nsec(u32 value, u32 count)
155{
156 u64 ret;
157
158 /* no samples yet, avoid division by 0 */
159 if (count == 0)
160 return 0;
161
162 /* value comes in units of 128 µsec */
163 ret = time_to_nsec(value);
164 do_div(ret, count);
165
166 return ret;
167}
168
169/*
170 * Activate or deactivate the channel monitor. When area is NULL,
171 * the monitor is deactivated. The channel monitor needs to
172 * be active in order to measure subchannels, which also need
173 * to be enabled.
174 */
175static inline void cmf_activate(void *area, unsigned int onoff)
176{
177 register void * __gpr2 asm("2");
178 register long __gpr1 asm("1");
179
180 __gpr2 = area;
181 __gpr1 = onoff ? 2 : 0;
182 /* activate channel measurement */
183 asm("schm" : : "d" (__gpr2), "d" (__gpr1) );
184}
185
186static int set_schib(struct ccw_device *cdev, u32 mme, int mbfc,
187 unsigned long address)
188{
189 struct subchannel *sch;
190
191 sch = to_subchannel(cdev->dev.parent);
192
193 sch->config.mme = mme;
194 sch->config.mbfc = mbfc;
195 /* address can be either a block address or a block index */
196 if (mbfc)
197 sch->config.mba = address;
198 else
199 sch->config.mbi = address;
200
201 return cio_commit_config(sch);
202}
203
204struct set_schib_struct {
205 u32 mme;
206 int mbfc;
207 unsigned long address;
208 wait_queue_head_t wait;
209 int ret;
210 struct kref kref;
211};
212
213static void cmf_set_schib_release(struct kref *kref)
214{
215 struct set_schib_struct *set_data;
216
217 set_data = container_of(kref, struct set_schib_struct, kref);
218 kfree(set_data);
219}
220
221#define CMF_PENDING 1
222
223static int set_schib_wait(struct ccw_device *cdev, u32 mme,
224 int mbfc, unsigned long address)
225{
226 struct set_schib_struct *set_data;
227 int ret;
228
229 spin_lock_irq(cdev->ccwlock);
230 if (!cdev->private->cmb) {
231 ret = -ENODEV;
232 goto out;
233 }
234 set_data = kzalloc(sizeof(struct set_schib_struct), GFP_ATOMIC);
235 if (!set_data) {
236 ret = -ENOMEM;
237 goto out;
238 }
239 init_waitqueue_head(&set_data->wait);
240 kref_init(&set_data->kref);
241 set_data->mme = mme;
242 set_data->mbfc = mbfc;
243 set_data->address = address;
244
245 ret = set_schib(cdev, mme, mbfc, address);
246 if (ret != -EBUSY)
247 goto out_put;
248
249 if (cdev->private->state != DEV_STATE_ONLINE) {
250 /* if the device is not online, don't even try again */
251 ret = -EBUSY;
252 goto out_put;
253 }
254
255 cdev->private->state = DEV_STATE_CMFCHANGE;
256 set_data->ret = CMF_PENDING;
257 cdev->private->cmb_wait = set_data;
258
259 spin_unlock_irq(cdev->ccwlock);
260 if (wait_event_interruptible(set_data->wait,
261 set_data->ret != CMF_PENDING)) {
262 spin_lock_irq(cdev->ccwlock);
263 if (set_data->ret == CMF_PENDING) {
264 set_data->ret = -ERESTARTSYS;
265 if (cdev->private->state == DEV_STATE_CMFCHANGE)
266 cdev->private->state = DEV_STATE_ONLINE;
267 }
268 spin_unlock_irq(cdev->ccwlock);
269 }
270 spin_lock_irq(cdev->ccwlock);
271 cdev->private->cmb_wait = NULL;
272 ret = set_data->ret;
273out_put:
274 kref_put(&set_data->kref, cmf_set_schib_release);
275out:
276 spin_unlock_irq(cdev->ccwlock);
277 return ret;
278}
279
280void retry_set_schib(struct ccw_device *cdev)
281{
282 struct set_schib_struct *set_data;
283
284 set_data = cdev->private->cmb_wait;
285 if (!set_data) {
286 WARN_ON(1);
287 return;
288 }
289 kref_get(&set_data->kref);
290 set_data->ret = set_schib(cdev, set_data->mme, set_data->mbfc,
291 set_data->address);
292 wake_up(&set_data->wait);
293 kref_put(&set_data->kref, cmf_set_schib_release);
294}
295
296static int cmf_copy_block(struct ccw_device *cdev)
297{
298 struct subchannel *sch;
299 void *reference_buf;
300 void *hw_block;
301 struct cmb_data *cmb_data;
302
303 sch = to_subchannel(cdev->dev.parent);
304
305 if (cio_update_schib(sch))
306 return -ENODEV;
307
308 if (scsw_fctl(&sch->schib.scsw) & SCSW_FCTL_START_FUNC) {
309 /* Don't copy if a start function is in progress. */
310 if ((!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_SUSPENDED)) &&
311 (scsw_actl(&sch->schib.scsw) &
312 (SCSW_ACTL_DEVACT | SCSW_ACTL_SCHACT)) &&
313 (!(scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_SEC_STATUS)))
314 return -EBUSY;
315 }
316 cmb_data = cdev->private->cmb;
317 hw_block = cmbops->align(cmb_data->hw_block);
318 if (!memcmp(cmb_data->last_block, hw_block, cmb_data->size))
319 /* No need to copy. */
320 return 0;
321 reference_buf = kzalloc(cmb_data->size, GFP_ATOMIC);
322 if (!reference_buf)
323 return -ENOMEM;
324 /* Ensure consistency of block copied from hardware. */
325 do {
326 memcpy(cmb_data->last_block, hw_block, cmb_data->size);
327 memcpy(reference_buf, hw_block, cmb_data->size);
328 } while (memcmp(cmb_data->last_block, reference_buf, cmb_data->size));
329 cmb_data->last_update = get_tod_clock();
330 kfree(reference_buf);
331 return 0;
332}
333
334struct copy_block_struct {
335 wait_queue_head_t wait;
336 int ret;
337 struct kref kref;
338};
339
340static void cmf_copy_block_release(struct kref *kref)
341{
342 struct copy_block_struct *copy_block;
343
344 copy_block = container_of(kref, struct copy_block_struct, kref);
345 kfree(copy_block);
346}
347
348static int cmf_cmb_copy_wait(struct ccw_device *cdev)
349{
350 struct copy_block_struct *copy_block;
351 int ret;
352 unsigned long flags;
353
354 spin_lock_irqsave(cdev->ccwlock, flags);
355 if (!cdev->private->cmb) {
356 ret = -ENODEV;
357 goto out;
358 }
359 copy_block = kzalloc(sizeof(struct copy_block_struct), GFP_ATOMIC);
360 if (!copy_block) {
361 ret = -ENOMEM;
362 goto out;
363 }
364 init_waitqueue_head(©_block->wait);
365 kref_init(©_block->kref);
366
367 ret = cmf_copy_block(cdev);
368 if (ret != -EBUSY)
369 goto out_put;
370
371 if (cdev->private->state != DEV_STATE_ONLINE) {
372 ret = -EBUSY;
373 goto out_put;
374 }
375
376 cdev->private->state = DEV_STATE_CMFUPDATE;
377 copy_block->ret = CMF_PENDING;
378 cdev->private->cmb_wait = copy_block;
379
380 spin_unlock_irqrestore(cdev->ccwlock, flags);
381 if (wait_event_interruptible(copy_block->wait,
382 copy_block->ret != CMF_PENDING)) {
383 spin_lock_irqsave(cdev->ccwlock, flags);
384 if (copy_block->ret == CMF_PENDING) {
385 copy_block->ret = -ERESTARTSYS;
386 if (cdev->private->state == DEV_STATE_CMFUPDATE)
387 cdev->private->state = DEV_STATE_ONLINE;
388 }
389 spin_unlock_irqrestore(cdev->ccwlock, flags);
390 }
391 spin_lock_irqsave(cdev->ccwlock, flags);
392 cdev->private->cmb_wait = NULL;
393 ret = copy_block->ret;
394out_put:
395 kref_put(©_block->kref, cmf_copy_block_release);
396out:
397 spin_unlock_irqrestore(cdev->ccwlock, flags);
398 return ret;
399}
400
401void cmf_retry_copy_block(struct ccw_device *cdev)
402{
403 struct copy_block_struct *copy_block;
404
405 copy_block = cdev->private->cmb_wait;
406 if (!copy_block) {
407 WARN_ON(1);
408 return;
409 }
410 kref_get(©_block->kref);
411 copy_block->ret = cmf_copy_block(cdev);
412 wake_up(©_block->wait);
413 kref_put(©_block->kref, cmf_copy_block_release);
414}
415
416static void cmf_generic_reset(struct ccw_device *cdev)
417{
418 struct cmb_data *cmb_data;
419
420 spin_lock_irq(cdev->ccwlock);
421 cmb_data = cdev->private->cmb;
422 if (cmb_data) {
423 memset(cmb_data->last_block, 0, cmb_data->size);
424 /*
425 * Need to reset hw block as well to make the hardware start
426 * from 0 again.
427 */
428 memset(cmbops->align(cmb_data->hw_block), 0, cmb_data->size);
429 cmb_data->last_update = 0;
430 }
431 cdev->private->cmb_start_time = get_tod_clock();
432 spin_unlock_irq(cdev->ccwlock);
433}
434
435/**
436 * struct cmb_area - container for global cmb data
437 *
438 * @mem: pointer to CMBs (only in basic measurement mode)
439 * @list: contains a linked list of all subchannels
440 * @num_channels: number of channels to be measured
441 * @lock: protect concurrent access to @mem and @list
442 */
443struct cmb_area {
444 struct cmb *mem;
445 struct list_head list;
446 int num_channels;
447 spinlock_t lock;
448};
449
450static struct cmb_area cmb_area = {
451 .lock = __SPIN_LOCK_UNLOCKED(cmb_area.lock),
452 .list = LIST_HEAD_INIT(cmb_area.list),
453 .num_channels = 1024,
454};
455
456/* ****** old style CMB handling ********/
457
458/*
459 * Basic channel measurement blocks are allocated in one contiguous
460 * block of memory, which can not be moved as long as any channel
461 * is active. Therefore, a maximum number of subchannels needs to
462 * be defined somewhere. This is a module parameter, defaulting to
463 * a reasonable value of 1024, or 32 kb of memory.
464 * Current kernels don't allow kmalloc with more than 128kb, so the
465 * maximum is 4096.
466 */
467
468module_param_named(maxchannels, cmb_area.num_channels, uint, 0444);
469
470/**
471 * struct cmb - basic channel measurement block
472 * @ssch_rsch_count: number of ssch and rsch
473 * @sample_count: number of samples
474 * @device_connect_time: time of device connect
475 * @function_pending_time: time of function pending
476 * @device_disconnect_time: time of device disconnect
477 * @control_unit_queuing_time: time of control unit queuing
478 * @device_active_only_time: time of device active only
479 * @reserved: unused in basic measurement mode
480 *
481 * The measurement block as used by the hardware. The fields are described
482 * further in z/Architecture Principles of Operation, chapter 17.
483 *
484 * The cmb area made up from these blocks must be a contiguous array and may
485 * not be reallocated or freed.
486 * Only one cmb area can be present in the system.
487 */
488struct cmb {
489 u16 ssch_rsch_count;
490 u16 sample_count;
491 u32 device_connect_time;
492 u32 function_pending_time;
493 u32 device_disconnect_time;
494 u32 control_unit_queuing_time;
495 u32 device_active_only_time;
496 u32 reserved[2];
497};
498
499/*
500 * Insert a single device into the cmb_area list.
501 * Called with cmb_area.lock held from alloc_cmb.
502 */
503static int alloc_cmb_single(struct ccw_device *cdev,
504 struct cmb_data *cmb_data)
505{
506 struct cmb *cmb;
507 struct ccw_device_private *node;
508 int ret;
509
510 spin_lock_irq(cdev->ccwlock);
511 if (!list_empty(&cdev->private->cmb_list)) {
512 ret = -EBUSY;
513 goto out;
514 }
515
516 /*
517 * Find first unused cmb in cmb_area.mem.
518 * This is a little tricky: cmb_area.list
519 * remains sorted by ->cmb->hw_data pointers.
520 */
521 cmb = cmb_area.mem;
522 list_for_each_entry(node, &cmb_area.list, cmb_list) {
523 struct cmb_data *data;
524 data = node->cmb;
525 if ((struct cmb*)data->hw_block > cmb)
526 break;
527 cmb++;
528 }
529 if (cmb - cmb_area.mem >= cmb_area.num_channels) {
530 ret = -ENOMEM;
531 goto out;
532 }
533
534 /* insert new cmb */
535 list_add_tail(&cdev->private->cmb_list, &node->cmb_list);
536 cmb_data->hw_block = cmb;
537 cdev->private->cmb = cmb_data;
538 ret = 0;
539out:
540 spin_unlock_irq(cdev->ccwlock);
541 return ret;
542}
543
544static int alloc_cmb(struct ccw_device *cdev)
545{
546 int ret;
547 struct cmb *mem;
548 ssize_t size;
549 struct cmb_data *cmb_data;
550
551 /* Allocate private cmb_data. */
552 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
553 if (!cmb_data)
554 return -ENOMEM;
555
556 cmb_data->last_block = kzalloc(sizeof(struct cmb), GFP_KERNEL);
557 if (!cmb_data->last_block) {
558 kfree(cmb_data);
559 return -ENOMEM;
560 }
561 cmb_data->size = sizeof(struct cmb);
562 spin_lock(&cmb_area.lock);
563
564 if (!cmb_area.mem) {
565 /* there is no user yet, so we need a new area */
566 size = sizeof(struct cmb) * cmb_area.num_channels;
567 WARN_ON(!list_empty(&cmb_area.list));
568
569 spin_unlock(&cmb_area.lock);
570 mem = (void*)__get_free_pages(GFP_KERNEL | GFP_DMA,
571 get_order(size));
572 spin_lock(&cmb_area.lock);
573
574 if (cmb_area.mem) {
575 /* ok, another thread was faster */
576 free_pages((unsigned long)mem, get_order(size));
577 } else if (!mem) {
578 /* no luck */
579 ret = -ENOMEM;
580 goto out;
581 } else {
582 /* everything ok */
583 memset(mem, 0, size);
584 cmb_area.mem = mem;
585 cmf_activate(cmb_area.mem, 1);
586 }
587 }
588
589 /* do the actual allocation */
590 ret = alloc_cmb_single(cdev, cmb_data);
591out:
592 spin_unlock(&cmb_area.lock);
593 if (ret) {
594 kfree(cmb_data->last_block);
595 kfree(cmb_data);
596 }
597 return ret;
598}
599
600static void free_cmb(struct ccw_device *cdev)
601{
602 struct ccw_device_private *priv;
603 struct cmb_data *cmb_data;
604
605 spin_lock(&cmb_area.lock);
606 spin_lock_irq(cdev->ccwlock);
607
608 priv = cdev->private;
609
610 if (list_empty(&priv->cmb_list)) {
611 /* already freed */
612 goto out;
613 }
614
615 cmb_data = priv->cmb;
616 priv->cmb = NULL;
617 if (cmb_data)
618 kfree(cmb_data->last_block);
619 kfree(cmb_data);
620 list_del_init(&priv->cmb_list);
621
622 if (list_empty(&cmb_area.list)) {
623 ssize_t size;
624 size = sizeof(struct cmb) * cmb_area.num_channels;
625 cmf_activate(NULL, 0);
626 free_pages((unsigned long)cmb_area.mem, get_order(size));
627 cmb_area.mem = NULL;
628 }
629out:
630 spin_unlock_irq(cdev->ccwlock);
631 spin_unlock(&cmb_area.lock);
632}
633
634static int set_cmb(struct ccw_device *cdev, u32 mme)
635{
636 u16 offset;
637 struct cmb_data *cmb_data;
638 unsigned long flags;
639
640 spin_lock_irqsave(cdev->ccwlock, flags);
641 if (!cdev->private->cmb) {
642 spin_unlock_irqrestore(cdev->ccwlock, flags);
643 return -EINVAL;
644 }
645 cmb_data = cdev->private->cmb;
646 offset = mme ? (struct cmb *)cmb_data->hw_block - cmb_area.mem : 0;
647 spin_unlock_irqrestore(cdev->ccwlock, flags);
648
649 return set_schib_wait(cdev, mme, 0, offset);
650}
651
652static u64 read_cmb(struct ccw_device *cdev, int index)
653{
654 struct cmb *cmb;
655 u32 val;
656 int ret;
657 unsigned long flags;
658
659 ret = cmf_cmb_copy_wait(cdev);
660 if (ret < 0)
661 return 0;
662
663 spin_lock_irqsave(cdev->ccwlock, flags);
664 if (!cdev->private->cmb) {
665 ret = 0;
666 goto out;
667 }
668 cmb = ((struct cmb_data *)cdev->private->cmb)->last_block;
669
670 switch (index) {
671 case cmb_ssch_rsch_count:
672 ret = cmb->ssch_rsch_count;
673 goto out;
674 case cmb_sample_count:
675 ret = cmb->sample_count;
676 goto out;
677 case cmb_device_connect_time:
678 val = cmb->device_connect_time;
679 break;
680 case cmb_function_pending_time:
681 val = cmb->function_pending_time;
682 break;
683 case cmb_device_disconnect_time:
684 val = cmb->device_disconnect_time;
685 break;
686 case cmb_control_unit_queuing_time:
687 val = cmb->control_unit_queuing_time;
688 break;
689 case cmb_device_active_only_time:
690 val = cmb->device_active_only_time;
691 break;
692 default:
693 ret = 0;
694 goto out;
695 }
696 ret = time_to_avg_nsec(val, cmb->sample_count);
697out:
698 spin_unlock_irqrestore(cdev->ccwlock, flags);
699 return ret;
700}
701
702static int readall_cmb(struct ccw_device *cdev, struct cmbdata *data)
703{
704 struct cmb *cmb;
705 struct cmb_data *cmb_data;
706 u64 time;
707 unsigned long flags;
708 int ret;
709
710 ret = cmf_cmb_copy_wait(cdev);
711 if (ret < 0)
712 return ret;
713 spin_lock_irqsave(cdev->ccwlock, flags);
714 cmb_data = cdev->private->cmb;
715 if (!cmb_data) {
716 ret = -ENODEV;
717 goto out;
718 }
719 if (cmb_data->last_update == 0) {
720 ret = -EAGAIN;
721 goto out;
722 }
723 cmb = cmb_data->last_block;
724 time = cmb_data->last_update - cdev->private->cmb_start_time;
725
726 memset(data, 0, sizeof(struct cmbdata));
727
728 /* we only know values before device_busy_time */
729 data->size = offsetof(struct cmbdata, device_busy_time);
730
731 /* convert to nanoseconds */
732 data->elapsed_time = (time * 1000) >> 12;
733
734 /* copy data to new structure */
735 data->ssch_rsch_count = cmb->ssch_rsch_count;
736 data->sample_count = cmb->sample_count;
737
738 /* time fields are converted to nanoseconds while copying */
739 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
740 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
741 data->device_disconnect_time =
742 time_to_nsec(cmb->device_disconnect_time);
743 data->control_unit_queuing_time
744 = time_to_nsec(cmb->control_unit_queuing_time);
745 data->device_active_only_time
746 = time_to_nsec(cmb->device_active_only_time);
747 ret = 0;
748out:
749 spin_unlock_irqrestore(cdev->ccwlock, flags);
750 return ret;
751}
752
753static void reset_cmb(struct ccw_device *cdev)
754{
755 cmf_generic_reset(cdev);
756}
757
758static void * align_cmb(void *area)
759{
760 return area;
761}
762
763static struct attribute_group cmf_attr_group;
764
765static struct cmb_operations cmbops_basic = {
766 .alloc = alloc_cmb,
767 .free = free_cmb,
768 .set = set_cmb,
769 .read = read_cmb,
770 .readall = readall_cmb,
771 .reset = reset_cmb,
772 .align = align_cmb,
773 .attr_group = &cmf_attr_group,
774};
775
776/* ******** extended cmb handling ********/
777
778/**
779 * struct cmbe - extended channel measurement block
780 * @ssch_rsch_count: number of ssch and rsch
781 * @sample_count: number of samples
782 * @device_connect_time: time of device connect
783 * @function_pending_time: time of function pending
784 * @device_disconnect_time: time of device disconnect
785 * @control_unit_queuing_time: time of control unit queuing
786 * @device_active_only_time: time of device active only
787 * @device_busy_time: time of device busy
788 * @initial_command_response_time: initial command response time
789 * @reserved: unused
790 *
791 * The measurement block as used by the hardware. May be in any 64 bit physical
792 * location.
793 * The fields are described further in z/Architecture Principles of Operation,
794 * third edition, chapter 17.
795 */
796struct cmbe {
797 u32 ssch_rsch_count;
798 u32 sample_count;
799 u32 device_connect_time;
800 u32 function_pending_time;
801 u32 device_disconnect_time;
802 u32 control_unit_queuing_time;
803 u32 device_active_only_time;
804 u32 device_busy_time;
805 u32 initial_command_response_time;
806 u32 reserved[7];
807};
808
809/*
810 * kmalloc only guarantees 8 byte alignment, but we need cmbe
811 * pointers to be naturally aligned. Make sure to allocate
812 * enough space for two cmbes.
813 */
814static inline struct cmbe *cmbe_align(struct cmbe *c)
815{
816 unsigned long addr;
817 addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
818 ~(sizeof (struct cmbe) - sizeof(long));
819 return (struct cmbe*)addr;
820}
821
822static int alloc_cmbe(struct ccw_device *cdev)
823{
824 struct cmbe *cmbe;
825 struct cmb_data *cmb_data;
826 int ret;
827
828 cmbe = kzalloc (sizeof (*cmbe) * 2, GFP_KERNEL);
829 if (!cmbe)
830 return -ENOMEM;
831 cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
832 if (!cmb_data) {
833 ret = -ENOMEM;
834 goto out_free;
835 }
836 cmb_data->last_block = kzalloc(sizeof(struct cmbe), GFP_KERNEL);
837 if (!cmb_data->last_block) {
838 ret = -ENOMEM;
839 goto out_free;
840 }
841 cmb_data->size = sizeof(struct cmbe);
842 spin_lock_irq(cdev->ccwlock);
843 if (cdev->private->cmb) {
844 spin_unlock_irq(cdev->ccwlock);
845 ret = -EBUSY;
846 goto out_free;
847 }
848 cmb_data->hw_block = cmbe;
849 cdev->private->cmb = cmb_data;
850 spin_unlock_irq(cdev->ccwlock);
851
852 /* activate global measurement if this is the first channel */
853 spin_lock(&cmb_area.lock);
854 if (list_empty(&cmb_area.list))
855 cmf_activate(NULL, 1);
856 list_add_tail(&cdev->private->cmb_list, &cmb_area.list);
857 spin_unlock(&cmb_area.lock);
858
859 return 0;
860out_free:
861 if (cmb_data)
862 kfree(cmb_data->last_block);
863 kfree(cmb_data);
864 kfree(cmbe);
865 return ret;
866}
867
868static void free_cmbe(struct ccw_device *cdev)
869{
870 struct cmb_data *cmb_data;
871
872 spin_lock_irq(cdev->ccwlock);
873 cmb_data = cdev->private->cmb;
874 cdev->private->cmb = NULL;
875 if (cmb_data)
876 kfree(cmb_data->last_block);
877 kfree(cmb_data);
878 spin_unlock_irq(cdev->ccwlock);
879
880 /* deactivate global measurement if this is the last channel */
881 spin_lock(&cmb_area.lock);
882 list_del_init(&cdev->private->cmb_list);
883 if (list_empty(&cmb_area.list))
884 cmf_activate(NULL, 0);
885 spin_unlock(&cmb_area.lock);
886}
887
888static int set_cmbe(struct ccw_device *cdev, u32 mme)
889{
890 unsigned long mba;
891 struct cmb_data *cmb_data;
892 unsigned long flags;
893
894 spin_lock_irqsave(cdev->ccwlock, flags);
895 if (!cdev->private->cmb) {
896 spin_unlock_irqrestore(cdev->ccwlock, flags);
897 return -EINVAL;
898 }
899 cmb_data = cdev->private->cmb;
900 mba = mme ? (unsigned long) cmbe_align(cmb_data->hw_block) : 0;
901 spin_unlock_irqrestore(cdev->ccwlock, flags);
902
903 return set_schib_wait(cdev, mme, 1, mba);
904}
905
906
907static u64 read_cmbe(struct ccw_device *cdev, int index)
908{
909 struct cmbe *cmb;
910 struct cmb_data *cmb_data;
911 u32 val;
912 int ret;
913 unsigned long flags;
914
915 ret = cmf_cmb_copy_wait(cdev);
916 if (ret < 0)
917 return 0;
918
919 spin_lock_irqsave(cdev->ccwlock, flags);
920 cmb_data = cdev->private->cmb;
921 if (!cmb_data) {
922 ret = 0;
923 goto out;
924 }
925 cmb = cmb_data->last_block;
926
927 switch (index) {
928 case cmb_ssch_rsch_count:
929 ret = cmb->ssch_rsch_count;
930 goto out;
931 case cmb_sample_count:
932 ret = cmb->sample_count;
933 goto out;
934 case cmb_device_connect_time:
935 val = cmb->device_connect_time;
936 break;
937 case cmb_function_pending_time:
938 val = cmb->function_pending_time;
939 break;
940 case cmb_device_disconnect_time:
941 val = cmb->device_disconnect_time;
942 break;
943 case cmb_control_unit_queuing_time:
944 val = cmb->control_unit_queuing_time;
945 break;
946 case cmb_device_active_only_time:
947 val = cmb->device_active_only_time;
948 break;
949 case cmb_device_busy_time:
950 val = cmb->device_busy_time;
951 break;
952 case cmb_initial_command_response_time:
953 val = cmb->initial_command_response_time;
954 break;
955 default:
956 ret = 0;
957 goto out;
958 }
959 ret = time_to_avg_nsec(val, cmb->sample_count);
960out:
961 spin_unlock_irqrestore(cdev->ccwlock, flags);
962 return ret;
963}
964
965static int readall_cmbe(struct ccw_device *cdev, struct cmbdata *data)
966{
967 struct cmbe *cmb;
968 struct cmb_data *cmb_data;
969 u64 time;
970 unsigned long flags;
971 int ret;
972
973 ret = cmf_cmb_copy_wait(cdev);
974 if (ret < 0)
975 return ret;
976 spin_lock_irqsave(cdev->ccwlock, flags);
977 cmb_data = cdev->private->cmb;
978 if (!cmb_data) {
979 ret = -ENODEV;
980 goto out;
981 }
982 if (cmb_data->last_update == 0) {
983 ret = -EAGAIN;
984 goto out;
985 }
986 time = cmb_data->last_update - cdev->private->cmb_start_time;
987
988 memset (data, 0, sizeof(struct cmbdata));
989
990 /* we only know values before device_busy_time */
991 data->size = offsetof(struct cmbdata, device_busy_time);
992
993 /* conver to nanoseconds */
994 data->elapsed_time = (time * 1000) >> 12;
995
996 cmb = cmb_data->last_block;
997 /* copy data to new structure */
998 data->ssch_rsch_count = cmb->ssch_rsch_count;
999 data->sample_count = cmb->sample_count;
1000
1001 /* time fields are converted to nanoseconds while copying */
1002 data->device_connect_time = time_to_nsec(cmb->device_connect_time);
1003 data->function_pending_time = time_to_nsec(cmb->function_pending_time);
1004 data->device_disconnect_time =
1005 time_to_nsec(cmb->device_disconnect_time);
1006 data->control_unit_queuing_time
1007 = time_to_nsec(cmb->control_unit_queuing_time);
1008 data->device_active_only_time
1009 = time_to_nsec(cmb->device_active_only_time);
1010 data->device_busy_time = time_to_nsec(cmb->device_busy_time);
1011 data->initial_command_response_time
1012 = time_to_nsec(cmb->initial_command_response_time);
1013
1014 ret = 0;
1015out:
1016 spin_unlock_irqrestore(cdev->ccwlock, flags);
1017 return ret;
1018}
1019
1020static void reset_cmbe(struct ccw_device *cdev)
1021{
1022 cmf_generic_reset(cdev);
1023}
1024
1025static void * align_cmbe(void *area)
1026{
1027 return cmbe_align(area);
1028}
1029
1030static struct attribute_group cmf_attr_group_ext;
1031
1032static struct cmb_operations cmbops_extended = {
1033 .alloc = alloc_cmbe,
1034 .free = free_cmbe,
1035 .set = set_cmbe,
1036 .read = read_cmbe,
1037 .readall = readall_cmbe,
1038 .reset = reset_cmbe,
1039 .align = align_cmbe,
1040 .attr_group = &cmf_attr_group_ext,
1041};
1042
1043static ssize_t cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
1044{
1045 return sprintf(buf, "%lld\n",
1046 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
1047}
1048
1049static ssize_t cmb_show_avg_sample_interval(struct device *dev,
1050 struct device_attribute *attr,
1051 char *buf)
1052{
1053 struct ccw_device *cdev;
1054 long interval;
1055 unsigned long count;
1056 struct cmb_data *cmb_data;
1057
1058 cdev = to_ccwdev(dev);
1059 count = cmf_read(cdev, cmb_sample_count);
1060 spin_lock_irq(cdev->ccwlock);
1061 cmb_data = cdev->private->cmb;
1062 if (count) {
1063 interval = cmb_data->last_update -
1064 cdev->private->cmb_start_time;
1065 interval = (interval * 1000) >> 12;
1066 interval /= count;
1067 } else
1068 interval = -1;
1069 spin_unlock_irq(cdev->ccwlock);
1070 return sprintf(buf, "%ld\n", interval);
1071}
1072
1073static ssize_t cmb_show_avg_utilization(struct device *dev,
1074 struct device_attribute *attr,
1075 char *buf)
1076{
1077 struct cmbdata data;
1078 u64 utilization;
1079 unsigned long t, u;
1080 int ret;
1081
1082 ret = cmf_readall(to_ccwdev(dev), &data);
1083 if (ret == -EAGAIN || ret == -ENODEV)
1084 /* No data (yet/currently) available to use for calculation. */
1085 return sprintf(buf, "n/a\n");
1086 else if (ret)
1087 return ret;
1088
1089 utilization = data.device_connect_time +
1090 data.function_pending_time +
1091 data.device_disconnect_time;
1092
1093 /* shift to avoid long long division */
1094 while (-1ul < (data.elapsed_time | utilization)) {
1095 utilization >>= 8;
1096 data.elapsed_time >>= 8;
1097 }
1098
1099 /* calculate value in 0.1 percent units */
1100 t = (unsigned long) data.elapsed_time / 1000;
1101 u = (unsigned long) utilization / t;
1102
1103 return sprintf(buf, "%02ld.%01ld%%\n", u/ 10, u - (u/ 10) * 10);
1104}
1105
1106#define cmf_attr(name) \
1107static ssize_t show_##name(struct device *dev, \
1108 struct device_attribute *attr, char *buf) \
1109{ return cmb_show_attr((dev), buf, cmb_##name); } \
1110static DEVICE_ATTR(name, 0444, show_##name, NULL);
1111
1112#define cmf_attr_avg(name) \
1113static ssize_t show_avg_##name(struct device *dev, \
1114 struct device_attribute *attr, char *buf) \
1115{ return cmb_show_attr((dev), buf, cmb_##name); } \
1116static DEVICE_ATTR(avg_##name, 0444, show_avg_##name, NULL);
1117
1118cmf_attr(ssch_rsch_count);
1119cmf_attr(sample_count);
1120cmf_attr_avg(device_connect_time);
1121cmf_attr_avg(function_pending_time);
1122cmf_attr_avg(device_disconnect_time);
1123cmf_attr_avg(control_unit_queuing_time);
1124cmf_attr_avg(device_active_only_time);
1125cmf_attr_avg(device_busy_time);
1126cmf_attr_avg(initial_command_response_time);
1127
1128static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval,
1129 NULL);
1130static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
1131
1132static struct attribute *cmf_attributes[] = {
1133 &dev_attr_avg_sample_interval.attr,
1134 &dev_attr_avg_utilization.attr,
1135 &dev_attr_ssch_rsch_count.attr,
1136 &dev_attr_sample_count.attr,
1137 &dev_attr_avg_device_connect_time.attr,
1138 &dev_attr_avg_function_pending_time.attr,
1139 &dev_attr_avg_device_disconnect_time.attr,
1140 &dev_attr_avg_control_unit_queuing_time.attr,
1141 &dev_attr_avg_device_active_only_time.attr,
1142 NULL,
1143};
1144
1145static struct attribute_group cmf_attr_group = {
1146 .name = "cmf",
1147 .attrs = cmf_attributes,
1148};
1149
1150static struct attribute *cmf_attributes_ext[] = {
1151 &dev_attr_avg_sample_interval.attr,
1152 &dev_attr_avg_utilization.attr,
1153 &dev_attr_ssch_rsch_count.attr,
1154 &dev_attr_sample_count.attr,
1155 &dev_attr_avg_device_connect_time.attr,
1156 &dev_attr_avg_function_pending_time.attr,
1157 &dev_attr_avg_device_disconnect_time.attr,
1158 &dev_attr_avg_control_unit_queuing_time.attr,
1159 &dev_attr_avg_device_active_only_time.attr,
1160 &dev_attr_avg_device_busy_time.attr,
1161 &dev_attr_avg_initial_command_response_time.attr,
1162 NULL,
1163};
1164
1165static struct attribute_group cmf_attr_group_ext = {
1166 .name = "cmf",
1167 .attrs = cmf_attributes_ext,
1168};
1169
1170static ssize_t cmb_enable_show(struct device *dev,
1171 struct device_attribute *attr,
1172 char *buf)
1173{
1174 return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
1175}
1176
1177static ssize_t cmb_enable_store(struct device *dev,
1178 struct device_attribute *attr, const char *buf,
1179 size_t c)
1180{
1181 struct ccw_device *cdev;
1182 int ret;
1183 unsigned long val;
1184
1185 ret = kstrtoul(buf, 16, &val);
1186 if (ret)
1187 return ret;
1188
1189 cdev = to_ccwdev(dev);
1190
1191 switch (val) {
1192 case 0:
1193 ret = disable_cmf(cdev);
1194 break;
1195 case 1:
1196 ret = enable_cmf(cdev);
1197 break;
1198 }
1199
1200 return c;
1201}
1202
1203DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
1204
1205int ccw_set_cmf(struct ccw_device *cdev, int enable)
1206{
1207 return cmbops->set(cdev, enable ? 2 : 0);
1208}
1209
1210/**
1211 * enable_cmf() - switch on the channel measurement for a specific device
1212 * @cdev: The ccw device to be enabled
1213 *
1214 * Returns %0 for success or a negative error value.
1215 *
1216 * Context:
1217 * non-atomic
1218 */
1219int enable_cmf(struct ccw_device *cdev)
1220{
1221 int ret;
1222
1223 ret = cmbops->alloc(cdev);
1224 cmbops->reset(cdev);
1225 if (ret)
1226 return ret;
1227 ret = cmbops->set(cdev, 2);
1228 if (ret) {
1229 cmbops->free(cdev);
1230 return ret;
1231 }
1232 ret = sysfs_create_group(&cdev->dev.kobj, cmbops->attr_group);
1233 if (!ret)
1234 return 0;
1235 cmbops->set(cdev, 0); //FIXME: this can fail
1236 cmbops->free(cdev);
1237 return ret;
1238}
1239
1240/**
1241 * disable_cmf() - switch off the channel measurement for a specific device
1242 * @cdev: The ccw device to be disabled
1243 *
1244 * Returns %0 for success or a negative error value.
1245 *
1246 * Context:
1247 * non-atomic
1248 */
1249int disable_cmf(struct ccw_device *cdev)
1250{
1251 int ret;
1252
1253 ret = cmbops->set(cdev, 0);
1254 if (ret)
1255 return ret;
1256 cmbops->free(cdev);
1257 sysfs_remove_group(&cdev->dev.kobj, cmbops->attr_group);
1258 return ret;
1259}
1260
1261/**
1262 * cmf_read() - read one value from the current channel measurement block
1263 * @cdev: the channel to be read
1264 * @index: the index of the value to be read
1265 *
1266 * Returns the value read or %0 if the value cannot be read.
1267 *
1268 * Context:
1269 * any
1270 */
1271u64 cmf_read(struct ccw_device *cdev, int index)
1272{
1273 return cmbops->read(cdev, index);
1274}
1275
1276/**
1277 * cmf_readall() - read the current channel measurement block
1278 * @cdev: the channel to be read
1279 * @data: a pointer to a data block that will be filled
1280 *
1281 * Returns %0 on success, a negative error value otherwise.
1282 *
1283 * Context:
1284 * any
1285 */
1286int cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
1287{
1288 return cmbops->readall(cdev, data);
1289}
1290
1291/* Reenable cmf when a disconnected device becomes available again. */
1292int cmf_reenable(struct ccw_device *cdev)
1293{
1294 cmbops->reset(cdev);
1295 return cmbops->set(cdev, 2);
1296}
1297
1298static int __init init_cmf(void)
1299{
1300 char *format_string;
1301 char *detect_string = "parameter";
1302
1303 /*
1304 * If the user did not give a parameter, see if we are running on a
1305 * machine supporting extended measurement blocks, otherwise fall back
1306 * to basic mode.
1307 */
1308 if (format == CMF_AUTODETECT) {
1309 if (!css_general_characteristics.ext_mb) {
1310 format = CMF_BASIC;
1311 } else {
1312 format = CMF_EXTENDED;
1313 }
1314 detect_string = "autodetected";
1315 } else {
1316 detect_string = "parameter";
1317 }
1318
1319 switch (format) {
1320 case CMF_BASIC:
1321 format_string = "basic";
1322 cmbops = &cmbops_basic;
1323 break;
1324 case CMF_EXTENDED:
1325 format_string = "extended";
1326 cmbops = &cmbops_extended;
1327 break;
1328 default:
1329 return 1;
1330 }
1331 pr_info("Channel measurement facility initialized using format "
1332 "%s (mode %s)\n", format_string, detect_string);
1333 return 0;
1334}
1335
1336module_init(init_cmf);
1337
1338
1339MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
1340MODULE_LICENSE("GPL");
1341MODULE_DESCRIPTION("channel measurement facility base driver\n"
1342 "Copyright IBM Corp. 2003\n");
1343
1344EXPORT_SYMBOL_GPL(enable_cmf);
1345EXPORT_SYMBOL_GPL(disable_cmf);
1346EXPORT_SYMBOL_GPL(cmf_read);
1347EXPORT_SYMBOL_GPL(cmf_readall);