drivers/s390/cio/chsc.c

   1 /*
   2  *  drivers/s390/cio/chsc.c
   3  *   S/390 common I/O routines -- channel subsystem call
   4  *
   5  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
   6  *                            IBM Corporation
   7  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
   8  *               Cornelia Huck (cornelia.huck@de.ibm.com)
   9  *               Arnd Bergmann (arndb@de.ibm.com)
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/init.h>
  15 #include <linux/device.h>
  16
  17 #include <asm/cio.h>
  18 #include <asm/chpid.h>
  19
  20 #include "css.h"
  21 #include "cio.h"
  22 #include "cio_debug.h"
  23 #include "ioasm.h"
  24 #include "chp.h"
  25 #include "chsc.h"
  26
  27 static void *sei_page;
  28
  29 struct chsc_ssd_area {
  30         struct chsc_header request;
  31         u16 :10;
  32         u16 ssid:2;
  33         u16 :4;
  34         u16 f_sch;        /* first subchannel */
  35         u16 :16;
  36         u16 l_sch;        /* last subchannel */
  37         u32 :32;
  38         struct chsc_header response;
  39         u32 :32;
  40         u8 sch_valid : 1;
  41         u8 dev_valid : 1;
  42         u8 st        : 3; /* subchannel type */
  43         u8 zeroes    : 3;
  44         u8  unit_addr;    /* unit address */
  45         u16 devno;        /* device number */
  46         u8 path_mask;
  47         u8 fla_valid_mask;
  48         u16 sch;          /* subchannel */
  49         u8 chpid[8];      /* chpids 0-7 */
  50         u16 fla[8];       /* full link addresses 0-7 */
  51 } __attribute__ ((packed));
  52
  53 int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
  54 {
  55         unsigned long page;
  56         struct chsc_ssd_area *ssd_area;
  57         int ccode;
  58         int ret;
  59         int i;
  60         int mask;
  61
  62         page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
  63         if (!page)
  64                 return -ENOMEM;
  65         ssd_area = (struct chsc_ssd_area *) page;
  66         ssd_area->request.length = 0x0010;
  67         ssd_area->request.code = 0x0004;
  68         ssd_area->ssid = schid.ssid;
  69         ssd_area->f_sch = schid.sch_no;
  70         ssd_area->l_sch = schid.sch_no;
  71
  72         ccode = chsc(ssd_area);
  73         /* Check response. */
  74         if (ccode > 0) {
  75                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
  76                 goto out_free;
  77         }
  78         if (ssd_area->response.code != 0x0001) {
  79                 CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
  80                               schid.ssid, schid.sch_no,
  81                               ssd_area->response.code);
  82                 ret = -EIO;
  83                 goto out_free;
  84         }
  85         if (!ssd_area->sch_valid) {
  86                 ret = -ENODEV;
  87                 goto out_free;
  88         }
  89         /* Copy data */
  90         ret = 0;
  91         memset(ssd, 0, sizeof(struct chsc_ssd_info));
  92         if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
  93             (ssd_area->st != SUBCHANNEL_TYPE_MSG))
  94                 goto out_free;
  95         ssd->path_mask = ssd_area->path_mask;
  96         ssd->fla_valid_mask = ssd_area->fla_valid_mask;
  97         for (i = 0; i < 8; i++) {
  98                 mask = 0x80 >> i;
  99                 if (ssd_area->path_mask & mask) {
 100                         chp_id_init(&ssd->chpid[i]);
 101                         ssd->chpid[i].id = ssd_area->chpid[i];
 102                 }
 103                 if (ssd_area->fla_valid_mask & mask)
 104                         ssd->fla[i] = ssd_area->fla[i];
 105         }
 106 out_free:
 107         free_page(page);
 108         return ret;
 109 }
 110
 111 static int check_for_io_on_path(struct subchannel *sch, int mask)
 112 {
 113         int cc;
 114
 115         cc = stsch(sch->schid, &sch->schib);
 116         if (cc)
 117                 return 0;
 118         if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == mask)
 119                 return 1;
 120         return 0;
 121 }
 122
 123 static void terminate_internal_io(struct subchannel *sch)
 124 {
 125         if (cio_clear(sch)) {
 126                 /* Recheck device in case clear failed. */
 127                 sch->lpm = 0;
 128                 if (device_trigger_verify(sch) != 0)
 129                         css_schedule_eval(sch->schid);
 130                 return;
 131         }
 132         /* Request retry of internal operation. */
 133         device_set_intretry(sch);
 134         /* Call handler. */
 135         if (sch->driver && sch->driver->termination)
 136                 sch->driver->termination(sch);
 137 }
 138
 139 static int s390_subchannel_remove_chpid(struct subchannel *sch, void *data)
 140 {
 141         int j;
 142         int mask;
 143         struct chp_id *chpid = data;
 144         struct schib schib;
 145
 146         for (j = 0; j < 8; j++) {
 147                 mask = 0x80 >> j;
 148                 if ((sch->schib.pmcw.pim & mask) &&
 149                     (sch->schib.pmcw.chpid[j] == chpid->id))
 150                         break;
 151         }
 152         if (j >= 8)
 153                 return 0;
 154
 155         spin_lock_irq(sch->lock);
 156
 157         stsch(sch->schid, &schib);
 158         if (!css_sch_is_valid(&schib))
 159                 goto out_unreg;
 160         memcpy(&sch->schib, &schib, sizeof(struct schib));
 161         /* Check for single path devices. */
 162         if (sch->schib.pmcw.pim == 0x80)
 163                 goto out_unreg;
 164
 165         if (check_for_io_on_path(sch, mask)) {
 166                 if (device_is_online(sch))
 167                         device_kill_io(sch);
 168                 else {
 169                         terminate_internal_io(sch);
 170                         /* Re-start path verification. */
 171                         if (sch->driver && sch->driver->verify)
 172                                 sch->driver->verify(sch);
 173                 }
 174         } else {
 175                 /* trigger path verification. */
 176                 if (sch->driver && sch->driver->verify)
 177                         sch->driver->verify(sch);
 178                 else if (sch->lpm == mask)
 179                         goto out_unreg;
 180         }
 181
 182         spin_unlock_irq(sch->lock);
 183         return 0;
 184
 185 out_unreg:
 186         sch->lpm = 0;
 187         spin_unlock_irq(sch->lock);
 188         css_schedule_eval(sch->schid);
 189         return 0;
 190 }
 191
 192 void chsc_chp_offline(struct chp_id chpid)
 193 {
 194         char dbf_txt[15];
 195
 196         sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);
 197         CIO_TRACE_EVENT(2, dbf_txt);
 198
 199         if (chp_get_status(chpid) <= 0)
 200                 return;
 201         for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &chpid);
 202 }
 203
 204 static int s390_process_res_acc_new_sch(struct subchannel_id schid, void *data)
 205 {
 206         struct schib schib;
 207         /*
 208          * We don't know the device yet, but since a path
 209          * may be available now to the device we'll have
 210          * to do recognition again.
 211          * Since we don't have any idea about which chpid
 212          * that beast may be on we'll have to do a stsch
 213          * on all devices, grr...
 214          */
 215         if (stsch_err(schid, &schib))
 216                 /* We're through */
 217                 return -ENXIO;
 218
 219         /* Put it on the slow path. */
 220         css_schedule_eval(schid);
 221         return 0;
 222 }
 223
 224 struct res_acc_data {
 225         struct chp_id chpid;
 226         u32 fla_mask;
 227         u16 fla;
 228 };
 229
 230 static int get_res_chpid_mask(struct chsc_ssd_info *ssd,
 231                               struct res_acc_data *data)
 232 {
 233         int i;
 234         int mask;
 235
 236         for (i = 0; i < 8; i++) {
 237                 mask = 0x80 >> i;
 238                 if (!(ssd->path_mask & mask))
 239                         continue;
 240                 if (!chp_id_is_equal(&ssd->chpid[i], &data->chpid))
 241                         continue;
 242                 if ((ssd->fla_valid_mask & mask) &&
 243                     ((ssd->fla[i] & data->fla_mask) != data->fla))
 244                         continue;
 245                 return mask;
 246         }
 247         return 0;
 248 }
 249
 250 static int __s390_process_res_acc(struct subchannel *sch, void *data)
 251 {
 252         int chp_mask, old_lpm;
 253         struct res_acc_data *res_data = data;
 254
 255         spin_lock_irq(sch->lock);
 256         chp_mask = get_res_chpid_mask(&sch->ssd_info, res_data);
 257         if (chp_mask == 0)
 258                 goto out;
 259         if (stsch(sch->schid, &sch->schib))
 260                 goto out;
 261         old_lpm = sch->lpm;
 262         sch->lpm = ((sch->schib.pmcw.pim &
 263                      sch->schib.pmcw.pam &
 264                      sch->schib.pmcw.pom)
 265                     | chp_mask) & sch->opm;
 266         if (!old_lpm && sch->lpm)
 267                 device_trigger_reprobe(sch);
 268         else if (sch->driver && sch->driver->verify)
 269                 sch->driver->verify(sch);
 270 out:
 271         spin_unlock_irq(sch->lock);
 272
 273         return 0;
 274 }
 275
 276 static void s390_process_res_acc (struct res_acc_data *res_data)
 277 {
 278         char dbf_txt[15];
 279
 280         sprintf(dbf_txt, "accpr%x.%02x", res_data->chpid.cssid,
 281                 res_data->chpid.id);
 282         CIO_TRACE_EVENT( 2, dbf_txt);
 283         if (res_data->fla != 0) {
 284                 sprintf(dbf_txt, "fla%x", res_data->fla);
 285                 CIO_TRACE_EVENT( 2, dbf_txt);
 286         }
 287
 288         /*
 289          * I/O resources may have become accessible.
 290          * Scan through all subchannels that may be concerned and
 291          * do a validation on those.
 292          * The more information we have (info), the less scanning
 293          * will we have to do.
 294          */
 295         for_each_subchannel_staged(__s390_process_res_acc,
 296                                    s390_process_res_acc_new_sch, res_data);
 297 }
 298
 299 static int
 300 __get_chpid_from_lir(void *data)
 301 {
 302         struct lir {
 303                 u8  iq;
 304                 u8  ic;
 305                 u16 sci;
 306                 /* incident-node descriptor */
 307                 u32 indesc[28];
 308                 /* attached-node descriptor */
 309                 u32 andesc[28];
 310                 /* incident-specific information */
 311                 u32 isinfo[28];
 312         } __attribute__ ((packed)) *lir;
 313
 314         lir = data;
 315         if (!(lir->iq&0x80))
 316                 /* NULL link incident record */
 317                 return -EINVAL;
 318         if (!(lir->indesc[0]&0xc0000000))
 319                 /* node descriptor not valid */
 320                 return -EINVAL;
 321         if (!(lir->indesc[0]&0x10000000))
 322                 /* don't handle device-type nodes - FIXME */
 323                 return -EINVAL;
 324         /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
 325
 326         return (u16) (lir->indesc[0]&0x000000ff);
 327 }
 328
 329 struct chsc_sei_area {
 330         struct chsc_header request;
 331         u32 reserved1;
 332         u32 reserved2;
 333         u32 reserved3;
 334         struct chsc_header response;
 335         u32 reserved4;
 336         u8  flags;
 337         u8  vf;         /* validity flags */
 338         u8  rs;         /* reporting source */
 339         u8  cc;         /* content code */
 340         u16 fla;        /* full link address */
 341         u16 rsid;       /* reporting source id */
 342         u32 reserved5;
 343         u32 reserved6;
 344         u8 ccdf[4096 - 16 - 24];        /* content-code dependent field */
 345         /* ccdf has to be big enough for a link-incident record */
 346 } __attribute__ ((packed));
 347
 348 static void chsc_process_sei_link_incident(struct chsc_sei_area *sei_area)
 349 {
 350         struct chp_id chpid;
 351         int id;
 352
 353         CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n",
 354                       sei_area->rs, sei_area->rsid);
 355         if (sei_area->rs != 4)
 356                 return;
 357         id = __get_chpid_from_lir(sei_area->ccdf);
 358         if (id < 0)
 359                 CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n");
 360         else {
 361                 chp_id_init(&chpid);
 362                 chpid.id = id;
 363                 chsc_chp_offline(chpid);
 364         }
 365 }
 366
 367 static void chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)
 368 {
 369         struct res_acc_data res_data;
 370         struct chp_id chpid;
 371         int status;
 372
 373         CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
 374                       "rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
 375         if (sei_area->rs != 4)
 376                 return;
 377         chp_id_init(&chpid);
 378         chpid.id = sei_area->rsid;
 379         /* allocate a new channel path structure, if needed */
 380         status = chp_get_status(chpid);
 381         if (status < 0)
 382                 chp_new(chpid);
 383         else if (!status)
 384                 return;
 385         memset(&res_data, 0, sizeof(struct res_acc_data));
 386         res_data.chpid = chpid;
 387         if ((sei_area->vf & 0xc0) != 0) {
 388                 res_data.fla = sei_area->fla;
 389                 if ((sei_area->vf & 0xc0) == 0xc0)
 390                         /* full link address */
 391                         res_data.fla_mask = 0xffff;
 392                 else
 393                         /* link address */
 394                         res_data.fla_mask = 0xff00;
 395         }
 396         s390_process_res_acc(&res_data);
 397 }
 398
 399 struct chp_config_data {
 400         u8 map[32];
 401         u8 op;
 402         u8 pc;
 403 };
 404
 405 static void chsc_process_sei_chp_config(struct chsc_sei_area *sei_area)
 406 {
 407         struct chp_config_data *data;
 408         struct chp_id chpid;
 409         int num;
 410
 411         CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
 412         if (sei_area->rs != 0)
 413                 return;
 414         data = (struct chp_config_data *) &(sei_area->ccdf);
 415         chp_id_init(&chpid);
 416         for (num = 0; num <= __MAX_CHPID; num++) {
 417                 if (!chp_test_bit(data->map, num))
 418                         continue;
 419                 chpid.id = num;
 420                 printk(KERN_WARNING "cio: processing configure event %d for "
 421                        "chpid %x.%02x\n", data->op, chpid.cssid, chpid.id);
 422                 switch (data->op) {
 423                 case 0:
 424                         chp_cfg_schedule(chpid, 1);
 425                         break;
 426                 case 1:
 427                         chp_cfg_schedule(chpid, 0);
 428                         break;
 429                 case 2:
 430                         chp_cfg_cancel_deconfigure(chpid);
 431                         break;
 432                 }
 433         }
 434 }
 435
 436 static void chsc_process_sei(struct chsc_sei_area *sei_area)
 437 {
 438         /* Check if we might have lost some information. */
 439         if (sei_area->flags & 0x40) {
 440                 CIO_CRW_EVENT(2, "chsc: event overflow\n");
 441                 css_schedule_eval_all();
 442         }
 443         /* which kind of information was stored? */
 444         switch (sei_area->cc) {
 445         case 1: /* link incident*/
 446                 chsc_process_sei_link_incident(sei_area);
 447                 break;
 448         case 2: /* i/o resource accessibiliy */
 449                 chsc_process_sei_res_acc(sei_area);
 450                 break;
 451         case 8: /* channel-path-configuration notification */
 452                 chsc_process_sei_chp_config(sei_area);
 453                 break;
 454         default: /* other stuff */
 455                 CIO_CRW_EVENT(4, "chsc: unhandled sei content code %d\n",
 456                               sei_area->cc);
 457                 break;
 458         }
 459 }
 460
 461 void chsc_process_crw(void)
 462 {
 463         struct chsc_sei_area *sei_area;
 464
 465         if (!sei_page)
 466                 return;
 467         /* Access to sei_page is serialized through machine check handler
 468          * thread, so no need for locking. */
 469         sei_area = sei_page;
 470
 471         CIO_TRACE_EVENT( 2, "prcss");
 472         do {
 473                 memset(sei_area, 0, sizeof(*sei_area));
 474                 sei_area->request.length = 0x0010;
 475                 sei_area->request.code = 0x000e;
 476                 if (chsc(sei_area))
 477                         break;
 478
 479                 if (sei_area->response.code == 0x0001) {
 480                         CIO_CRW_EVENT(4, "chsc: sei successful\n");
 481                         chsc_process_sei(sei_area);
 482                 } else {
 483                         CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n",
 484                                       sei_area->response.code);
 485                         break;
 486                 }
 487         } while (sei_area->flags & 0x80);
 488 }
 489
 490 static int __chp_add_new_sch(struct subchannel_id schid, void *data)
 491 {
 492         struct schib schib;
 493
 494         if (stsch_err(schid, &schib))
 495                 /* We're through */
 496                 return -ENXIO;
 497
 498         /* Put it on the slow path. */
 499         css_schedule_eval(schid);
 500         return 0;
 501 }
 502
 503
 504 static int __chp_add(struct subchannel *sch, void *data)
 505 {
 506         int i, mask;
 507         struct chp_id *chpid = data;
 508
 509         spin_lock_irq(sch->lock);
 510         for (i=0; i<8; i++) {
 511                 mask = 0x80 >> i;
 512                 if ((sch->schib.pmcw.pim & mask) &&
 513                     (sch->schib.pmcw.chpid[i] == chpid->id))
 514                         break;
 515         }
 516         if (i==8) {
 517                 spin_unlock_irq(sch->lock);
 518                 return 0;
 519         }
 520         if (stsch(sch->schid, &sch->schib)) {
 521                 spin_unlock_irq(sch->lock);
 522                 css_schedule_eval(sch->schid);
 523                 return 0;
 524         }
 525         sch->lpm = ((sch->schib.pmcw.pim &
 526                      sch->schib.pmcw.pam &
 527                      sch->schib.pmcw.pom)
 528                     | mask) & sch->opm;
 529
 530         if (sch->driver && sch->driver->verify)
 531                 sch->driver->verify(sch);
 532
 533         spin_unlock_irq(sch->lock);
 534
 535         return 0;
 536 }
 537
 538 void chsc_chp_online(struct chp_id chpid)
 539 {
 540         char dbf_txt[15];
 541
 542         sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);
 543         CIO_TRACE_EVENT(2, dbf_txt);
 544
 545         if (chp_get_status(chpid) != 0)
 546                 for_each_subchannel_staged(__chp_add, __chp_add_new_sch,
 547                                            &chpid);
 548 }
 549
 550 static void __s390_subchannel_vary_chpid(struct subchannel *sch,
 551                                          struct chp_id chpid, int on)
 552 {
 553         int chp, old_lpm;
 554         int mask;
 555         unsigned long flags;
 556
 557         spin_lock_irqsave(sch->lock, flags);
 558         old_lpm = sch->lpm;
 559         for (chp = 0; chp < 8; chp++) {
 560                 mask = 0x80 >> chp;
 561                 if (!(sch->ssd_info.path_mask & mask))
 562                         continue;
 563                 if (!chp_id_is_equal(&sch->ssd_info.chpid[chp], &chpid))
 564                         continue;
 565
 566                 if (on) {
 567                         sch->opm |= mask;
 568                         sch->lpm |= mask;
 569                         if (!old_lpm)
 570                                 device_trigger_reprobe(sch);
 571                         else if (sch->driver && sch->driver->verify)
 572                                 sch->driver->verify(sch);
 573                         break;
 574                 }
 575                 sch->opm &= ~mask;
 576                 sch->lpm &= ~mask;
 577                 if (check_for_io_on_path(sch, mask)) {
 578                         if (device_is_online(sch))
 579                                 /* Path verification is done after killing. */
 580                                 device_kill_io(sch);
 581                         else {
 582                                 /* Kill and retry internal I/O. */
 583                                 terminate_internal_io(sch);
 584                                 /* Re-start path verification. */
 585                                 if (sch->driver && sch->driver->verify)
 586                                         sch->driver->verify(sch);
 587                         }
 588                 } else if (!sch->lpm) {
 589                         if (device_trigger_verify(sch) != 0)
 590                                 css_schedule_eval(sch->schid);
 591                 } else if (sch->driver && sch->driver->verify)
 592                         sch->driver->verify(sch);
 593                 break;
 594         }
 595         spin_unlock_irqrestore(sch->lock, flags);
 596 }
 597
 598 static int s390_subchannel_vary_chpid_off(struct subchannel *sch, void *data)
 599 {
 600         struct chp_id *chpid = data;
 601
 602         __s390_subchannel_vary_chpid(sch, *chpid, 0);
 603         return 0;
 604 }
 605
 606 static int s390_subchannel_vary_chpid_on(struct subchannel *sch, void *data)
 607 {
 608         struct chp_id *chpid = data;
 609
 610         __s390_subchannel_vary_chpid(sch, *chpid, 1);
 611         return 0;
 612 }
 613
 614 static int
 615 __s390_vary_chpid_on(struct subchannel_id schid, void *data)
 616 {
 617         struct schib schib;
 618
 619         if (stsch_err(schid, &schib))
 620                 /* We're through */
 621                 return -ENXIO;
 622         /* Put it on the slow path. */
 623         css_schedule_eval(schid);
 624         return 0;
 625 }
 626
 627 /**
 628  * chsc_chp_vary - propagate channel-path vary operation to subchannels
 629  * @chpid: channl-path ID
 630  * @on: non-zero for vary online, zero for vary offline
 631  */
 632 int chsc_chp_vary(struct chp_id chpid, int on)
 633 {
 634         /*
 635          * Redo PathVerification on the devices the chpid connects to
 636          */
 637
 638         if (on)
 639                 for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
 640                                            __s390_vary_chpid_on, &chpid);
 641         else
 642                 for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
 643                                            NULL, &chpid);
 644
 645         return 0;
 646 }
 647
 648 static void
 649 chsc_remove_cmg_attr(struct channel_subsystem *css)
 650 {
 651         int i;
 652
 653         for (i = 0; i <= __MAX_CHPID; i++) {
 654                 if (!css->chps[i])
 655                         continue;
 656                 chp_remove_cmg_attr(css->chps[i]);
 657         }
 658 }
 659
 660 static int
 661 chsc_add_cmg_attr(struct channel_subsystem *css)
 662 {
 663         int i, ret;
 664
 665         ret = 0;
 666         for (i = 0; i <= __MAX_CHPID; i++) {
 667                 if (!css->chps[i])
 668                         continue;
 669                 ret = chp_add_cmg_attr(css->chps[i]);
 670                 if (ret)
 671                         goto cleanup;
 672         }
 673         return ret;
 674 cleanup:
 675         for (--i; i >= 0; i--) {
 676                 if (!css->chps[i])
 677                         continue;
 678                 chp_remove_cmg_attr(css->chps[i]);
 679         }
 680         return ret;
 681 }
 682
 683 static int
 684 __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
 685 {
 686         struct {
 687                 struct chsc_header request;
 688                 u32 operation_code : 2;
 689                 u32 : 30;
 690                 u32 key : 4;
 691                 u32 : 28;
 692                 u32 zeroes1;
 693                 u32 cub_addr1;
 694                 u32 zeroes2;
 695                 u32 cub_addr2;
 696                 u32 reserved[13];
 697                 struct chsc_header response;
 698                 u32 status : 8;
 699                 u32 : 4;
 700                 u32 fmt : 4;
 701                 u32 : 16;
 702         } __attribute__ ((packed)) *secm_area;
 703         int ret, ccode;
 704
 705         secm_area = page;
 706         secm_area->request.length = 0x0050;
 707         secm_area->request.code = 0x0016;
 708
 709         secm_area->key = PAGE_DEFAULT_KEY;
 710         secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
 711         secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
 712
 713         secm_area->operation_code = enable ? 0 : 1;
 714
 715         ccode = chsc(secm_area);
 716         if (ccode > 0)
 717                 return (ccode == 3) ? -ENODEV : -EBUSY;
 718
 719         switch (secm_area->response.code) {
 720         case 0x0001: /* Success. */
 721                 ret = 0;
 722                 break;
 723         case 0x0003: /* Invalid block. */
 724         case 0x0007: /* Invalid format. */
 725         case 0x0008: /* Other invalid block. */
 726                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
 727                 ret = -EINVAL;
 728                 break;
 729         case 0x0004: /* Command not provided in model. */
 730                 CIO_CRW_EVENT(2, "Model does not provide secm\n");
 731                 ret = -EOPNOTSUPP;
 732                 break;
 733         case 0x0102: /* cub adresses incorrect */
 734                 CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
 735                 ret = -EINVAL;
 736                 break;
 737         case 0x0103: /* key error */
 738                 CIO_CRW_EVENT(2, "Access key error in secm\n");
 739                 ret = -EINVAL;
 740                 break;
 741         case 0x0105: /* error while starting */
 742                 CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
 743                 ret = -EIO;
 744                 break;
 745         default:
 746                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
 747                               secm_area->response.code);
 748                 ret = -EIO;
 749         }
 750         return ret;
 751 }
 752
 753 int
 754 chsc_secm(struct channel_subsystem *css, int enable)
 755 {
 756         void  *secm_area;
 757         int ret;
 758
 759         secm_area = (void *)get_zeroed_page(GFP_KERNEL |  GFP_DMA);
 760         if (!secm_area)
 761                 return -ENOMEM;
 762
 763         mutex_lock(&css->mutex);
 764         if (enable && !css->cm_enabled) {
 765                 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 766                 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 767                 if (!css->cub_addr1 || !css->cub_addr2) {
 768                         free_page((unsigned long)css->cub_addr1);
 769                         free_page((unsigned long)css->cub_addr2);
 770                         free_page((unsigned long)secm_area);
 771                         mutex_unlock(&css->mutex);
 772                         return -ENOMEM;
 773                 }
 774         }
 775         ret = __chsc_do_secm(css, enable, secm_area);
 776         if (!ret) {
 777                 css->cm_enabled = enable;
 778                 if (css->cm_enabled) {
 779                         ret = chsc_add_cmg_attr(css);
 780                         if (ret) {
 781                                 memset(secm_area, 0, PAGE_SIZE);
 782                                 __chsc_do_secm(css, 0, secm_area);
 783                                 css->cm_enabled = 0;
 784                         }
 785                 } else
 786                         chsc_remove_cmg_attr(css);
 787         }
 788         if (!css->cm_enabled) {
 789                 free_page((unsigned long)css->cub_addr1);
 790                 free_page((unsigned long)css->cub_addr2);
 791         }
 792         mutex_unlock(&css->mutex);
 793         free_page((unsigned long)secm_area);
 794         return ret;
 795 }
 796
 797 int chsc_determine_channel_path_description(struct chp_id chpid,
 798                                             struct channel_path_desc *desc)
 799 {
 800         int ccode, ret;
 801
 802         struct {
 803                 struct chsc_header request;
 804                 u32 : 24;
 805                 u32 first_chpid : 8;
 806                 u32 : 24;
 807                 u32 last_chpid : 8;
 808                 u32 zeroes1;
 809                 struct chsc_header response;
 810                 u32 zeroes2;
 811                 struct channel_path_desc desc;
 812         } __attribute__ ((packed)) *scpd_area;
 813
 814         scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 815         if (!scpd_area)
 816                 return -ENOMEM;
 817
 818         scpd_area->request.length = 0x0010;
 819         scpd_area->request.code = 0x0002;
 820
 821         scpd_area->first_chpid = chpid.id;
 822         scpd_area->last_chpid = chpid.id;
 823
 824         ccode = chsc(scpd_area);
 825         if (ccode > 0) {
 826                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
 827                 goto out;
 828         }
 829
 830         switch (scpd_area->response.code) {
 831         case 0x0001: /* Success. */
 832                 memcpy(desc, &scpd_area->desc,
 833                        sizeof(struct channel_path_desc));
 834                 ret = 0;
 835                 break;
 836         case 0x0003: /* Invalid block. */
 837         case 0x0007: /* Invalid format. */
 838         case 0x0008: /* Other invalid block. */
 839                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
 840                 ret = -EINVAL;
 841                 break;
 842         case 0x0004: /* Command not provided in model. */
 843                 CIO_CRW_EVENT(2, "Model does not provide scpd\n");
 844                 ret = -EOPNOTSUPP;
 845                 break;
 846         default:
 847                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
 848                               scpd_area->response.code);
 849                 ret = -EIO;
 850         }
 851 out:
 852         free_page((unsigned long)scpd_area);
 853         return ret;
 854 }
 855
 856 static void
 857 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
 858                           struct cmg_chars *chars)
 859 {
 860         switch (chp->cmg) {
 861         case 2:
 862         case 3:
 863                 chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
 864                                          GFP_KERNEL);
 865                 if (chp->cmg_chars) {
 866                         int i, mask;
 867                         struct cmg_chars *cmg_chars;
 868
 869                         cmg_chars = chp->cmg_chars;
 870                         for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
 871                                 mask = 0x80 >> (i + 3);
 872                                 if (cmcv & mask)
 873                                         cmg_chars->values[i] = chars->values[i];
 874                                 else
 875                                         cmg_chars->values[i] = 0;
 876                         }
 877                 }
 878                 break;
 879         default:
 880                 /* No cmg-dependent data. */
 881                 break;
 882         }
 883 }
 884
 885 int chsc_get_channel_measurement_chars(struct channel_path *chp)
 886 {
 887         int ccode, ret;
 888
 889         struct {
 890                 struct chsc_header request;
 891                 u32 : 24;
 892                 u32 first_chpid : 8;
 893                 u32 : 24;
 894                 u32 last_chpid : 8;
 895                 u32 zeroes1;
 896                 struct chsc_header response;
 897                 u32 zeroes2;
 898                 u32 not_valid : 1;
 899                 u32 shared : 1;
 900                 u32 : 22;
 901                 u32 chpid : 8;
 902                 u32 cmcv : 5;
 903                 u32 : 11;
 904                 u32 cmgq : 8;
 905                 u32 cmg : 8;
 906                 u32 zeroes3;
 907                 u32 data[NR_MEASUREMENT_CHARS];
 908         } __attribute__ ((packed)) *scmc_area;
 909
 910         scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 911         if (!scmc_area)
 912                 return -ENOMEM;
 913
 914         scmc_area->request.length = 0x0010;
 915         scmc_area->request.code = 0x0022;
 916
 917         scmc_area->first_chpid = chp->chpid.id;
 918         scmc_area->last_chpid = chp->chpid.id;
 919
 920         ccode = chsc(scmc_area);
 921         if (ccode > 0) {
 922                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
 923                 goto out;
 924         }
 925
 926         switch (scmc_area->response.code) {
 927         case 0x0001: /* Success. */
 928                 if (!scmc_area->not_valid) {
 929                         chp->cmg = scmc_area->cmg;
 930                         chp->shared = scmc_area->shared;
 931                         chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
 932                                                   (struct cmg_chars *)
 933                                                   &scmc_area->data);
 934                 } else {
 935                         chp->cmg = -1;
 936                         chp->shared = -1;
 937                 }
 938                 ret = 0;
 939                 break;
 940         case 0x0003: /* Invalid block. */
 941         case 0x0007: /* Invalid format. */
 942         case 0x0008: /* Invalid bit combination. */
 943                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
 944                 ret = -EINVAL;
 945                 break;
 946         case 0x0004: /* Command not provided. */
 947                 CIO_CRW_EVENT(2, "Model does not provide scmc\n");
 948                 ret = -EOPNOTSUPP;
 949                 break;
 950         default:
 951                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
 952                               scmc_area->response.code);
 953                 ret = -EIO;
 954         }
 955 out:
 956         free_page((unsigned long)scmc_area);
 957         return ret;
 958 }
 959
 960 int __init chsc_alloc_sei_area(void)
 961 {
 962         sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 963         if (!sei_page)
 964                 CIO_MSG_EVENT(0, "Can't allocate page for processing of "
 965                               "chsc machine checks!\n");
 966         return (sei_page ? 0 : -ENOMEM);
 967 }
 968
 969 void __init chsc_free_sei_area(void)
 970 {
 971         kfree(sei_page);
 972 }
 973
 974 int __init
 975 chsc_enable_facility(int operation_code)
 976 {
 977         int ret;
 978         struct {
 979                 struct chsc_header request;
 980                 u8 reserved1:4;
 981                 u8 format:4;
 982                 u8 reserved2;
 983                 u16 operation_code;
 984                 u32 reserved3;
 985                 u32 reserved4;
 986                 u32 operation_data_area[252];
 987                 struct chsc_header response;
 988                 u32 reserved5:4;
 989                 u32 format2:4;
 990                 u32 reserved6:24;
 991         } __attribute__ ((packed)) *sda_area;
 992
 993         sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
 994         if (!sda_area)
 995                 return -ENOMEM;
 996         sda_area->request.length = 0x0400;
 997         sda_area->request.code = 0x0031;
 998         sda_area->operation_code = operation_code;
 999
1000         ret = chsc(sda_area);
1001         if (ret > 0) {
1002                 ret = (ret == 3) ? -ENODEV : -EBUSY;
1003                 goto out;
1004         }
1005         switch (sda_area->response.code) {
1006         case 0x0001: /* everything ok */
1007                 ret = 0;
1008                 break;
1009         case 0x0003: /* invalid request block */
1010         case 0x0007:
1011                 ret = -EINVAL;
1012                 break;
1013         case 0x0004: /* command not provided */
1014         case 0x0101: /* facility not provided */
1015                 ret = -EOPNOTSUPP;
1016                 break;
1017         default: /* something went wrong */
1018                 ret = -EIO;
1019         }
1020  out:
1021         free_page((unsigned long)sda_area);
1022         return ret;
1023 }
1024
1025 struct css_general_char css_general_characteristics;
1026 struct css_chsc_char css_chsc_characteristics;
1027
1028 int __init
1029 chsc_determine_css_characteristics(void)
1030 {
1031         int result;
1032         struct {
1033                 struct chsc_header request;
1034                 u32 reserved1;
1035                 u32 reserved2;
1036                 u32 reserved3;
1037                 struct chsc_header response;
1038                 u32 reserved4;
1039                 u32 general_char[510];
1040                 u32 chsc_char[518];
1041         } __attribute__ ((packed)) *scsc_area;
1042
1043         scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1044         if (!scsc_area) {
1045                 CIO_MSG_EVENT(0, "Was not able to determine available"
1046                               "CHSCs due to no memory.\n");
1047                 return -ENOMEM;
1048         }
1049
1050         scsc_area->request.length = 0x0010;
1051         scsc_area->request.code = 0x0010;
1052
1053         result = chsc(scsc_area);
1054         if (result) {
1055                 CIO_MSG_EVENT(0, "Was not able to determine available CHSCs, "
1056                               "cc=%i.\n", result);
1057                 result = -EIO;
1058                 goto exit;
1059         }
1060
1061         if (scsc_area->response.code != 1) {
1062                 CIO_MSG_EVENT(0, "Was not able to determine "
1063                               "available CHSCs.\n");
1064                 result = -EIO;
1065                 goto exit;
1066         }
1067         memcpy(&css_general_characteristics, scsc_area->general_char,
1068                sizeof(css_general_characteristics));
1069         memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1070                sizeof(css_chsc_characteristics));
1071 exit:
1072         free_page ((unsigned long) scsc_area);
1073         return result;
1074 }
1075
1076 EXPORT_SYMBOL_GPL(css_general_characteristics);
1077 EXPORT_SYMBOL_GPL(css_chsc_characteristics);