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