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