git.oblomov.eu Git - linux-2.6/blob - 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,
 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                         ret = -ENOMEM;
 598                         goto out;
 599                 } else {
 600                         /* everything ok */
 601                         memset(mem, 0, size);
 602                         cmb_area.mem = mem;
 603                         cmf_activate(cmb_area.mem, 1);
 604                 }
 605         }
 606
 607         /* do the actual allocation */
 608         ret = alloc_cmb_single(cdev, cmb_data);
 609 out:
 610         spin_unlock(&cmb_area.lock);
 611         if (ret) {
 612                 kfree(cmb_data->last_block);
 613                 kfree(cmb_data);
 614         }
 615         return ret;
 616 }
 617
 618 static void free_cmb(struct ccw_device *cdev)
 619 {
 620         struct ccw_device_private *priv;
 621         struct cmb_data *cmb_data;
 622
 623         spin_lock(&cmb_area.lock);
 624         spin_lock_irq(cdev->ccwlock);
 625
 626         priv = cdev->private;
 627
 628         if (list_empty(&priv->cmb_list)) {
 629                 /* already freed */
 630                 goto out;
 631         }
 632
 633         cmb_data = priv->cmb;
 634         priv->cmb = NULL;
 635         if (cmb_data)
 636                 kfree(cmb_data->last_block);
 637         kfree(cmb_data);
 638         list_del_init(&priv->cmb_list);
 639
 640         if (list_empty(&cmb_area.list)) {
 641                 ssize_t size;
 642                 size = sizeof(struct cmb) * cmb_area.num_channels;
 643                 cmf_activate(NULL, 0);
 644                 free_pages((unsigned long)cmb_area.mem, get_order(size));
 645                 cmb_area.mem = NULL;
 646         }
 647 out:
 648         spin_unlock_irq(cdev->ccwlock);
 649         spin_unlock(&cmb_area.lock);
 650 }
 651
 652 static int set_cmb(struct ccw_device *cdev, u32 mme)
 653 {
 654         u16 offset;
 655         struct cmb_data *cmb_data;
 656         unsigned long flags;
 657
 658         spin_lock_irqsave(cdev->ccwlock, flags);
 659         if (!cdev->private->cmb) {
 660                 spin_unlock_irqrestore(cdev->ccwlock, flags);
 661                 return -EINVAL;
 662         }
 663         cmb_data = cdev->private->cmb;
 664         offset = mme ? (struct cmb *)cmb_data->hw_block - cmb_area.mem : 0;
 665         spin_unlock_irqrestore(cdev->ccwlock, flags);
 666
 667         return set_schib_wait(cdev, mme, 0, offset);
 668 }
 669
 670 static u64 read_cmb (struct ccw_device *cdev, int index)
 671 {
 672         struct cmb *cmb;
 673         u32 val;
 674         int ret;
 675         unsigned long flags;
 676
 677         ret = cmf_cmb_copy_wait(cdev);
 678         if (ret < 0)
 679                 return 0;
 680
 681         spin_lock_irqsave(cdev->ccwlock, flags);
 682         if (!cdev->private->cmb) {
 683                 ret = 0;
 684                 goto out;
 685         }
 686         cmb = ((struct cmb_data *)cdev->private->cmb)->last_block;
 687
 688         switch (index) {
 689         case cmb_ssch_rsch_count:
 690                 ret = cmb->ssch_rsch_count;
 691                 goto out;
 692         case cmb_sample_count:
 693                 ret = cmb->sample_count;
 694                 goto out;
 695         case cmb_device_connect_time:
 696                 val = cmb->device_connect_time;
 697                 break;
 698         case cmb_function_pending_time:
 699                 val = cmb->function_pending_time;
 700                 break;
 701         case cmb_device_disconnect_time:
 702                 val = cmb->device_disconnect_time;
 703                 break;
 704         case cmb_control_unit_queuing_time:
 705                 val = cmb->control_unit_queuing_time;
 706                 break;
 707         case cmb_device_active_only_time:
 708                 val = cmb->device_active_only_time;
 709                 break;
 710         default:
 711                 ret = 0;
 712                 goto out;
 713         }
 714         ret = time_to_avg_nsec(val, cmb->sample_count);
 715 out:
 716         spin_unlock_irqrestore(cdev->ccwlock, flags);
 717         return ret;
 718 }
 719
 720 static int readall_cmb (struct ccw_device *cdev, struct cmbdata *data)
 721 {
 722         struct cmb *cmb;
 723         struct cmb_data *cmb_data;
 724         u64 time;
 725         unsigned long flags;
 726         int ret;
 727
 728         ret = cmf_cmb_copy_wait(cdev);
 729         if (ret < 0)
 730                 return ret;
 731         spin_lock_irqsave(cdev->ccwlock, flags);
 732         cmb_data = cdev->private->cmb;
 733         if (!cmb_data) {
 734                 ret = -ENODEV;
 735                 goto out;
 736         }
 737         if (cmb_data->last_update == 0) {
 738                 ret = -EAGAIN;
 739                 goto out;
 740         }
 741         cmb = cmb_data->last_block;
 742         time = cmb_data->last_update - cdev->private->cmb_start_time;
 743
 744         memset(data, 0, sizeof(struct cmbdata));
 745
 746         /* we only know values before device_busy_time */
 747         data->size = offsetof(struct cmbdata, device_busy_time);
 748
 749         /* convert to nanoseconds */
 750         data->elapsed_time = (time * 1000) >> 12;
 751
 752         /* copy data to new structure */
 753         data->ssch_rsch_count = cmb->ssch_rsch_count;
 754         data->sample_count = cmb->sample_count;
 755
 756         /* time fields are converted to nanoseconds while copying */
 757         data->device_connect_time = time_to_nsec(cmb->device_connect_time);
 758         data->function_pending_time = time_to_nsec(cmb->function_pending_time);
 759         data->device_disconnect_time =
 760                 time_to_nsec(cmb->device_disconnect_time);
 761         data->control_unit_queuing_time
 762                 = time_to_nsec(cmb->control_unit_queuing_time);
 763         data->device_active_only_time
 764                 = time_to_nsec(cmb->device_active_only_time);
 765         ret = 0;
 766 out:
 767         spin_unlock_irqrestore(cdev->ccwlock, flags);
 768         return ret;
 769 }
 770
 771 static void reset_cmb(struct ccw_device *cdev)
 772 {
 773         cmf_generic_reset(cdev);
 774 }
 775
 776 static void * align_cmb(void *area)
 777 {
 778         return area;
 779 }
 780
 781 static struct attribute_group cmf_attr_group;
 782
 783 static struct cmb_operations cmbops_basic = {
 784         .alloc  = alloc_cmb,
 785         .free   = free_cmb,
 786         .set    = set_cmb,
 787         .read   = read_cmb,
 788         .readall    = readall_cmb,
 789         .reset      = reset_cmb,
 790         .align      = align_cmb,
 791         .attr_group = &cmf_attr_group,
 792 };
 793 \f
 794 /* ******** extended cmb handling ********/
 795
 796 /**
 797  * struct cmbe - extended channel measurement block
 798  *
 799  * cmb as used by the hardware, may be in any 64 bit physical location,
 800  * the fields are described in z/Architecture Principles of Operation,
 801  * third edition, chapter 17.
 802  */
 803 struct cmbe {
 804         u32 ssch_rsch_count;
 805         u32 sample_count;
 806         u32 device_connect_time;
 807         u32 function_pending_time;
 808         u32 device_disconnect_time;
 809         u32 control_unit_queuing_time;
 810         u32 device_active_only_time;
 811         u32 device_busy_time;
 812         u32 initial_command_response_time;
 813         u32 reserved[7];
 814 };
 815
 816 /* kmalloc only guarantees 8 byte alignment, but we need cmbe
 817  * pointers to be naturally aligned. Make sure to allocate
 818  * enough space for two cmbes */
 819 static inline struct cmbe* cmbe_align(struct cmbe *c)
 820 {
 821         unsigned long addr;
 822         addr = ((unsigned long)c + sizeof (struct cmbe) - sizeof(long)) &
 823                                  ~(sizeof (struct cmbe) - sizeof(long));
 824         return (struct cmbe*)addr;
 825 }
 826
 827 static int alloc_cmbe (struct ccw_device *cdev)
 828 {
 829         struct cmbe *cmbe;
 830         struct cmb_data *cmb_data;
 831         int ret;
 832
 833         cmbe = kzalloc (sizeof (*cmbe) * 2, GFP_KERNEL);
 834         if (!cmbe)
 835                 return -ENOMEM;
 836         cmb_data = kzalloc(sizeof(struct cmb_data), GFP_KERNEL);
 837         if (!cmb_data) {
 838                 ret = -ENOMEM;
 839                 goto out_free;
 840         }
 841         cmb_data->last_block = kzalloc(sizeof(struct cmbe), GFP_KERNEL);
 842         if (!cmb_data->last_block) {
 843                 ret = -ENOMEM;
 844                 goto out_free;
 845         }
 846         cmb_data->size = sizeof(struct cmbe);
 847         spin_lock_irq(cdev->ccwlock);
 848         if (cdev->private->cmb) {
 849                 spin_unlock_irq(cdev->ccwlock);
 850                 ret = -EBUSY;
 851                 goto out_free;
 852         }
 853         cmb_data->hw_block = cmbe;
 854         cdev->private->cmb = cmb_data;
 855         spin_unlock_irq(cdev->ccwlock);
 856
 857         /* activate global measurement if this is the first channel */
 858         spin_lock(&cmb_area.lock);
 859         if (list_empty(&cmb_area.list))
 860                 cmf_activate(NULL, 1);
 861         list_add_tail(&cdev->private->cmb_list, &cmb_area.list);
 862         spin_unlock(&cmb_area.lock);
 863
 864         return 0;
 865 out_free:
 866         if (cmb_data)
 867                 kfree(cmb_data->last_block);
 868         kfree(cmb_data);
 869         kfree(cmbe);
 870         return ret;
 871 }
 872
 873 static void free_cmbe (struct ccw_device *cdev)
 874 {
 875         struct cmb_data *cmb_data;
 876
 877         spin_lock_irq(cdev->ccwlock);
 878         cmb_data = cdev->private->cmb;
 879         cdev->private->cmb = NULL;
 880         if (cmb_data)
 881                 kfree(cmb_data->last_block);
 882         kfree(cmb_data);
 883         spin_unlock_irq(cdev->ccwlock);
 884
 885         /* deactivate global measurement if this is the last channel */
 886         spin_lock(&cmb_area.lock);
 887         list_del_init(&cdev->private->cmb_list);
 888         if (list_empty(&cmb_area.list))
 889                 cmf_activate(NULL, 0);
 890         spin_unlock(&cmb_area.lock);
 891 }
 892
 893 static int set_cmbe(struct ccw_device *cdev, u32 mme)
 894 {
 895         unsigned long mba;
 896         struct cmb_data *cmb_data;
 897         unsigned long flags;
 898
 899         spin_lock_irqsave(cdev->ccwlock, flags);
 900         if (!cdev->private->cmb) {
 901                 spin_unlock_irqrestore(cdev->ccwlock, flags);
 902                 return -EINVAL;
 903         }
 904         cmb_data = cdev->private->cmb;
 905         mba = mme ? (unsigned long) cmbe_align(cmb_data->hw_block) : 0;
 906         spin_unlock_irqrestore(cdev->ccwlock, flags);
 907
 908         return set_schib_wait(cdev, mme, 1, mba);
 909 }
 910
 911
 912 static u64 read_cmbe (struct ccw_device *cdev, int index)
 913 {
 914         struct cmbe *cmb;
 915         struct cmb_data *cmb_data;
 916         u32 val;
 917         int ret;
 918         unsigned long flags;
 919
 920         ret = cmf_cmb_copy_wait(cdev);
 921         if (ret < 0)
 922                 return 0;
 923
 924         spin_lock_irqsave(cdev->ccwlock, flags);
 925         cmb_data = cdev->private->cmb;
 926         if (!cmb_data) {
 927                 ret = 0;
 928                 goto out;
 929         }
 930         cmb = cmb_data->last_block;
 931
 932         switch (index) {
 933         case cmb_ssch_rsch_count:
 934                 ret = cmb->ssch_rsch_count;
 935                 goto out;
 936         case cmb_sample_count:
 937                 ret = cmb->sample_count;
 938                 goto out;
 939         case cmb_device_connect_time:
 940                 val = cmb->device_connect_time;
 941                 break;
 942         case cmb_function_pending_time:
 943                 val = cmb->function_pending_time;
 944                 break;
 945         case cmb_device_disconnect_time:
 946                 val = cmb->device_disconnect_time;
 947                 break;
 948         case cmb_control_unit_queuing_time:
 949                 val = cmb->control_unit_queuing_time;
 950                 break;
 951         case cmb_device_active_only_time:
 952                 val = cmb->device_active_only_time;
 953                 break;
 954         case cmb_device_busy_time:
 955                 val = cmb->device_busy_time;
 956                 break;
 957         case cmb_initial_command_response_time:
 958                 val = cmb->initial_command_response_time;
 959                 break;
 960         default:
 961                 ret = 0;
 962                 goto out;
 963         }
 964         ret = time_to_avg_nsec(val, cmb->sample_count);
 965 out:
 966         spin_unlock_irqrestore(cdev->ccwlock, flags);
 967         return ret;
 968 }
 969
 970 static int readall_cmbe (struct ccw_device *cdev, struct cmbdata *data)
 971 {
 972         struct cmbe *cmb;
 973         struct cmb_data *cmb_data;
 974         u64 time;
 975         unsigned long flags;
 976         int ret;
 977
 978         ret = cmf_cmb_copy_wait(cdev);
 979         if (ret < 0)
 980                 return ret;
 981         spin_lock_irqsave(cdev->ccwlock, flags);
 982         cmb_data = cdev->private->cmb;
 983         if (!cmb_data) {
 984                 ret = -ENODEV;
 985                 goto out;
 986         }
 987         if (cmb_data->last_update == 0) {
 988                 ret = -EAGAIN;
 989                 goto out;
 990         }
 991         time = cmb_data->last_update - cdev->private->cmb_start_time;
 992
 993         memset (data, 0, sizeof(struct cmbdata));
 994
 995         /* we only know values before device_busy_time */
 996         data->size = offsetof(struct cmbdata, device_busy_time);
 997
 998         /* conver to nanoseconds */
 999         data->elapsed_time = (time * 1000) >> 12;
1000
1001         cmb = cmb_data->last_block;
1002         /* copy data to new structure */
1003         data->ssch_rsch_count = cmb->ssch_rsch_count;
1004         data->sample_count = cmb->sample_count;
1005
1006         /* time fields are converted to nanoseconds while copying */
1007         data->device_connect_time = time_to_nsec(cmb->device_connect_time);
1008         data->function_pending_time = time_to_nsec(cmb->function_pending_time);
1009         data->device_disconnect_time =
1010                 time_to_nsec(cmb->device_disconnect_time);
1011         data->control_unit_queuing_time
1012                 = time_to_nsec(cmb->control_unit_queuing_time);
1013         data->device_active_only_time
1014                 = time_to_nsec(cmb->device_active_only_time);
1015         data->device_busy_time = time_to_nsec(cmb->device_busy_time);
1016         data->initial_command_response_time
1017                 = time_to_nsec(cmb->initial_command_response_time);
1018
1019         ret = 0;
1020 out:
1021         spin_unlock_irqrestore(cdev->ccwlock, flags);
1022         return ret;
1023 }
1024
1025 static void reset_cmbe(struct ccw_device *cdev)
1026 {
1027         cmf_generic_reset(cdev);
1028 }
1029
1030 static void * align_cmbe(void *area)
1031 {
1032         return cmbe_align(area);
1033 }
1034
1035 static struct attribute_group cmf_attr_group_ext;
1036
1037 static struct cmb_operations cmbops_extended = {
1038         .alloc      = alloc_cmbe,
1039         .free       = free_cmbe,
1040         .set        = set_cmbe,
1041         .read       = read_cmbe,
1042         .readall    = readall_cmbe,
1043         .reset      = reset_cmbe,
1044         .align      = align_cmbe,
1045         .attr_group = &cmf_attr_group_ext,
1046 };
1047 \f
1048
1049 static ssize_t
1050 cmb_show_attr(struct device *dev, char *buf, enum cmb_index idx)
1051 {
1052         return sprintf(buf, "%lld\n",
1053                 (unsigned long long) cmf_read(to_ccwdev(dev), idx));
1054 }
1055
1056 static ssize_t
1057 cmb_show_avg_sample_interval(struct device *dev, struct device_attribute *attr, char *buf)
1058 {
1059         struct ccw_device *cdev;
1060         long interval;
1061         unsigned long count;
1062         struct cmb_data *cmb_data;
1063
1064         cdev = to_ccwdev(dev);
1065         count = cmf_read(cdev, cmb_sample_count);
1066         spin_lock_irq(cdev->ccwlock);
1067         cmb_data = cdev->private->cmb;
1068         if (count) {
1069                 interval = cmb_data->last_update -
1070                         cdev->private->cmb_start_time;
1071                 interval = (interval * 1000) >> 12;
1072                 interval /= count;
1073         } else
1074                 interval = -1;
1075         spin_unlock_irq(cdev->ccwlock);
1076         return sprintf(buf, "%ld\n", interval);
1077 }
1078
1079 static ssize_t
1080 cmb_show_avg_utilization(struct device *dev, struct device_attribute *attr, char *buf)
1081 {
1082         struct cmbdata data;
1083         u64 utilization;
1084         unsigned long t, u;
1085         int ret;
1086
1087         ret = cmf_readall(to_ccwdev(dev), &data);
1088         if (ret == -EAGAIN || ret == -ENODEV)
1089                 /* No data (yet/currently) available to use for calculation. */
1090                 return sprintf(buf, "n/a\n");
1091         else if (ret)
1092                 return ret;
1093
1094         utilization = data.device_connect_time +
1095                       data.function_pending_time +
1096                       data.device_disconnect_time;
1097
1098         /* shift to avoid long long division */
1099         while (-1ul < (data.elapsed_time | utilization)) {
1100                 utilization >>= 8;
1101                 data.elapsed_time >>= 8;
1102         }
1103
1104         /* calculate value in 0.1 percent units */
1105         t = (unsigned long) data.elapsed_time / 1000;
1106         u = (unsigned long) utilization / t;
1107
1108         return sprintf(buf, "%02ld.%01ld%%\n", u/ 10, u - (u/ 10) * 10);
1109 }
1110
1111 #define cmf_attr(name) \
1112 static ssize_t show_ ## name (struct device * dev, struct device_attribute *attr, char * buf) \
1113 { return cmb_show_attr((dev), buf, cmb_ ## name); } \
1114 static DEVICE_ATTR(name, 0444, show_ ## name, NULL);
1115
1116 #define cmf_attr_avg(name) \
1117 static ssize_t show_avg_ ## name (struct device * dev, struct device_attribute *attr, char * buf) \
1118 { return cmb_show_attr((dev), buf, cmb_ ## name); } \
1119 static DEVICE_ATTR(avg_ ## name, 0444, show_avg_ ## name, NULL);
1120
1121 cmf_attr(ssch_rsch_count);
1122 cmf_attr(sample_count);
1123 cmf_attr_avg(device_connect_time);
1124 cmf_attr_avg(function_pending_time);
1125 cmf_attr_avg(device_disconnect_time);
1126 cmf_attr_avg(control_unit_queuing_time);
1127 cmf_attr_avg(device_active_only_time);
1128 cmf_attr_avg(device_busy_time);
1129 cmf_attr_avg(initial_command_response_time);
1130
1131 static DEVICE_ATTR(avg_sample_interval, 0444, cmb_show_avg_sample_interval, NULL);
1132 static DEVICE_ATTR(avg_utilization, 0444, cmb_show_avg_utilization, NULL);
1133
1134 static 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
1147 static struct attribute_group cmf_attr_group = {
1148         .name  = "cmf",
1149         .attrs = cmf_attributes,
1150 };
1151
1152 static 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
1167 static struct attribute_group cmf_attr_group_ext = {
1168         .name  = "cmf",
1169         .attrs = cmf_attributes_ext,
1170 };
1171
1172 static ssize_t cmb_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
1173 {
1174         return sprintf(buf, "%d\n", to_ccwdev(dev)->private->cmb ? 1 : 0);
1175 }
1176
1177 static ssize_t cmb_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t c)
1178 {
1179         struct ccw_device *cdev;
1180         int ret;
1181
1182         cdev = to_ccwdev(dev);
1183
1184         switch (buf[0]) {
1185         case '0':
1186                 ret = disable_cmf(cdev);
1187                 if (ret)
1188                         printk(KERN_INFO "disable_cmf failed (%d)\n", ret);
1189                 break;
1190         case '1':
1191                 ret = enable_cmf(cdev);
1192                 if (ret && ret != -EBUSY)
1193                         printk(KERN_INFO "enable_cmf failed (%d)\n", ret);
1194                 break;
1195         }
1196
1197         return c;
1198 }
1199
1200 DEVICE_ATTR(cmb_enable, 0644, cmb_enable_show, cmb_enable_store);
1201
1202 /* enable_cmf/disable_cmf: module interface for cmf (de)activation */
1203 int
1204 enable_cmf(struct ccw_device *cdev)
1205 {
1206         int ret;
1207
1208         ret = cmbops->alloc(cdev);
1209         cmbops->reset(cdev);
1210         if (ret)
1211                 return ret;
1212         ret = cmbops->set(cdev, 2);
1213         if (ret) {
1214                 cmbops->free(cdev);
1215                 return ret;
1216         }
1217         ret = sysfs_create_group(&cdev->dev.kobj, cmbops->attr_group);
1218         if (!ret)
1219                 return 0;
1220         cmbops->set(cdev, 0);  //FIXME: this can fail
1221         cmbops->free(cdev);
1222         return ret;
1223 }
1224
1225 int
1226 disable_cmf(struct ccw_device *cdev)
1227 {
1228         int ret;
1229
1230         ret = cmbops->set(cdev, 0);
1231         if (ret)
1232                 return ret;
1233         cmbops->free(cdev);
1234         sysfs_remove_group(&cdev->dev.kobj, cmbops->attr_group);
1235         return ret;
1236 }
1237
1238 u64
1239 cmf_read(struct ccw_device *cdev, int index)
1240 {
1241         return cmbops->read(cdev, index);
1242 }
1243
1244 int
1245 cmf_readall(struct ccw_device *cdev, struct cmbdata *data)
1246 {
1247         return cmbops->readall(cdev, data);
1248 }
1249
1250 /* Reenable cmf when a disconnected device becomes available again. */
1251 int cmf_reenable(struct ccw_device *cdev)
1252 {
1253         cmbops->reset(cdev);
1254         return cmbops->set(cdev, 2);
1255 }
1256
1257 static int __init
1258 init_cmf(void)
1259 {
1260         char *format_string;
1261         char *detect_string = "parameter";
1262
1263         /* We cannot really autoprobe this. If the user did not give a parameter,
1264            see if we are running on z990 or up, otherwise fall back to basic mode. */
1265
1266         if (format == CMF_AUTODETECT) {
1267                 if (!css_characteristics_avail ||
1268                     !css_general_characteristics.ext_mb) {
1269                         format = CMF_BASIC;
1270                 } else {
1271                         format = CMF_EXTENDED;
1272                 }
1273                 detect_string = "autodetected";
1274         } else {
1275                 detect_string = "parameter";
1276         }
1277
1278         switch (format) {
1279         case CMF_BASIC:
1280                 format_string = "basic";
1281                 cmbops = &cmbops_basic;
1282                 if (cmb_area.num_channels > 4096 || cmb_area.num_channels < 1) {
1283                         printk(KERN_ERR "Basic channel measurement facility"
1284                                         " can only use 1 to 4096 devices\n"
1285                                KERN_ERR "when the cmf driver is built"
1286                                         " as a loadable module\n");
1287                         return 1;
1288                 }
1289                 break;
1290         case CMF_EXTENDED:
1291                 format_string = "extended";
1292                 cmbops = &cmbops_extended;
1293                 break;
1294         default:
1295                 printk(KERN_ERR "Invalid format %d for channel "
1296                         "measurement facility\n", format);
1297                 return 1;
1298         }
1299
1300         printk(KERN_INFO "Channel measurement facility using %s format (%s)\n",
1301                 format_string, detect_string);
1302         return 0;
1303 }
1304
1305 module_init(init_cmf);
1306
1307
1308 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
1309 MODULE_LICENSE("GPL");
1310 MODULE_DESCRIPTION("channel measurement facility base driver\n"
1311                    "Copyright 2003 IBM Corporation\n");
1312
1313 EXPORT_SYMBOL_GPL(enable_cmf);
1314 EXPORT_SYMBOL_GPL(disable_cmf);
1315 EXPORT_SYMBOL_GPL(cmf_read);
1316 EXPORT_SYMBOL_GPL(cmf_readall);