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