SAFE public projects git trees. - safe/jmp/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(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);