drivers/s390/cio/cio.c

   1 /*
   2  *  drivers/s390/cio/cio.c
   3  *   S/390 common I/O routines -- low level i/o calls
   4  *
   5  *    Copyright IBM Corp. 1999,2008
   6  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
   7  *               Cornelia Huck (cornelia.huck@de.ibm.com)
   8  *               Arnd Bergmann (arndb@de.ibm.com)
   9  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/slab.h>
  15 #include <linux/device.h>
  16 #include <linux/kernel_stat.h>
  17 #include <linux/interrupt.h>
  18 #include <asm/cio.h>
  19 #include <asm/delay.h>
  20 #include <asm/irq.h>
  21 #include <asm/irq_regs.h>
  22 #include <asm/setup.h>
  23 #include <asm/reset.h>
  24 #include <asm/ipl.h>
  25 #include <asm/chpid.h>
  26 #include <asm/airq.h>
  27 #include <asm/cpu.h>
  28 #include "cio.h"
  29 #include "css.h"
  30 #include "chsc.h"
  31 #include "ioasm.h"
  32 #include "io_sch.h"
  33 #include "blacklist.h"
  34 #include "cio_debug.h"
  35 #include "chp.h"
  36 #include "../s390mach.h"
  37
  38 debug_info_t *cio_debug_msg_id;
  39 debug_info_t *cio_debug_trace_id;
  40 debug_info_t *cio_debug_crw_id;
  41
  42 /*
  43  * Function: cio_debug_init
  44  * Initializes three debug logs for common I/O:
  45  * - cio_msg logs generic cio messages
  46  * - cio_trace logs the calling of different functions
  47  * - cio_crw logs machine check related cio messages
  48  */
  49 static int __init cio_debug_init(void)
  50 {
  51         cio_debug_msg_id = debug_register("cio_msg", 16, 1, 16 * sizeof(long));
  52         if (!cio_debug_msg_id)
  53                 goto out_unregister;
  54         debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
  55         debug_set_level(cio_debug_msg_id, 2);
  56         cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
  57         if (!cio_debug_trace_id)
  58                 goto out_unregister;
  59         debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
  60         debug_set_level(cio_debug_trace_id, 2);
  61         cio_debug_crw_id = debug_register("cio_crw", 16, 1, 16 * sizeof(long));
  62         if (!cio_debug_crw_id)
  63                 goto out_unregister;
  64         debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
  65         debug_set_level(cio_debug_crw_id, 4);
  66         return 0;
  67
  68 out_unregister:
  69         if (cio_debug_msg_id)
  70                 debug_unregister(cio_debug_msg_id);
  71         if (cio_debug_trace_id)
  72                 debug_unregister(cio_debug_trace_id);
  73         if (cio_debug_crw_id)
  74                 debug_unregister(cio_debug_crw_id);
  75         printk(KERN_WARNING"cio: could not initialize debugging\n");
  76         return -1;
  77 }
  78
  79 arch_initcall (cio_debug_init);
  80
  81 int
  82 cio_set_options (struct subchannel *sch, int flags)
  83 {
  84        sch->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
  85        sch->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
  86        sch->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
  87        return 0;
  88 }
  89
  90 /* FIXME: who wants to use this? */
  91 int
  92 cio_get_options (struct subchannel *sch)
  93 {
  94        int flags;
  95
  96        flags = 0;
  97        if (sch->options.suspend)
  98                 flags |= DOIO_ALLOW_SUSPEND;
  99        if (sch->options.prefetch)
 100                 flags |= DOIO_DENY_PREFETCH;
 101        if (sch->options.inter)
 102                 flags |= DOIO_SUPPRESS_INTER;
 103        return flags;
 104 }
 105
 106 /*
 107  * Use tpi to get a pending interrupt, call the interrupt handler and
 108  * return a pointer to the subchannel structure.
 109  */
 110 static int
 111 cio_tpi(void)
 112 {
 113         struct tpi_info *tpi_info;
 114         struct subchannel *sch;
 115         struct irb *irb;
 116
 117         tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
 118         if (tpi (NULL) != 1)
 119                 return 0;
 120         irb = (struct irb *) __LC_IRB;
 121         /* Store interrupt response block to lowcore. */
 122         if (tsch (tpi_info->schid, irb) != 0)
 123                 /* Not status pending or not operational. */
 124                 return 1;
 125         sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
 126         if (!sch)
 127                 return 1;
 128         local_bh_disable();
 129         irq_enter ();
 130         spin_lock(sch->lock);
 131         memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
 132         if (sch->driver && sch->driver->irq)
 133                 sch->driver->irq(sch);
 134         spin_unlock(sch->lock);
 135         irq_exit ();
 136         _local_bh_enable();
 137         return 1;
 138 }
 139
 140 static int
 141 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
 142 {
 143         char dbf_text[15];
 144
 145         if (lpm != 0)
 146                 sch->lpm &= ~lpm;
 147         else
 148                 sch->lpm = 0;
 149
 150         stsch (sch->schid, &sch->schib);
 151
 152         CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
 153                       "subchannel 0.%x.%04x!\n", sch->schid.ssid,
 154                       sch->schid.sch_no);
 155         sprintf(dbf_text, "no%s", sch->dev.bus_id);
 156         CIO_TRACE_EVENT(0, dbf_text);
 157         CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
 158
 159         return (sch->lpm ? -EACCES : -ENODEV);
 160 }
 161
 162 int
 163 cio_start_key (struct subchannel *sch,  /* subchannel structure */
 164                struct ccw1 * cpa,       /* logical channel prog addr */
 165                __u8 lpm,                /* logical path mask */
 166                __u8 key)                /* storage key */
 167 {
 168         char dbf_txt[15];
 169         int ccode;
 170         struct orb *orb;
 171
 172         CIO_TRACE_EVENT(4, "stIO");
 173         CIO_TRACE_EVENT(4, sch->dev.bus_id);
 174
 175         orb = &to_io_private(sch)->orb;
 176         /* sch is always under 2G. */
 177         orb->intparm = (u32)(addr_t)sch;
 178         orb->fmt = 1;
 179
 180         orb->pfch = sch->options.prefetch == 0;
 181         orb->spnd = sch->options.suspend;
 182         orb->ssic = sch->options.suspend && sch->options.inter;
 183         orb->lpm = (lpm != 0) ? lpm : sch->lpm;
 184 #ifdef CONFIG_64BIT
 185         /*
 186          * for 64 bit we always support 64 bit IDAWs with 4k page size only
 187          */
 188         orb->c64 = 1;
 189         orb->i2k = 0;
 190 #endif
 191         orb->key = key >> 4;
 192         /* issue "Start Subchannel" */
 193         orb->cpa = (__u32) __pa(cpa);
 194         ccode = ssch(sch->schid, orb);
 195
 196         /* process condition code */
 197         sprintf(dbf_txt, "ccode:%d", ccode);
 198         CIO_TRACE_EVENT(4, dbf_txt);
 199
 200         switch (ccode) {
 201         case 0:
 202                 /*
 203                  * initialize device status information
 204                  */
 205                 sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
 206                 return 0;
 207         case 1:         /* status pending */
 208         case 2:         /* busy */
 209                 return -EBUSY;
 210         default:                /* device/path not operational */
 211                 return cio_start_handle_notoper(sch, lpm);
 212         }
 213 }
 214
 215 int
 216 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
 217 {
 218         return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
 219 }
 220
 221 /*
 222  * resume suspended I/O operation
 223  */
 224 int
 225 cio_resume (struct subchannel *sch)
 226 {
 227         char dbf_txt[15];
 228         int ccode;
 229
 230         CIO_TRACE_EVENT (4, "resIO");
 231         CIO_TRACE_EVENT (4, sch->dev.bus_id);
 232
 233         ccode = rsch (sch->schid);
 234
 235         sprintf (dbf_txt, "ccode:%d", ccode);
 236         CIO_TRACE_EVENT (4, dbf_txt);
 237
 238         switch (ccode) {
 239         case 0:
 240                 sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
 241                 return 0;
 242         case 1:
 243                 return -EBUSY;
 244         case 2:
 245                 return -EINVAL;
 246         default:
 247                 /*
 248                  * useless to wait for request completion
 249                  *  as device is no longer operational !
 250                  */
 251                 return -ENODEV;
 252         }
 253 }
 254
 255 /*
 256  * halt I/O operation
 257  */
 258 int
 259 cio_halt(struct subchannel *sch)
 260 {
 261         char dbf_txt[15];
 262         int ccode;
 263
 264         if (!sch)
 265                 return -ENODEV;
 266
 267         CIO_TRACE_EVENT (2, "haltIO");
 268         CIO_TRACE_EVENT (2, sch->dev.bus_id);
 269
 270         /*
 271          * Issue "Halt subchannel" and process condition code
 272          */
 273         ccode = hsch (sch->schid);
 274
 275         sprintf (dbf_txt, "ccode:%d", ccode);
 276         CIO_TRACE_EVENT (2, dbf_txt);
 277
 278         switch (ccode) {
 279         case 0:
 280                 sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
 281                 return 0;
 282         case 1:         /* status pending */
 283         case 2:         /* busy */
 284                 return -EBUSY;
 285         default:                /* device not operational */
 286                 return -ENODEV;
 287         }
 288 }
 289
 290 /*
 291  * Clear I/O operation
 292  */
 293 int
 294 cio_clear(struct subchannel *sch)
 295 {
 296         char dbf_txt[15];
 297         int ccode;
 298
 299         if (!sch)
 300                 return -ENODEV;
 301
 302         CIO_TRACE_EVENT (2, "clearIO");
 303         CIO_TRACE_EVENT (2, sch->dev.bus_id);
 304
 305         /*
 306          * Issue "Clear subchannel" and process condition code
 307          */
 308         ccode = csch (sch->schid);
 309
 310         sprintf (dbf_txt, "ccode:%d", ccode);
 311         CIO_TRACE_EVENT (2, dbf_txt);
 312
 313         switch (ccode) {
 314         case 0:
 315                 sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
 316                 return 0;
 317         default:                /* device not operational */
 318                 return -ENODEV;
 319         }
 320 }
 321
 322 /*
 323  * Function: cio_cancel
 324  * Issues a "Cancel Subchannel" on the specified subchannel
 325  * Note: We don't need any fancy intparms and flags here
 326  *       since xsch is executed synchronously.
 327  * Only for common I/O internal use as for now.
 328  */
 329 int
 330 cio_cancel (struct subchannel *sch)
 331 {
 332         char dbf_txt[15];
 333         int ccode;
 334
 335         if (!sch)
 336                 return -ENODEV;
 337
 338         CIO_TRACE_EVENT (2, "cancelIO");
 339         CIO_TRACE_EVENT (2, sch->dev.bus_id);
 340
 341         ccode = xsch (sch->schid);
 342
 343         sprintf (dbf_txt, "ccode:%d", ccode);
 344         CIO_TRACE_EVENT (2, dbf_txt);
 345
 346         switch (ccode) {
 347         case 0:         /* success */
 348                 /* Update information in scsw. */
 349                 stsch (sch->schid, &sch->schib);
 350                 return 0;
 351         case 1:         /* status pending */
 352                 return -EBUSY;
 353         case 2:         /* not applicable */
 354                 return -EINVAL;
 355         default:        /* not oper */
 356                 return -ENODEV;
 357         }
 358 }
 359
 360 /*
 361  * Function: cio_modify
 362  * Issues a "Modify Subchannel" on the specified subchannel
 363  */
 364 int
 365 cio_modify (struct subchannel *sch)
 366 {
 367         int ccode, retry, ret;
 368
 369         ret = 0;
 370         for (retry = 0; retry < 5; retry++) {
 371                 ccode = msch_err (sch->schid, &sch->schib);
 372                 if (ccode < 0)  /* -EIO if msch gets a program check. */
 373                         return ccode;
 374                 switch (ccode) {
 375                 case 0: /* successfull */
 376                         return 0;
 377                 case 1: /* status pending */
 378                         return -EBUSY;
 379                 case 2: /* busy */
 380                         udelay (100);   /* allow for recovery */
 381                         ret = -EBUSY;
 382                         break;
 383                 case 3: /* not operational */
 384                         return -ENODEV;
 385                 }
 386         }
 387         return ret;
 388 }
 389
 390 /**
 391  * cio_enable_subchannel - enable a subchannel.
 392  * @sch: subchannel to be enabled
 393  * @intparm: interruption parameter to set
 394  */
 395 int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
 396 {
 397         char dbf_txt[15];
 398         int ccode;
 399         int retry;
 400         int ret;
 401
 402         CIO_TRACE_EVENT (2, "ensch");
 403         CIO_TRACE_EVENT (2, sch->dev.bus_id);
 404
 405         if (sch_is_pseudo_sch(sch))
 406                 return -EINVAL;
 407         ccode = stsch (sch->schid, &sch->schib);
 408         if (ccode)
 409                 return -ENODEV;
 410
 411         for (retry = 5, ret = 0; retry > 0; retry--) {
 412                 sch->schib.pmcw.ena = 1;
 413                 sch->schib.pmcw.isc = sch->isc;
 414                 sch->schib.pmcw.intparm = intparm;
 415                 ret = cio_modify(sch);
 416                 if (ret == -ENODEV)
 417                         break;
 418                 if (ret == -EIO)
 419                         /*
 420                          * Got a program check in cio_modify. Try without
 421                          * the concurrent sense bit the next time.
 422                          */
 423                         sch->schib.pmcw.csense = 0;
 424                 if (ret == 0) {
 425                         stsch (sch->schid, &sch->schib);
 426                         if (sch->schib.pmcw.ena)
 427                                 break;
 428                 }
 429                 if (ret == -EBUSY) {
 430                         struct irb irb;
 431                         if (tsch(sch->schid, &irb) != 0)
 432                                 break;
 433                 }
 434         }
 435         sprintf (dbf_txt, "ret:%d", ret);
 436         CIO_TRACE_EVENT (2, dbf_txt);
 437         return ret;
 438 }
 439 EXPORT_SYMBOL_GPL(cio_enable_subchannel);
 440
 441 /**
 442  * cio_disable_subchannel - disable a subchannel.
 443  * @sch: subchannel to disable
 444  */
 445 int cio_disable_subchannel(struct subchannel *sch)
 446 {
 447         char dbf_txt[15];
 448         int ccode;
 449         int retry;
 450         int ret;
 451
 452         CIO_TRACE_EVENT (2, "dissch");
 453         CIO_TRACE_EVENT (2, sch->dev.bus_id);
 454
 455         if (sch_is_pseudo_sch(sch))
 456                 return 0;
 457         ccode = stsch (sch->schid, &sch->schib);
 458         if (ccode == 3)         /* Not operational. */
 459                 return -ENODEV;
 460
 461         if (scsw_actl(&sch->schib.scsw) != 0)
 462                 /*
 463                  * the disable function must not be called while there are
 464                  *  requests pending for completion !
 465                  */
 466                 return -EBUSY;
 467
 468         for (retry = 5, ret = 0; retry > 0; retry--) {
 469                 sch->schib.pmcw.ena = 0;
 470                 ret = cio_modify(sch);
 471                 if (ret == -ENODEV)
 472                         break;
 473                 if (ret == -EBUSY)
 474                         /*
 475                          * The subchannel is busy or status pending.
 476                          * We'll disable when the next interrupt was delivered
 477                          * via the state machine.
 478                          */
 479                         break;
 480                 if (ret == 0) {
 481                         stsch (sch->schid, &sch->schib);
 482                         if (!sch->schib.pmcw.ena)
 483                                 break;
 484                 }
 485         }
 486         sprintf (dbf_txt, "ret:%d", ret);
 487         CIO_TRACE_EVENT (2, dbf_txt);
 488         return ret;
 489 }
 490 EXPORT_SYMBOL_GPL(cio_disable_subchannel);
 491
 492 int cio_create_sch_lock(struct subchannel *sch)
 493 {
 494         sch->lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
 495         if (!sch->lock)
 496                 return -ENOMEM;
 497         spin_lock_init(sch->lock);
 498         return 0;
 499 }
 500
 501 static int cio_check_devno_blacklisted(struct subchannel *sch)
 502 {
 503         if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
 504                 /*
 505                  * This device must not be known to Linux. So we simply
 506                  * say that there is no device and return ENODEV.
 507                  */
 508                 CIO_MSG_EVENT(6, "Blacklisted device detected "
 509                               "at devno %04X, subchannel set %x\n",
 510                               sch->schib.pmcw.dev, sch->schid.ssid);
 511                 return -ENODEV;
 512         }
 513         return 0;
 514 }
 515
 516 static int cio_validate_io_subchannel(struct subchannel *sch)
 517 {
 518         /* Initialization for io subchannels. */
 519         if (!css_sch_is_valid(&sch->schib))
 520                 return -ENODEV;
 521
 522         /* Devno is valid. */
 523         return cio_check_devno_blacklisted(sch);
 524 }
 525
 526 static int cio_validate_msg_subchannel(struct subchannel *sch)
 527 {
 528         /* Initialization for message subchannels. */
 529         if (!css_sch_is_valid(&sch->schib))
 530                 return -ENODEV;
 531
 532         /* Devno is valid. */
 533         return cio_check_devno_blacklisted(sch);
 534 }
 535
 536 /**
 537  * cio_validate_subchannel - basic validation of subchannel
 538  * @sch: subchannel structure to be filled out
 539  * @schid: subchannel id
 540  *
 541  * Find out subchannel type and initialize struct subchannel.
 542  * Return codes:
 543  *   0 on success
 544  *   -ENXIO for non-defined subchannels
 545  *   -ENODEV for invalid subchannels or blacklisted devices
 546  *   -EIO for subchannels in an invalid subchannel set
 547  */
 548 int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
 549 {
 550         char dbf_txt[15];
 551         int ccode;
 552         int err;
 553
 554         sprintf(dbf_txt, "valsch%x", schid.sch_no);
 555         CIO_TRACE_EVENT(4, dbf_txt);
 556
 557         /* Nuke all fields. */
 558         memset(sch, 0, sizeof(struct subchannel));
 559
 560         sch->schid = schid;
 561         if (cio_is_console(schid)) {
 562                 sch->lock = cio_get_console_lock();
 563         } else {
 564                 err = cio_create_sch_lock(sch);
 565                 if (err)
 566                         goto out;
 567         }
 568         mutex_init(&sch->reg_mutex);
 569         /* Set a name for the subchannel */
 570         snprintf (sch->dev.bus_id, BUS_ID_SIZE, "0.%x.%04x", schid.ssid,
 571                   schid.sch_no);
 572
 573         /*
 574          * The first subchannel that is not-operational (ccode==3)
 575          *  indicates that there aren't any more devices available.
 576          * If stsch gets an exception, it means the current subchannel set
 577          *  is not valid.
 578          */
 579         ccode = stsch_err (schid, &sch->schib);
 580         if (ccode) {
 581                 err = (ccode == 3) ? -ENXIO : ccode;
 582                 goto out;
 583         }
 584         /* Copy subchannel type from path management control word. */
 585         sch->st = sch->schib.pmcw.st;
 586
 587         switch (sch->st) {
 588         case SUBCHANNEL_TYPE_IO:
 589                 err = cio_validate_io_subchannel(sch);
 590                 break;
 591         case SUBCHANNEL_TYPE_MSG:
 592                 err = cio_validate_msg_subchannel(sch);
 593                 break;
 594         default:
 595                 err = 0;
 596         }
 597         if (err)
 598                 goto out;
 599
 600         CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
 601                       sch->schid.ssid, sch->schid.sch_no, sch->st);
 602         return 0;
 603 out:
 604         if (!cio_is_console(schid))
 605                 kfree(sch->lock);
 606         sch->lock = NULL;
 607         return err;
 608 }
 609
 610 /*
 611  * do_IRQ() handles all normal I/O device IRQ's (the special
 612  *          SMP cross-CPU interrupts have their own specific
 613  *          handlers).
 614  *
 615  */
 616 void
 617 do_IRQ (struct pt_regs *regs)
 618 {
 619         struct tpi_info *tpi_info;
 620         struct subchannel *sch;
 621         struct irb *irb;
 622         struct pt_regs *old_regs;
 623
 624         old_regs = set_irq_regs(regs);
 625         irq_enter();
 626         s390_idle_check();
 627         if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
 628                 /* Serve timer interrupts first. */
 629                 clock_comparator_work();
 630         /*
 631          * Get interrupt information from lowcore
 632          */
 633         tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
 634         irb = (struct irb *) __LC_IRB;
 635         do {
 636                 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
 637                 /*
 638                  * Non I/O-subchannel thin interrupts are processed differently
 639                  */
 640                 if (tpi_info->adapter_IO == 1 &&
 641                     tpi_info->int_type == IO_INTERRUPT_TYPE) {
 642                         do_adapter_IO();
 643                         continue;
 644                 }
 645                 sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
 646                 if (!sch) {
 647                         /* Clear pending interrupt condition. */
 648                         tsch(tpi_info->schid, irb);
 649                         continue;
 650                 }
 651                 spin_lock(sch->lock);
 652                 /* Store interrupt response block to lowcore. */
 653                 if (tsch(tpi_info->schid, irb) == 0) {
 654                         /* Keep subchannel information word up to date. */
 655                         memcpy (&sch->schib.scsw, &irb->scsw,
 656                                 sizeof (irb->scsw));
 657                         /* Call interrupt handler if there is one. */
 658                         if (sch->driver && sch->driver->irq)
 659                                 sch->driver->irq(sch);
 660                 }
 661                 spin_unlock(sch->lock);
 662                 /*
 663                  * Are more interrupts pending?
 664                  * If so, the tpi instruction will update the lowcore
 665                  * to hold the info for the next interrupt.
 666                  * We don't do this for VM because a tpi drops the cpu
 667                  * out of the sie which costs more cycles than it saves.
 668                  */
 669         } while (!MACHINE_IS_VM && tpi (NULL) != 0);
 670         irq_exit();
 671         set_irq_regs(old_regs);
 672 }
 673
 674 #ifdef CONFIG_CCW_CONSOLE
 675 static struct subchannel console_subchannel;
 676 static struct io_subchannel_private console_priv;
 677 static int console_subchannel_in_use;
 678
 679 void *cio_get_console_priv(void)
 680 {
 681         return &console_priv;
 682 }
 683
 684 /*
 685  * busy wait for the next interrupt on the console
 686  */
 687 void wait_cons_dev(void)
 688         __releases(console_subchannel.lock)
 689         __acquires(console_subchannel.lock)
 690 {
 691         unsigned long cr6      __attribute__ ((aligned (8)));
 692         unsigned long save_cr6 __attribute__ ((aligned (8)));
 693
 694         /*
 695          * before entering the spinlock we may already have
 696          * processed the interrupt on a different CPU...
 697          */
 698         if (!console_subchannel_in_use)
 699                 return;
 700
 701         /* disable all but isc 1 (console device) */
 702         __ctl_store (save_cr6, 6, 6);
 703         cr6 = 0x40000000;
 704         __ctl_load (cr6, 6, 6);
 705
 706         do {
 707                 spin_unlock(console_subchannel.lock);
 708                 if (!cio_tpi())
 709                         cpu_relax();
 710                 spin_lock(console_subchannel.lock);
 711         } while (console_subchannel.schib.scsw.cmd.actl != 0);
 712         /*
 713          * restore previous isc value
 714          */
 715         __ctl_load (save_cr6, 6, 6);
 716 }
 717
 718 static int
 719 cio_test_for_console(struct subchannel_id schid, void *data)
 720 {
 721         if (stsch_err(schid, &console_subchannel.schib) != 0)
 722                 return -ENXIO;
 723         if ((console_subchannel.schib.pmcw.st == SUBCHANNEL_TYPE_IO) &&
 724             console_subchannel.schib.pmcw.dnv &&
 725             (console_subchannel.schib.pmcw.dev == console_devno)) {
 726                 console_irq = schid.sch_no;
 727                 return 1; /* found */
 728         }
 729         return 0;
 730 }
 731
 732
 733 static int
 734 cio_get_console_sch_no(void)
 735 {
 736         struct subchannel_id schid;
 737
 738         init_subchannel_id(&schid);
 739         if (console_irq != -1) {
 740                 /* VM provided us with the irq number of the console. */
 741                 schid.sch_no = console_irq;
 742                 if (stsch(schid, &console_subchannel.schib) != 0 ||
 743                     (console_subchannel.schib.pmcw.st != SUBCHANNEL_TYPE_IO) ||
 744                     !console_subchannel.schib.pmcw.dnv)
 745                         return -1;
 746                 console_devno = console_subchannel.schib.pmcw.dev;
 747         } else if (console_devno != -1) {
 748                 /* At least the console device number is known. */
 749                 for_each_subchannel(cio_test_for_console, NULL);
 750                 if (console_irq == -1)
 751                         return -1;
 752         } else {
 753                 /* unlike in 2.4, we cannot autoprobe here, since
 754                  * the channel subsystem is not fully initialized.
 755                  * With some luck, the HWC console can take over */
 756                 printk(KERN_WARNING "cio: No ccw console found!\n");
 757                 return -1;
 758         }
 759         return console_irq;
 760 }
 761
 762 struct subchannel *
 763 cio_probe_console(void)
 764 {
 765         int sch_no, ret;
 766         struct subchannel_id schid;
 767
 768         if (xchg(&console_subchannel_in_use, 1) != 0)
 769                 return ERR_PTR(-EBUSY);
 770         sch_no = cio_get_console_sch_no();
 771         if (sch_no == -1) {
 772                 console_subchannel_in_use = 0;
 773                 return ERR_PTR(-ENODEV);
 774         }
 775         memset(&console_subchannel, 0, sizeof(struct subchannel));
 776         init_subchannel_id(&schid);
 777         schid.sch_no = sch_no;
 778         ret = cio_validate_subchannel(&console_subchannel, schid);
 779         if (ret) {
 780                 console_subchannel_in_use = 0;
 781                 return ERR_PTR(-ENODEV);
 782         }
 783
 784         /*
 785          * enable console I/O-interrupt subclass 1
 786          */
 787         ctl_set_bit(6, 30);
 788         console_subchannel.schib.pmcw.isc = 1;
 789         console_subchannel.schib.pmcw.intparm =
 790                 (u32)(addr_t)&console_subchannel;
 791         ret = cio_modify(&console_subchannel);
 792         if (ret) {
 793                 console_subchannel_in_use = 0;
 794                 return ERR_PTR(ret);
 795         }
 796         return &console_subchannel;
 797 }
 798
 799 void
 800 cio_release_console(void)
 801 {
 802         console_subchannel.schib.pmcw.intparm = 0;
 803         cio_modify(&console_subchannel);
 804         ctl_clear_bit(6, 30);
 805         console_subchannel_in_use = 0;
 806 }
 807
 808 /* Bah... hack to catch console special sausages. */
 809 int
 810 cio_is_console(struct subchannel_id schid)
 811 {
 812         if (!console_subchannel_in_use)
 813                 return 0;
 814         return schid_equal(&schid, &console_subchannel.schid);
 815 }
 816
 817 struct subchannel *
 818 cio_get_console_subchannel(void)
 819 {
 820         if (!console_subchannel_in_use)
 821                 return NULL;
 822         return &console_subchannel;
 823 }
 824
 825 #endif
 826 static int
 827 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
 828 {
 829         int retry, cc;
 830
 831         cc = 0;
 832         for (retry=0;retry<3;retry++) {
 833                 schib->pmcw.ena = 0;
 834                 cc = msch(schid, schib);
 835                 if (cc)
 836                         return (cc==3?-ENODEV:-EBUSY);
 837                 stsch(schid, schib);
 838                 if (!schib->pmcw.ena)
 839                         return 0;
 840         }
 841         return -EBUSY; /* uhm... */
 842 }
 843
 844 /* we can't use the normal udelay here, since it enables external interrupts */
 845
 846 static void udelay_reset(unsigned long usecs)
 847 {
 848         uint64_t start_cc, end_cc;
 849
 850         asm volatile ("STCK %0" : "=m" (start_cc));
 851         do {
 852                 cpu_relax();
 853                 asm volatile ("STCK %0" : "=m" (end_cc));
 854         } while (((end_cc - start_cc)/4096) < usecs);
 855 }
 856
 857 static int
 858 __clear_io_subchannel_easy(struct subchannel_id schid)
 859 {
 860         int retry;
 861
 862         if (csch(schid))
 863                 return -ENODEV;
 864         for (retry=0;retry<20;retry++) {
 865                 struct tpi_info ti;
 866
 867                 if (tpi(&ti)) {
 868                         tsch(ti.schid, (struct irb *)__LC_IRB);
 869                         if (schid_equal(&ti.schid, &schid))
 870                                 return 0;
 871                 }
 872                 udelay_reset(100);
 873         }
 874         return -EBUSY;
 875 }
 876
 877 static int pgm_check_occured;
 878
 879 static void cio_reset_pgm_check_handler(void)
 880 {
 881         pgm_check_occured = 1;
 882 }
 883
 884 static int stsch_reset(struct subchannel_id schid, volatile struct schib *addr)
 885 {
 886         int rc;
 887
 888         pgm_check_occured = 0;
 889         s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
 890         rc = stsch(schid, addr);
 891         s390_base_pgm_handler_fn = NULL;
 892
 893         /* The program check handler could have changed pgm_check_occured. */
 894         barrier();
 895
 896         if (pgm_check_occured)
 897                 return -EIO;
 898         else
 899                 return rc;
 900 }
 901
 902 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
 903 {
 904         struct schib schib;
 905
 906         if (stsch_reset(schid, &schib))
 907                 return -ENXIO;
 908         if (!schib.pmcw.ena)
 909                 return 0;
 910         switch(__disable_subchannel_easy(schid, &schib)) {
 911         case 0:
 912         case -ENODEV:
 913                 break;
 914         default: /* -EBUSY */
 915                 switch (schib.pmcw.st) {
 916                 case SUBCHANNEL_TYPE_IO:
 917                         if (__clear_io_subchannel_easy(schid))
 918                                 goto out; /* give up... */
 919                         break;
 920                 default:
 921                         /* No default clear strategy */
 922                         break;
 923                 }
 924                 stsch(schid, &schib);
 925                 __disable_subchannel_easy(schid, &schib);
 926         }
 927 out:
 928         return 0;
 929 }
 930
 931 static atomic_t chpid_reset_count;
 932
 933 static void s390_reset_chpids_mcck_handler(void)
 934 {
 935         struct crw crw;
 936         struct mci *mci;
 937
 938         /* Check for pending channel report word. */
 939         mci = (struct mci *)&S390_lowcore.mcck_interruption_code;
 940         if (!mci->cp)
 941                 return;
 942         /* Process channel report words. */
 943         while (stcrw(&crw) == 0) {
 944                 /* Check for responses to RCHP. */
 945                 if (crw.slct && crw.rsc == CRW_RSC_CPATH)
 946                         atomic_dec(&chpid_reset_count);
 947         }
 948 }
 949
 950 #define RCHP_TIMEOUT (30 * USEC_PER_SEC)
 951 static void css_reset(void)
 952 {
 953         int i, ret;
 954         unsigned long long timeout;
 955         struct chp_id chpid;
 956
 957         /* Reset subchannels. */
 958         for_each_subchannel(__shutdown_subchannel_easy,  NULL);
 959         /* Reset channel paths. */
 960         s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
 961         /* Enable channel report machine checks. */
 962         __ctl_set_bit(14, 28);
 963         /* Temporarily reenable machine checks. */
 964         local_mcck_enable();
 965         chp_id_init(&chpid);
 966         for (i = 0; i <= __MAX_CHPID; i++) {
 967                 chpid.id = i;
 968                 ret = rchp(chpid);
 969                 if ((ret == 0) || (ret == 2))
 970                         /*
 971                          * rchp either succeeded, or another rchp is already
 972                          * in progress. In either case, we'll get a crw.
 973                          */
 974                         atomic_inc(&chpid_reset_count);
 975         }
 976         /* Wait for machine check for all channel paths. */
 977         timeout = get_clock() + (RCHP_TIMEOUT << 12);
 978         while (atomic_read(&chpid_reset_count) != 0) {
 979                 if (get_clock() > timeout)
 980                         break;
 981                 cpu_relax();
 982         }
 983         /* Disable machine checks again. */
 984         local_mcck_disable();
 985         /* Disable channel report machine checks. */
 986         __ctl_clear_bit(14, 28);
 987         s390_base_mcck_handler_fn = NULL;
 988 }
 989
 990 static struct reset_call css_reset_call = {
 991         .fn = css_reset,
 992 };
 993
 994 static int __init init_css_reset_call(void)
 995 {
 996         atomic_set(&chpid_reset_count, 0);
 997         register_reset_call(&css_reset_call);
 998         return 0;
 999 }
1000
1001 arch_initcall(init_css_reset_call);
1002
1003 struct sch_match_id {
1004         struct subchannel_id schid;
1005         struct ccw_dev_id devid;
1006         int rc;
1007 };
1008
1009 static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
1010 {
1011         struct schib schib;
1012         struct sch_match_id *match_id = data;
1013
1014         if (stsch_reset(schid, &schib))
1015                 return -ENXIO;
1016         if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
1017             (schib.pmcw.dev == match_id->devid.devno) &&
1018             (schid.ssid == match_id->devid.ssid)) {
1019                 match_id->schid = schid;
1020                 match_id->rc = 0;
1021                 return 1;
1022         }
1023         return 0;
1024 }
1025
1026 static int reipl_find_schid(struct ccw_dev_id *devid,
1027                             struct subchannel_id *schid)
1028 {
1029         struct sch_match_id match_id;
1030
1031         match_id.devid = *devid;
1032         match_id.rc = -ENODEV;
1033         for_each_subchannel(__reipl_subchannel_match, &match_id);
1034         if (match_id.rc == 0)
1035                 *schid = match_id.schid;
1036         return match_id.rc;
1037 }
1038
1039 extern void do_reipl_asm(__u32 schid);
1040
1041 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
1042 void reipl_ccw_dev(struct ccw_dev_id *devid)
1043 {
1044         struct subchannel_id schid;
1045
1046         s390_reset_system();
1047         if (reipl_find_schid(devid, &schid) != 0)
1048                 panic("IPL Device not found\n");
1049         do_reipl_asm(*((__u32*)&schid));
1050 }
1051
1052 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
1053 {
1054         struct subchannel_id schid;
1055         struct schib schib;
1056
1057         schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
1058         if (!schid.one)
1059                 return -ENODEV;
1060         if (stsch(schid, &schib))
1061                 return -ENODEV;
1062         if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
1063                 return -ENODEV;
1064         if (!schib.pmcw.dnv)
1065                 return -ENODEV;
1066         iplinfo->devno = schib.pmcw.dev;
1067         iplinfo->is_qdio = schib.pmcw.qf;
1068         return 0;
1069 }