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 #include <linux/completion.h>
  10 #include <linux/init.h>
  11 #include <linux/errno.h>
  12 #include <linux/slab.h>
  13 #include <linux/string.h>
  14 #include <asm/chpid.h>
  15 #include <asm/sclp.h>
  16 #include "sclp.h"
  17
  18 #define TAG     "sclp_cmd: "
  19
  20 #define SCLP_CMDW_READ_SCP_INFO         0x00020001
  21 #define SCLP_CMDW_READ_SCP_INFO_FORCED  0x00120001
  22
  23 struct read_info_sccb {
  24         struct  sccb_header header;     /* 0-7 */
  25         u16     rnmax;                  /* 8-9 */
  26         u8      rnsize;                 /* 10 */
  27         u8      _reserved0[24 - 11];    /* 11-15 */
  28         u8      loadparm[8];            /* 24-31 */
  29         u8      _reserved1[48 - 32];    /* 32-47 */
  30         u64     facilities;             /* 48-55 */
  31         u8      _reserved2[84 - 56];    /* 56-83 */
  32         u8      fac84;                  /* 84 */
  33         u8      _reserved3[91 - 85];    /* 85-90 */
  34         u8      flags;                  /* 91 */
  35         u8      _reserved4[100 - 92];   /* 92-99 */
  36         u32     rnsize2;                /* 100-103 */
  37         u64     rnmax2;                 /* 104-111 */
  38         u8      _reserved5[4096 - 112]; /* 112-4095 */
  39 } __attribute__((packed, aligned(PAGE_SIZE)));
  40
  41 static struct read_info_sccb __initdata early_read_info_sccb;
  42 static int __initdata early_read_info_sccb_valid;
  43
  44 u64 sclp_facilities;
  45 static u8 sclp_fac84;
  46
  47 static int __init sclp_cmd_sync_early(sclp_cmdw_t cmd, void *sccb)
  48 {
  49         int rc;
  50
  51         __ctl_set_bit(0, 9);
  52         rc = sclp_service_call(cmd, sccb);
  53         if (rc)
  54                 goto out;
  55         __load_psw_mask(PSW_BASE_BITS | PSW_MASK_EXT |
  56                         PSW_MASK_WAIT | PSW_DEFAULT_KEY);
  57         local_irq_disable();
  58 out:
  59         /* Contents of the sccb might have changed. */
  60         barrier();
  61         __ctl_clear_bit(0, 9);
  62         return rc;
  63 }
  64
  65 void __init sclp_read_info_early(void)
  66 {
  67         int rc;
  68         int i;
  69         struct read_info_sccb *sccb;
  70         sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
  71                                   SCLP_CMDW_READ_SCP_INFO};
  72
  73         sccb = &early_read_info_sccb;
  74         for (i = 0; i < ARRAY_SIZE(commands); i++) {
  75                 do {
  76                         memset(sccb, 0, sizeof(*sccb));
  77                         sccb->header.length = sizeof(*sccb);
  78                         sccb->header.control_mask[2] = 0x80;
  79                         rc = sclp_cmd_sync_early(commands[i], sccb);
  80                 } while (rc == -EBUSY);
  81
  82                 if (rc)
  83                         break;
  84                 if (sccb->header.response_code == 0x10) {
  85                         early_read_info_sccb_valid = 1;
  86                         break;
  87                 }
  88                 if (sccb->header.response_code != 0x1f0)
  89                         break;
  90         }
  91 }
  92
  93 void __init sclp_facilities_detect(void)
  94 {
  95         if (!early_read_info_sccb_valid)
  96                 return;
  97         sclp_facilities = early_read_info_sccb.facilities;
  98         sclp_fac84 = early_read_info_sccb.fac84;
  99 }
 100
 101 unsigned long long __init sclp_memory_detect(void)
 102 {
 103         unsigned long long memsize;
 104         struct read_info_sccb *sccb;
 105
 106         if (!early_read_info_sccb_valid)
 107                 return 0;
 108         sccb = &early_read_info_sccb;
 109         if (sccb->rnsize)
 110                 memsize = sccb->rnsize << 20;
 111         else
 112                 memsize = sccb->rnsize2 << 20;
 113         if (sccb->rnmax)
 114                 memsize *= sccb->rnmax;
 115         else
 116                 memsize *= sccb->rnmax2;
 117         return memsize;
 118 }
 119
 120 /*
 121  * This function will be called after sclp_memory_detect(), which gets called
 122  * early from early.c code. Therefore the sccb should have valid contents.
 123  */
 124 void __init sclp_get_ipl_info(struct sclp_ipl_info *info)
 125 {
 126         struct read_info_sccb *sccb;
 127
 128         if (!early_read_info_sccb_valid)
 129                 return;
 130         sccb = &early_read_info_sccb;
 131         info->is_valid = 1;
 132         if (sccb->flags & 0x2)
 133                 info->has_dump = 1;
 134         memcpy(&info->loadparm, &sccb->loadparm, LOADPARM_LEN);
 135 }
 136
 137 static void sclp_sync_callback(struct sclp_req *req, void *data)
 138 {
 139         struct completion *completion = data;
 140
 141         complete(completion);
 142 }
 143
 144 static int do_sync_request(sclp_cmdw_t cmd, void *sccb)
 145 {
 146         struct completion completion;
 147         struct sclp_req *request;
 148         int rc;
 149
 150         request = kzalloc(sizeof(*request), GFP_KERNEL);
 151         if (!request)
 152                 return -ENOMEM;
 153         request->command = cmd;
 154         request->sccb = sccb;
 155         request->status = SCLP_REQ_FILLED;
 156         request->callback = sclp_sync_callback;
 157         request->callback_data = &completion;
 158         init_completion(&completion);
 159
 160         /* Perform sclp request. */
 161         rc = sclp_add_request(request);
 162         if (rc)
 163                 goto out;
 164         wait_for_completion(&completion);
 165
 166         /* Check response. */
 167         if (request->status != SCLP_REQ_DONE) {
 168                 printk(KERN_WARNING TAG "sync request failed "
 169                        "(cmd=0x%08x, status=0x%02x)\n", cmd, request->status);
 170                 rc = -EIO;
 171         }
 172 out:
 173         kfree(request);
 174         return rc;
 175 }
 176
 177 /*
 178  * CPU configuration related functions.
 179  */
 180
 181 #define SCLP_CMDW_READ_CPU_INFO         0x00010001
 182 #define SCLP_CMDW_CONFIGURE_CPU         0x00110001
 183 #define SCLP_CMDW_DECONFIGURE_CPU       0x00100001
 184
 185 struct read_cpu_info_sccb {
 186         struct  sccb_header header;
 187         u16     nr_configured;
 188         u16     offset_configured;
 189         u16     nr_standby;
 190         u16     offset_standby;
 191         u8      reserved[4096 - 16];
 192 } __attribute__((packed, aligned(PAGE_SIZE)));
 193
 194 static void sclp_fill_cpu_info(struct sclp_cpu_info *info,
 195                                struct read_cpu_info_sccb *sccb)
 196 {
 197         char *page = (char *) sccb;
 198
 199         memset(info, 0, sizeof(*info));
 200         info->configured = sccb->nr_configured;
 201         info->standby = sccb->nr_standby;
 202         info->combined = sccb->nr_configured + sccb->nr_standby;
 203         info->has_cpu_type = sclp_fac84 & 0x1;
 204         memcpy(&info->cpu, page + sccb->offset_configured,
 205                info->combined * sizeof(struct sclp_cpu_entry));
 206 }
 207
 208 int sclp_get_cpu_info(struct sclp_cpu_info *info)
 209 {
 210         int rc;
 211         struct read_cpu_info_sccb *sccb;
 212
 213         if (!SCLP_HAS_CPU_INFO)
 214                 return -EOPNOTSUPP;
 215         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 216         if (!sccb)
 217                 return -ENOMEM;
 218         sccb->header.length = sizeof(*sccb);
 219         rc = do_sync_request(SCLP_CMDW_READ_CPU_INFO, sccb);
 220         if (rc)
 221                 goto out;
 222         if (sccb->header.response_code != 0x0010) {
 223                 printk(KERN_WARNING TAG "readcpuinfo failed "
 224                        "(response=0x%04x)\n", sccb->header.response_code);
 225                 rc = -EIO;
 226                 goto out;
 227         }
 228         sclp_fill_cpu_info(info, sccb);
 229 out:
 230         free_page((unsigned long) sccb);
 231         return rc;
 232 }
 233
 234 struct cpu_configure_sccb {
 235         struct sccb_header header;
 236 } __attribute__((packed, aligned(8)));
 237
 238 static int do_cpu_configure(sclp_cmdw_t cmd)
 239 {
 240         struct cpu_configure_sccb *sccb;
 241         int rc;
 242
 243         if (!SCLP_HAS_CPU_RECONFIG)
 244                 return -EOPNOTSUPP;
 245         /*
 246          * This is not going to cross a page boundary since we force
 247          * kmalloc to have a minimum alignment of 8 bytes on s390.
 248          */
 249         sccb = kzalloc(sizeof(*sccb), GFP_KERNEL | GFP_DMA);
 250         if (!sccb)
 251                 return -ENOMEM;
 252         sccb->header.length = sizeof(*sccb);
 253         rc = do_sync_request(cmd, sccb);
 254         if (rc)
 255                 goto out;
 256         switch (sccb->header.response_code) {
 257         case 0x0020:
 258         case 0x0120:
 259                 break;
 260         default:
 261                 printk(KERN_WARNING TAG "configure cpu failed (cmd=0x%08x, "
 262                        "response=0x%04x)\n", cmd, sccb->header.response_code);
 263                 rc = -EIO;
 264                 break;
 265         }
 266 out:
 267         kfree(sccb);
 268         return rc;
 269 }
 270
 271 int sclp_cpu_configure(u8 cpu)
 272 {
 273         return do_cpu_configure(SCLP_CMDW_CONFIGURE_CPU | cpu << 8);
 274 }
 275
 276 int sclp_cpu_deconfigure(u8 cpu)
 277 {
 278         return do_cpu_configure(SCLP_CMDW_DECONFIGURE_CPU | cpu << 8);
 279 }
 280
 281 /*
 282  * Channel path configuration related functions.
 283  */
 284
 285 #define SCLP_CMDW_CONFIGURE_CHPATH              0x000f0001
 286 #define SCLP_CMDW_DECONFIGURE_CHPATH            0x000e0001
 287 #define SCLP_CMDW_READ_CHPATH_INFORMATION       0x00030001
 288
 289 struct chp_cfg_sccb {
 290         struct sccb_header header;
 291         u8 ccm;
 292         u8 reserved[6];
 293         u8 cssid;
 294 } __attribute__((packed));
 295
 296 static int do_chp_configure(sclp_cmdw_t cmd)
 297 {
 298         struct chp_cfg_sccb *sccb;
 299         int rc;
 300
 301         if (!SCLP_HAS_CHP_RECONFIG)
 302                 return -EOPNOTSUPP;
 303         /* Prepare sccb. */
 304         sccb = (struct chp_cfg_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 305         if (!sccb)
 306                 return -ENOMEM;
 307         sccb->header.length = sizeof(*sccb);
 308         rc = do_sync_request(cmd, sccb);
 309         if (rc)
 310                 goto out;
 311         switch (sccb->header.response_code) {
 312         case 0x0020:
 313         case 0x0120:
 314         case 0x0440:
 315         case 0x0450:
 316                 break;
 317         default:
 318                 printk(KERN_WARNING TAG "configure channel-path failed "
 319                        "(cmd=0x%08x, response=0x%04x)\n", cmd,
 320                        sccb->header.response_code);
 321                 rc = -EIO;
 322                 break;
 323         }
 324 out:
 325         free_page((unsigned long) sccb);
 326         return rc;
 327 }
 328
 329 /**
 330  * sclp_chp_configure - perform configure channel-path sclp command
 331  * @chpid: channel-path ID
 332  *
 333  * Perform configure channel-path command sclp command for specified chpid.
 334  * Return 0 after command successfully finished, non-zero otherwise.
 335  */
 336 int sclp_chp_configure(struct chp_id chpid)
 337 {
 338         return do_chp_configure(SCLP_CMDW_CONFIGURE_CHPATH | chpid.id << 8);
 339 }
 340
 341 /**
 342  * sclp_chp_deconfigure - perform deconfigure channel-path sclp command
 343  * @chpid: channel-path ID
 344  *
 345  * Perform deconfigure channel-path command sclp command for specified chpid
 346  * and wait for completion. On success return 0. Return non-zero otherwise.
 347  */
 348 int sclp_chp_deconfigure(struct chp_id chpid)
 349 {
 350         return do_chp_configure(SCLP_CMDW_DECONFIGURE_CHPATH | chpid.id << 8);
 351 }
 352
 353 struct chp_info_sccb {
 354         struct sccb_header header;
 355         u8 recognized[SCLP_CHP_INFO_MASK_SIZE];
 356         u8 standby[SCLP_CHP_INFO_MASK_SIZE];
 357         u8 configured[SCLP_CHP_INFO_MASK_SIZE];
 358         u8 ccm;
 359         u8 reserved[6];
 360         u8 cssid;
 361 } __attribute__((packed));
 362
 363 /**
 364  * sclp_chp_read_info - perform read channel-path information sclp command
 365  * @info: resulting channel-path information data
 366  *
 367  * Perform read channel-path information sclp command and wait for completion.
 368  * On success, store channel-path information in @info and return 0. Return
 369  * non-zero otherwise.
 370  */
 371 int sclp_chp_read_info(struct sclp_chp_info *info)
 372 {
 373         struct chp_info_sccb *sccb;
 374         int rc;
 375
 376         if (!SCLP_HAS_CHP_INFO)
 377                 return -EOPNOTSUPP;
 378         /* Prepare sccb. */
 379         sccb = (struct chp_info_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 380         if (!sccb)
 381                 return -ENOMEM;
 382         sccb->header.length = sizeof(*sccb);
 383         rc = do_sync_request(SCLP_CMDW_READ_CHPATH_INFORMATION, sccb);
 384         if (rc)
 385                 goto out;
 386         if (sccb->header.response_code != 0x0010) {
 387                 printk(KERN_WARNING TAG "read channel-path info failed "
 388                        "(response=0x%04x)\n", sccb->header.response_code);
 389                 rc = -EIO;
 390                 goto out;
 391         }
 392         memcpy(info->recognized, sccb->recognized, SCLP_CHP_INFO_MASK_SIZE);
 393         memcpy(info->standby, sccb->standby, SCLP_CHP_INFO_MASK_SIZE);
 394         memcpy(info->configured, sccb->configured, SCLP_CHP_INFO_MASK_SIZE);
 395 out:
 396         free_page((unsigned long) sccb);
 397         return rc;
 398 }