drivers/s390/char/sclp_cmd.c

   1 /*
   2  * Copyright IBM Corp. 2007,2012
   3  *
   4  * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>,
   5  *            Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   6  */
   7
   8 #define KMSG_COMPONENT "sclp_cmd"
   9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  10
  11 #include <linux/completion.h>
  12 #include <linux/init.h>
  13 #include <linux/errno.h>
  14 #include <linux/err.h>
  15 #include <linux/export.h>
  16 #include <linux/slab.h>
  17 #include <linux/string.h>
  18 #include <linux/mm.h>
  19 #include <linux/mmzone.h>
  20 #include <linux/memory.h>
  21 #include <linux/module.h>
  22 #include <linux/platform_device.h>
  23 #include <asm/ctl_reg.h>
  24 #include <asm/chpid.h>
  25 #include <asm/setup.h>
  26 #include <asm/page.h>
  27 #include <asm/sclp.h>
  28 #include <asm/numa.h>
  29
  30 #include "sclp.h"
  31
  32 static void sclp_sync_callback(struct sclp_req *req, void *data)
  33 {
  34         struct completion *completion = data;
  35
  36         complete(completion);
  37 }
  38
  39 int sclp_sync_request(sclp_cmdw_t cmd, void *sccb)
  40 {
  41         return sclp_sync_request_timeout(cmd, sccb, 0);
  42 }
  43
  44 int sclp_sync_request_timeout(sclp_cmdw_t cmd, void *sccb, int timeout)
  45 {
  46         struct completion completion;
  47         struct sclp_req *request;
  48         int rc;
  49
  50         request = kzalloc(sizeof(*request), GFP_KERNEL);
  51         if (!request)
  52                 return -ENOMEM;
  53         if (timeout)
  54                 request->queue_timeout = timeout;
  55         request->command = cmd;
  56         request->sccb = sccb;
  57         request->status = SCLP_REQ_FILLED;
  58         request->callback = sclp_sync_callback;
  59         request->callback_data = &completion;
  60         init_completion(&completion);
  61
  62         /* Perform sclp request. */
  63         rc = sclp_add_request(request);
  64         if (rc)
  65                 goto out;
  66         wait_for_completion(&completion);
  67
  68         /* Check response. */
  69         if (request->status != SCLP_REQ_DONE) {
  70                 pr_warn("sync request failed (cmd=0x%08x, status=0x%02x)\n",
  71                         cmd, request->status);
  72                 rc = -EIO;
  73         }
  74 out:
  75         kfree(request);
  76         return rc;
  77 }
  78
  79 /*
  80  * CPU configuration related functions.
  81  */
  82
  83 #define SCLP_CMDW_READ_CPU_INFO         0x00010001
  84 #define SCLP_CMDW_CONFIGURE_CPU         0x00110001
  85 #define SCLP_CMDW_DECONFIGURE_CPU       0x00100001
  86
  87 struct read_cpu_info_sccb {
  88         struct  sccb_header header;
  89         u16     nr_configured;
  90         u16     offset_configured;
  91         u16     nr_standby;
  92         u16     offset_standby;
  93         u8      reserved[4096 - 16];
  94 } __attribute__((packed, aligned(PAGE_SIZE)));
  95
  96 static void sclp_fill_core_info(struct sclp_core_info *info,
  97                                 struct read_cpu_info_sccb *sccb)
  98 {
  99         char *page = (char *) sccb;
 100
 101         memset(info, 0, sizeof(*info));
 102         info->configured = sccb->nr_configured;
 103         info->standby = sccb->nr_standby;
 104         info->combined = sccb->nr_configured + sccb->nr_standby;
 105         memcpy(&info->core, page + sccb->offset_configured,
 106                info->combined * sizeof(struct sclp_core_entry));
 107 }
 108
 109 int sclp_get_core_info(struct sclp_core_info *info)
 110 {
 111         int rc;
 112         struct read_cpu_info_sccb *sccb;
 113
 114         if (!SCLP_HAS_CPU_INFO)
 115                 return -EOPNOTSUPP;
 116         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 117         if (!sccb)
 118                 return -ENOMEM;
 119         sccb->header.length = sizeof(*sccb);
 120         rc = sclp_sync_request_timeout(SCLP_CMDW_READ_CPU_INFO, sccb,
 121                                        SCLP_QUEUE_INTERVAL);
 122         if (rc)
 123                 goto out;
 124         if (sccb->header.response_code != 0x0010) {
 125                 pr_warn("readcpuinfo failed (response=0x%04x)\n",
 126                         sccb->header.response_code);
 127                 rc = -EIO;
 128                 goto out;
 129         }
 130         sclp_fill_core_info(info, sccb);
 131 out:
 132         free_page((unsigned long) sccb);
 133         return rc;
 134 }
 135
 136 struct cpu_configure_sccb {
 137         struct sccb_header header;
 138 } __attribute__((packed, aligned(8)));
 139
 140 static int do_core_configure(sclp_cmdw_t cmd)
 141 {
 142         struct cpu_configure_sccb *sccb;
 143         int rc;
 144
 145         if (!SCLP_HAS_CPU_RECONFIG)
 146                 return -EOPNOTSUPP;
 147         /*
 148          * This is not going to cross a page boundary since we force
 149          * kmalloc to have a minimum alignment of 8 bytes on s390.
 150          */
 151         sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
 152         if (!sccb)
 153                 return -ENOMEM;
 154         sccb->header.length = sizeof(*sccb);
 155         rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
 156         if (rc)
 157                 goto out;
 158         switch (sccb->header.response_code) {
 159         case 0x0020:
 160         case 0x0120:
 161                 break;
 162         default:
 163                 pr_warn("configure cpu failed (cmd=0x%08x, response=0x%04x)\n",
 164                         cmd, sccb->header.response_code);
 165                 rc = -EIO;
 166                 break;
 167         }
 168 out:
 169         kfree(sccb);
 170         return rc;
 171 }
 172
 173 int sclp_core_configure(u8 core)
 174 {
 175         return do_core_configure(SCLP_CMDW_CONFIGURE_CPU | core << 8);
 176 }
 177
 178 int sclp_core_deconfigure(u8 core)
 179 {
 180         return do_core_configure(SCLP_CMDW_DECONFIGURE_CPU | core << 8);
 181 }
 182
 183 #ifdef CONFIG_MEMORY_HOTPLUG
 184
 185 static DEFINE_MUTEX(sclp_mem_mutex);
 186 static LIST_HEAD(sclp_mem_list);
 187 static u8 sclp_max_storage_id;
 188 static DECLARE_BITMAP(sclp_storage_ids, 256);
 189 static int sclp_mem_state_changed;
 190
 191 struct memory_increment {
 192         struct list_head list;
 193         u16 rn;
 194         int standby;
 195 };
 196
 197 struct assign_storage_sccb {
 198         struct sccb_header header;
 199         u16 rn;
 200 } __packed;
 201
 202 int arch_get_memory_phys_device(unsigned long start_pfn)
 203 {
 204         if (!sclp.rzm)
 205                 return 0;
 206         return PFN_PHYS(start_pfn) >> ilog2(sclp.rzm);
 207 }
 208
 209 static unsigned long long rn2addr(u16 rn)
 210 {
 211         return (unsigned long long) (rn - 1) * sclp.rzm;
 212 }
 213
 214 static int do_assign_storage(sclp_cmdw_t cmd, u16 rn)
 215 {
 216         struct assign_storage_sccb *sccb;
 217         int rc;
 218
 219         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 220         if (!sccb)
 221                 return -ENOMEM;
 222         sccb->header.length = PAGE_SIZE;
 223         sccb->rn = rn;
 224         rc = sclp_sync_request_timeout(cmd, sccb, SCLP_QUEUE_INTERVAL);
 225         if (rc)
 226                 goto out;
 227         switch (sccb->header.response_code) {
 228         case 0x0020:
 229         case 0x0120:
 230                 break;
 231         default:
 232                 pr_warn("assign storage failed (cmd=0x%08x, response=0x%04x, rn=0x%04x)\n",
 233                         cmd, sccb->header.response_code, rn);
 234                 rc = -EIO;
 235                 break;
 236         }
 237 out:
 238         free_page((unsigned long) sccb);
 239         return rc;
 240 }
 241
 242 static int sclp_assign_storage(u16 rn)
 243 {
 244         unsigned long long start;
 245         int rc;
 246
 247         rc = do_assign_storage(0x000d0001, rn);
 248         if (rc)
 249                 return rc;
 250         start = rn2addr(rn);
 251         storage_key_init_range(start, start + sclp.rzm);
 252         return 0;
 253 }
 254
 255 static int sclp_unassign_storage(u16 rn)
 256 {
 257         return do_assign_storage(0x000c0001, rn);
 258 }
 259
 260 struct attach_storage_sccb {
 261         struct sccb_header header;
 262         u16 :16;
 263         u16 assigned;
 264         u32 :32;
 265         u32 entries[0];
 266 } __packed;
 267
 268 static int sclp_attach_storage(u8 id)
 269 {
 270         struct attach_storage_sccb *sccb;
 271         int rc;
 272         int i;
 273
 274         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 275         if (!sccb)
 276                 return -ENOMEM;
 277         sccb->header.length = PAGE_SIZE;
 278         rc = sclp_sync_request_timeout(0x00080001 | id << 8, sccb,
 279                                        SCLP_QUEUE_INTERVAL);
 280         if (rc)
 281                 goto out;
 282         switch (sccb->header.response_code) {
 283         case 0x0020:
 284                 set_bit(id, sclp_storage_ids);
 285                 for (i = 0; i < sccb->assigned; i++) {
 286                         if (sccb->entries[i])
 287                                 sclp_unassign_storage(sccb->entries[i] >> 16);
 288                 }
 289                 break;
 290         default:
 291                 rc = -EIO;
 292                 break;
 293         }
 294 out:
 295         free_page((unsigned long) sccb);
 296         return rc;
 297 }
 298
 299 static int sclp_mem_change_state(unsigned long start, unsigned long size,
 300                                  int online)
 301 {
 302         struct memory_increment *incr;
 303         unsigned long long istart;
 304         int rc = 0;
 305
 306         list_for_each_entry(incr, &sclp_mem_list, list) {
 307                 istart = rn2addr(incr->rn);
 308                 if (start + size - 1 < istart)
 309                         break;
 310                 if (start > istart + sclp.rzm - 1)
 311                         continue;
 312                 if (online)
 313                         rc |= sclp_assign_storage(incr->rn);
 314                 else
 315                         sclp_unassign_storage(incr->rn);
 316                 if (rc == 0)
 317                         incr->standby = online ? 0 : 1;
 318         }
 319         return rc ? -EIO : 0;
 320 }
 321
 322 static bool contains_standby_increment(unsigned long start, unsigned long end)
 323 {
 324         struct memory_increment *incr;
 325         unsigned long istart;
 326
 327         list_for_each_entry(incr, &sclp_mem_list, list) {
 328                 istart = rn2addr(incr->rn);
 329                 if (end - 1 < istart)
 330                         continue;
 331                 if (start > istart + sclp.rzm - 1)
 332                         continue;
 333                 if (incr->standby)
 334                         return true;
 335         }
 336         return false;
 337 }
 338
 339 static int sclp_mem_notifier(struct notifier_block *nb,
 340                              unsigned long action, void *data)
 341 {
 342         unsigned long start, size;
 343         struct memory_notify *arg;
 344         unsigned char id;
 345         int rc = 0;
 346
 347         arg = data;
 348         start = arg->start_pfn << PAGE_SHIFT;
 349         size = arg->nr_pages << PAGE_SHIFT;
 350         mutex_lock(&sclp_mem_mutex);
 351         for_each_clear_bit(id, sclp_storage_ids, sclp_max_storage_id + 1)
 352                 sclp_attach_storage(id);
 353         switch (action) {
 354         case MEM_GOING_OFFLINE:
 355                 /*
 356                  * We do not allow to set memory blocks offline that contain
 357                  * standby memory. This is done to simplify the "memory online"
 358                  * case.
 359                  */
 360                 if (contains_standby_increment(start, start + size))
 361                         rc = -EPERM;
 362                 break;
 363         case MEM_ONLINE:
 364         case MEM_CANCEL_OFFLINE:
 365                 break;
 366         case MEM_GOING_ONLINE:
 367                 rc = sclp_mem_change_state(start, size, 1);
 368                 break;
 369         case MEM_CANCEL_ONLINE:
 370                 sclp_mem_change_state(start, size, 0);
 371                 break;
 372         case MEM_OFFLINE:
 373                 sclp_mem_change_state(start, size, 0);
 374                 break;
 375         default:
 376                 rc = -EINVAL;
 377                 break;
 378         }
 379         if (!rc)
 380                 sclp_mem_state_changed = 1;
 381         mutex_unlock(&sclp_mem_mutex);
 382         return rc ? NOTIFY_BAD : NOTIFY_OK;
 383 }
 384
 385 static struct notifier_block sclp_mem_nb = {
 386         .notifier_call = sclp_mem_notifier,
 387 };
 388
 389 static void __init align_to_block_size(unsigned long long *start,
 390                                        unsigned long long *size,
 391                                        unsigned long long alignment)
 392 {
 393         unsigned long long start_align, size_align;
 394
 395         start_align = roundup(*start, alignment);
 396         size_align = rounddown(*start + *size, alignment) - start_align;
 397
 398         pr_info("Standby memory at 0x%llx (%lluM of %lluM usable)\n",
 399                 *start, size_align >> 20, *size >> 20);
 400         *start = start_align;
 401         *size = size_align;
 402 }
 403
 404 static void __init add_memory_merged(u16 rn)
 405 {
 406         unsigned long long start, size, addr, block_size;
 407         static u16 first_rn, num;
 408
 409         if (rn && first_rn && (first_rn + num == rn)) {
 410                 num++;
 411                 return;
 412         }
 413         if (!first_rn)
 414                 goto skip_add;
 415         start = rn2addr(first_rn);
 416         size = (unsigned long long) num * sclp.rzm;
 417         if (start >= VMEM_MAX_PHYS)
 418                 goto skip_add;
 419         if (start + size > VMEM_MAX_PHYS)
 420                 size = VMEM_MAX_PHYS - start;
 421         if (memory_end_set && (start >= memory_end))
 422                 goto skip_add;
 423         if (memory_end_set && (start + size > memory_end))
 424                 size = memory_end - start;
 425         block_size = memory_block_size_bytes();
 426         align_to_block_size(&start, &size, block_size);
 427         if (!size)
 428                 goto skip_add;
 429         for (addr = start; addr < start + size; addr += block_size)
 430                 add_memory(numa_pfn_to_nid(PFN_DOWN(addr)), addr, block_size);
 431 skip_add:
 432         first_rn = rn;
 433         num = 1;
 434 }
 435
 436 static void __init sclp_add_standby_memory(void)
 437 {
 438         struct memory_increment *incr;
 439
 440         list_for_each_entry(incr, &sclp_mem_list, list)
 441                 if (incr->standby)
 442                         add_memory_merged(incr->rn);
 443         add_memory_merged(0);
 444 }
 445
 446 static void __init insert_increment(u16 rn, int standby, int assigned)
 447 {
 448         struct memory_increment *incr, *new_incr;
 449         struct list_head *prev;
 450         u16 last_rn;
 451
 452         new_incr = kzalloc(sizeof(*new_incr), GFP_KERNEL);
 453         if (!new_incr)
 454                 return;
 455         new_incr->rn = rn;
 456         new_incr->standby = standby;
 457         last_rn = 0;
 458         prev = &sclp_mem_list;
 459         list_for_each_entry(incr, &sclp_mem_list, list) {
 460                 if (assigned && incr->rn > rn)
 461                         break;
 462                 if (!assigned && incr->rn - last_rn > 1)
 463                         break;
 464                 last_rn = incr->rn;
 465                 prev = &incr->list;
 466         }
 467         if (!assigned)
 468                 new_incr->rn = last_rn + 1;
 469         if (new_incr->rn > sclp.rnmax) {
 470                 kfree(new_incr);
 471                 return;
 472         }
 473         list_add(&new_incr->list, prev);
 474 }
 475
 476 static int sclp_mem_freeze(struct device *dev)
 477 {
 478         if (!sclp_mem_state_changed)
 479                 return 0;
 480         pr_err("Memory hotplug state changed, suspend refused.\n");
 481         return -EPERM;
 482 }
 483
 484 struct read_storage_sccb {
 485         struct sccb_header header;
 486         u16 max_id;
 487         u16 assigned;
 488         u16 standby;
 489         u16 :16;
 490         u32 entries[0];
 491 } __packed;
 492
 493 static const struct dev_pm_ops sclp_mem_pm_ops = {
 494         .freeze         = sclp_mem_freeze,
 495 };
 496
 497 static struct platform_driver sclp_mem_pdrv = {
 498         .driver = {
 499                 .name   = "sclp_mem",
 500                 .pm     = &sclp_mem_pm_ops,
 501         },
 502 };
 503
 504 static int __init sclp_detect_standby_memory(void)
 505 {
 506         struct platform_device *sclp_pdev;
 507         struct read_storage_sccb *sccb;
 508         int i, id, assigned, rc;
 509
 510         if (OLDMEM_BASE) /* No standby memory in kdump mode */
 511                 return 0;
 512         if ((sclp.facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
 513                 return 0;
 514         rc = -ENOMEM;
 515         sccb = (void *) __get_free_page(GFP_KERNEL | GFP_DMA);
 516         if (!sccb)
 517                 goto out;
 518         assigned = 0;
 519         for (id = 0; id <= sclp_max_storage_id; id++) {
 520                 memset(sccb, 0, PAGE_SIZE);
 521                 sccb->header.length = PAGE_SIZE;
 522                 rc = sclp_sync_request(0x00040001 | id << 8, sccb);
 523                 if (rc)
 524                         goto out;
 525                 switch (sccb->header.response_code) {
 526                 case 0x0010:
 527                         set_bit(id, sclp_storage_ids);
 528                         for (i = 0; i < sccb->assigned; i++) {
 529                                 if (!sccb->entries[i])
 530                                         continue;
 531                                 assigned++;
 532                                 insert_increment(sccb->entries[i] >> 16, 0, 1);
 533                         }
 534                         break;
 535                 case 0x0310:
 536                         break;
 537                 case 0x0410:
 538                         for (i = 0; i < sccb->assigned; i++) {
 539                                 if (!sccb->entries[i])
 540                                         continue;
 541                                 assigned++;
 542                                 insert_increment(sccb->entries[i] >> 16, 1, 1);
 543                         }
 544                         break;
 545                 default:
 546                         rc = -EIO;
 547                         break;
 548                 }
 549                 if (!rc)
 550                         sclp_max_storage_id = sccb->max_id;
 551         }
 552         if (rc || list_empty(&sclp_mem_list))
 553                 goto out;
 554         for (i = 1; i <= sclp.rnmax - assigned; i++)
 555                 insert_increment(0, 1, 0);
 556         rc = register_memory_notifier(&sclp_mem_nb);
 557         if (rc)
 558                 goto out;
 559         rc = platform_driver_register(&sclp_mem_pdrv);
 560         if (rc)
 561                 goto out;
 562         sclp_pdev = platform_device_register_simple("sclp_mem", -1, NULL, 0);
 563         rc = PTR_ERR_OR_ZERO(sclp_pdev);
 564         if (rc)
 565                 goto out_driver;
 566         sclp_add_standby_memory();
 567         goto out;
 568 out_driver:
 569         platform_driver_unregister(&sclp_mem_pdrv);
 570 out:
 571         free_page((unsigned long) sccb);
 572         return rc;
 573 }
 574 __initcall(sclp_detect_standby_memory);
 575
 576 #endif /* CONFIG_MEMORY_HOTPLUG */
 577
 578 /*
 579  * Channel path configuration related functions.
 580  */
 581
 582 #define SCLP_CMDW_CONFIGURE_CHPATH              0x000f0001
 583 #define SCLP_CMDW_DECONFIGURE_CHPATH            0x000e0001
 584 #define SCLP_CMDW_READ_CHPATH_INFORMATION       0x00030001
 585
 586 struct chp_cfg_sccb {
 587         struct sccb_header header;
 588         u8 ccm;
 589         u8 reserved[6];
 590         u8 cssid;
 591 } __attribute__((packed));
 592
 593 static int do_chp_configure(sclp_cmdw_t cmd)
 594 {
 595         struct chp_cfg_sccb *sccb;
 596         int rc;
 597
 598         if (!SCLP_HAS_CHP_RECONFIG)
 599                 return -EOPNOTSUPP;
 600         /* Prepare sccb. */
 601         sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 602         if (!sccb)
 603                 return -ENOMEM;
 604         sccb->header.length = sizeof(*sccb);
 605         rc = sclp_sync_request(cmd, sccb);
 606         if (rc)
 607                 goto out;
 608         switch (sccb->header.response_code) {
 609         case 0x0020:
 610         case 0x0120:
 611         case 0x0440:
 612         case 0x0450:
 613                 break;
 614         default:
 615                 pr_warn("configure channel-path failed (cmd=0x%08x, response=0x%04x)\n",
 616                         cmd, sccb->header.response_code);
 617                 rc = -EIO;
 618                 break;
 619         }
 620 out:
 621         free_page((unsigned long) sccb);
 622         return rc;
 623 }
 624
 625 /**
 626  * sclp_chp_configure - perform configure channel-path sclp command
 627  * @chpid: channel-path ID
 628  *
 629  * Perform configure channel-path command sclp command for specified chpid.
 630  * Return 0 after command successfully finished, non-zero otherwise.
 631  */
 632 int sclp_chp_configure(struct chp_id chpid)
 633 {
 634         return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH | chpid.id << 8);
 635 }
 636
 637 /**
 638  * sclp_chp_deconfigure - perform deconfigure channel-path sclp command
 639  * @chpid: channel-path ID
 640  *
 641  * Perform deconfigure channel-path command sclp command for specified chpid
 642  * and wait for completion. On success return 0. Return non-zero otherwise.
 643  */
 644 int sclp_chp_deconfigure(struct chp_id chpid)
 645 {
 646         return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH | chpid.id << 8);
 647 }
 648
 649 struct chp_info_sccb {
 650         struct sccb_header header;
 651         u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
 652         u8 standby[SCLP_CHP_INFO_MASK_SIZE];
 653         u8 configured[SCLP_CHP_INFO_MASK_SIZE];
 654         u8 ccm;
 655         u8 reserved[6];
 656         u8 cssid;
 657 } __attribute__((packed));
 658
 659 /**
 660  * sclp_chp_read_info - perform read channel-path information sclp command
 661  * @info: resulting channel-path information data
 662  *
 663  * Perform read channel-path information sclp command and wait for completion.
 664  * On success, store channel-path information in @info and return 0. Return
 665  * non-zero otherwise.
 666  */
 667 int sclp_chp_read_info(struct sclp_chp_info *info)
 668 {
 669         struct chp_info_sccb *sccb;
 670         int rc;
 671
 672         if (!SCLP_HAS_CHP_INFO)
 673                 return -EOPNOTSUPP;
 674         /* Prepare sccb. */
 675         sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 676         if (!sccb)
 677                 return -ENOMEM;
 678         sccb->header.length = sizeof(*sccb);
 679         rc = sclp_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
 680         if (rc)
 681                 goto out;
 682         if (sccb->header.response_code != 0x0010) {
 683                 pr_warn("read channel-path info failed (response=0x%04x)\n",
 684                         sccb->header.response_code);
 685                 rc = -EIO;
 686                 goto out;
 687         }
 688         memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
 689         memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
 690         memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
 691 out:
 692         free_page((unsigned long) sccb);
 693         return rc;
 694 }