drivers/s390/char/sclp_cmd.c

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