drivers/s390/char/sclp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * core function to access sclp interface
   4  *
   5  * Copyright IBM Corp. 1999, 2009
   6  *
   7  * Author(s): Martin Peschke <mpeschke@de.ibm.com>
   8  *            Martin Schwidefsky <schwidefsky@de.ibm.com>
   9  */
  10
  11 #include <linux/kernel_stat.h>
  12 #include <linux/module.h>
  13 #include <linux/err.h>
  14 #include <linux/panic_notifier.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/timer.h>
  18 #include <linux/reboot.h>
  19 #include <linux/jiffies.h>
  20 #include <linux/init.h>
  21 #include <linux/platform_device.h>
  22 #include <asm/types.h>
  23 #include <asm/irq.h>
  24 #include <asm/debug.h>
  25
  26 #include "sclp.h"
  27
  28 #define SCLP_HEADER             "sclp: "
  29
  30 struct sclp_trace_entry {
  31         char id[4] __nonstring;
  32         u32 a;
  33         u64 b;
  34 };
  35
  36 #define SCLP_TRACE_ENTRY_SIZE           sizeof(struct sclp_trace_entry)
  37 #define SCLP_TRACE_MAX_SIZE             128
  38 #define SCLP_TRACE_EVENT_MAX_SIZE       64
  39
  40 /* Debug trace area intended for all entries in abbreviated form. */
  41 DEFINE_STATIC_DEBUG_INFO(sclp_debug, "sclp", 8, 1, SCLP_TRACE_ENTRY_SIZE,
  42                          &debug_hex_ascii_view);
  43
  44 /* Error trace area intended for full entries relating to failed requests. */
  45 DEFINE_STATIC_DEBUG_INFO(sclp_debug_err, "sclp_err", 4, 1,
  46                          SCLP_TRACE_ENTRY_SIZE, &debug_hex_ascii_view);
  47
  48 /* Lock to protect internal data consistency. */
  49 static DEFINE_SPINLOCK(sclp_lock);
  50
  51 /* Mask of events that we can send to the sclp interface. */
  52 static sccb_mask_t sclp_receive_mask;
  53
  54 /* Mask of events that we can receive from the sclp interface. */
  55 static sccb_mask_t sclp_send_mask;
  56
  57 /* List of registered event listeners and senders. */
  58 static LIST_HEAD(sclp_reg_list);
  59
  60 /* List of queued requests. */
  61 static LIST_HEAD(sclp_req_queue);
  62
  63 /* Data for read and init requests. */
  64 static struct sclp_req sclp_read_req;
  65 static struct sclp_req sclp_init_req;
  66 static void *sclp_read_sccb;
  67 static struct init_sccb *sclp_init_sccb;
  68
  69 /* Number of console pages to allocate, used by sclp_con.c and sclp_vt220.c */
  70 int sclp_console_pages = SCLP_CONSOLE_PAGES;
  71 /* Flag to indicate if buffer pages are dropped on buffer full condition */
  72 bool sclp_console_drop = true;
  73 /* Number of times the console dropped buffer pages */
  74 unsigned long sclp_console_full;
  75
  76 /* The currently active SCLP command word. */
  77 static sclp_cmdw_t active_cmd;
  78
  79 static inline void sclp_trace(int prio, char *id, u32 a, u64 b, bool err)
  80 {
  81         struct sclp_trace_entry e;
  82
  83         memset(&e, 0, sizeof(e));
  84         strtomem(e.id, id);
  85         e.a = a;
  86         e.b = b;
  87         debug_event(&sclp_debug, prio, &e, sizeof(e));
  88         if (err)
  89                 debug_event(&sclp_debug_err, 0, &e, sizeof(e));
  90 }
  91
  92 static inline int no_zeroes_len(void *data, int len)
  93 {
  94         char *d = data;
  95
  96         /* Minimize trace area usage by not tracing trailing zeroes. */
  97         while (len > SCLP_TRACE_ENTRY_SIZE && d[len - 1] == 0)
  98                 len--;
  99
 100         return len;
 101 }
 102
 103 static inline void sclp_trace_bin(int prio, void *d, int len, int errlen)
 104 {
 105         debug_event(&sclp_debug, prio, d, no_zeroes_len(d, len));
 106         if (errlen)
 107                 debug_event(&sclp_debug_err, 0, d, no_zeroes_len(d, errlen));
 108 }
 109
 110 static inline int abbrev_len(sclp_cmdw_t cmd, struct sccb_header *sccb)
 111 {
 112         struct evbuf_header *evbuf = (struct evbuf_header *)(sccb + 1);
 113         int len = sccb->length, limit = SCLP_TRACE_MAX_SIZE;
 114
 115         /* Full SCCB tracing if debug level is set to max. */
 116         if (sclp_debug.level == DEBUG_MAX_LEVEL)
 117                 return len;
 118
 119         /* Minimal tracing for console writes. */
 120         if (cmd == SCLP_CMDW_WRITE_EVENT_DATA &&
 121             (evbuf->type == EVTYP_MSG  || evbuf->type == EVTYP_VT220MSG))
 122                 limit = SCLP_TRACE_ENTRY_SIZE;
 123
 124         return min(len, limit);
 125 }
 126
 127 static inline void sclp_trace_sccb(int prio, char *id, u32 a, u64 b,
 128                                    sclp_cmdw_t cmd, struct sccb_header *sccb,
 129                                    bool err)
 130 {
 131         sclp_trace(prio, id, a, b, err);
 132         if (sccb) {
 133                 sclp_trace_bin(prio + 1, sccb, abbrev_len(cmd, sccb),
 134                                err ? sccb->length : 0);
 135         }
 136 }
 137
 138 static inline void sclp_trace_evbuf(int prio, char *id, u32 a, u64 b,
 139                                     struct evbuf_header *evbuf, bool err)
 140 {
 141         sclp_trace(prio, id, a, b, err);
 142         sclp_trace_bin(prio + 1, evbuf,
 143                        min((int)evbuf->length, (int)SCLP_TRACE_EVENT_MAX_SIZE),
 144                        err ? evbuf->length : 0);
 145 }
 146
 147 static inline void sclp_trace_req(int prio, char *id, struct sclp_req *req,
 148                                   bool err)
 149 {
 150         struct sccb_header *sccb = req->sccb;
 151         union {
 152                 struct {
 153                         u16 status;
 154                         u16 response;
 155                         u16 timeout;
 156                         u16 start_count;
 157                 };
 158                 u64 b;
 159         } summary;
 160
 161         summary.status = req->status;
 162         summary.response = sccb ? sccb->response_code : 0;
 163         summary.timeout = (u16)req->queue_timeout;
 164         summary.start_count = (u16)req->start_count;
 165
 166         sclp_trace(prio, id, __pa(sccb), summary.b, err);
 167 }
 168
 169 static inline void sclp_trace_register(int prio, char *id, u32 a, u64 b,
 170                                        struct sclp_register *reg)
 171 {
 172         struct {
 173                 u64 receive;
 174                 u64 send;
 175         } d;
 176
 177         d.receive = reg->receive_mask;
 178         d.send = reg->send_mask;
 179
 180         sclp_trace(prio, id, a, b, false);
 181         sclp_trace_bin(prio, &d, sizeof(d), 0);
 182 }
 183
 184 static int __init sclp_setup_console_pages(char *str)
 185 {
 186         int pages, rc;
 187
 188         rc = kstrtoint(str, 0, &pages);
 189         if (!rc && pages >= SCLP_CONSOLE_PAGES)
 190                 sclp_console_pages = pages;
 191         return 1;
 192 }
 193
 194 __setup("sclp_con_pages=", sclp_setup_console_pages);
 195
 196 static int __init sclp_setup_console_drop(char *str)
 197 {
 198         return kstrtobool(str, &sclp_console_drop) == 0;
 199 }
 200
 201 __setup("sclp_con_drop=", sclp_setup_console_drop);
 202
 203 /* Timer for request retries. */
 204 static struct timer_list sclp_request_timer;
 205
 206 /* Timer for queued requests. */
 207 static struct timer_list sclp_queue_timer;
 208
 209 /* Internal state: is a request active at the sclp? */
 210 static volatile enum sclp_running_state_t {
 211         sclp_running_state_idle,
 212         sclp_running_state_running,
 213         sclp_running_state_reset_pending
 214 } sclp_running_state = sclp_running_state_idle;
 215
 216 /* Internal state: is a read request pending? */
 217 static volatile enum sclp_reading_state_t {
 218         sclp_reading_state_idle,
 219         sclp_reading_state_reading
 220 } sclp_reading_state = sclp_reading_state_idle;
 221
 222 /* Internal state: is the driver currently serving requests? */
 223 static volatile enum sclp_activation_state_t {
 224         sclp_activation_state_active,
 225         sclp_activation_state_deactivating,
 226         sclp_activation_state_inactive,
 227         sclp_activation_state_activating
 228 } sclp_activation_state = sclp_activation_state_active;
 229
 230 /* Internal state: is an init mask request pending? */
 231 static volatile enum sclp_mask_state_t {
 232         sclp_mask_state_idle,
 233         sclp_mask_state_initializing
 234 } sclp_mask_state = sclp_mask_state_idle;
 235
 236 /* Maximum retry counts */
 237 #define SCLP_INIT_RETRY         3
 238 #define SCLP_MASK_RETRY         3
 239
 240 /* Timeout intervals in seconds.*/
 241 #define SCLP_BUSY_INTERVAL      10
 242 #define SCLP_RETRY_INTERVAL     30
 243
 244 static void sclp_request_timeout(bool force_restart);
 245 static void sclp_process_queue(void);
 246 static void __sclp_make_read_req(void);
 247 static int sclp_init_mask(int calculate);
 248 static int sclp_init(void);
 249
 250 static void
 251 __sclp_queue_read_req(void)
 252 {
 253         if (sclp_reading_state == sclp_reading_state_idle) {
 254                 sclp_reading_state = sclp_reading_state_reading;
 255                 __sclp_make_read_req();
 256                 /* Add request to head of queue */
 257                 list_add(&sclp_read_req.list, &sclp_req_queue);
 258         }
 259 }
 260
 261 /* Set up request retry timer. Called while sclp_lock is locked. */
 262 static inline void
 263 __sclp_set_request_timer(unsigned long time, void (*cb)(struct timer_list *))
 264 {
 265         del_timer(&sclp_request_timer);
 266         sclp_request_timer.function = cb;
 267         sclp_request_timer.expires = jiffies + time;
 268         add_timer(&sclp_request_timer);
 269 }
 270
 271 static void sclp_request_timeout_restart(struct timer_list *unused)
 272 {
 273         sclp_request_timeout(true);
 274 }
 275
 276 static void sclp_request_timeout_normal(struct timer_list *unused)
 277 {
 278         sclp_request_timeout(false);
 279 }
 280
 281 /* Request timeout handler. Restart the request queue. If force_restart,
 282  * force restart of running request. */
 283 static void sclp_request_timeout(bool force_restart)
 284 {
 285         unsigned long flags;
 286
 287         /* TMO: A timeout occurred (a=force_restart) */
 288         sclp_trace(2, "TMO", force_restart, 0, true);
 289
 290         spin_lock_irqsave(&sclp_lock, flags);
 291         if (force_restart) {
 292                 if (sclp_running_state == sclp_running_state_running) {
 293                         /* Break running state and queue NOP read event request
 294                          * to get a defined interface state. */
 295                         __sclp_queue_read_req();
 296                         sclp_running_state = sclp_running_state_idle;
 297                 }
 298         } else {
 299                 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 300                                          sclp_request_timeout_normal);
 301         }
 302         spin_unlock_irqrestore(&sclp_lock, flags);
 303         sclp_process_queue();
 304 }
 305
 306 /*
 307  * Returns the expire value in jiffies of the next pending request timeout,
 308  * if any. Needs to be called with sclp_lock.
 309  */
 310 static unsigned long __sclp_req_queue_find_next_timeout(void)
 311 {
 312         unsigned long expires_next = 0;
 313         struct sclp_req *req;
 314
 315         list_for_each_entry(req, &sclp_req_queue, list) {
 316                 if (!req->queue_expires)
 317                         continue;
 318                 if (!expires_next ||
 319                    (time_before(req->queue_expires, expires_next)))
 320                                 expires_next = req->queue_expires;
 321         }
 322         return expires_next;
 323 }
 324
 325 /*
 326  * Returns expired request, if any, and removes it from the list.
 327  */
 328 static struct sclp_req *__sclp_req_queue_remove_expired_req(void)
 329 {
 330         unsigned long flags, now;
 331         struct sclp_req *req;
 332
 333         spin_lock_irqsave(&sclp_lock, flags);
 334         now = jiffies;
 335         /* Don't need list_for_each_safe because we break out after list_del */
 336         list_for_each_entry(req, &sclp_req_queue, list) {
 337                 if (!req->queue_expires)
 338                         continue;
 339                 if (time_before_eq(req->queue_expires, now)) {
 340                         if (req->status == SCLP_REQ_QUEUED) {
 341                                 req->status = SCLP_REQ_QUEUED_TIMEOUT;
 342                                 list_del(&req->list);
 343                                 goto out;
 344                         }
 345                 }
 346         }
 347         req = NULL;
 348 out:
 349         spin_unlock_irqrestore(&sclp_lock, flags);
 350         return req;
 351 }
 352
 353 /*
 354  * Timeout handler for queued requests. Removes request from list and
 355  * invokes callback. This timer can be set per request in situations where
 356  * waiting too long would be harmful to the system, e.g. during SE reboot.
 357  */
 358 static void sclp_req_queue_timeout(struct timer_list *unused)
 359 {
 360         unsigned long flags, expires_next;
 361         struct sclp_req *req;
 362
 363         do {
 364                 req = __sclp_req_queue_remove_expired_req();
 365
 366                 if (req) {
 367                         /* RQTM: Request timed out (a=sccb, b=summary) */
 368                         sclp_trace_req(2, "RQTM", req, true);
 369                 }
 370
 371                 if (req && req->callback)
 372                         req->callback(req, req->callback_data);
 373         } while (req);
 374
 375         spin_lock_irqsave(&sclp_lock, flags);
 376         expires_next = __sclp_req_queue_find_next_timeout();
 377         if (expires_next)
 378                 mod_timer(&sclp_queue_timer, expires_next);
 379         spin_unlock_irqrestore(&sclp_lock, flags);
 380 }
 381
 382 static int sclp_service_call_trace(sclp_cmdw_t command, void *sccb)
 383 {
 384         static u64 srvc_count;
 385         int rc;
 386
 387         /* SRV1: Service call about to be issued (a=command, b=sccb address) */
 388         sclp_trace_sccb(0, "SRV1", command, (u64)sccb, command, sccb, false);
 389
 390         rc = sclp_service_call(command, sccb);
 391
 392         /* SRV2: Service call was issued (a=rc, b=SRVC sequence number) */
 393         sclp_trace(0, "SRV2", -rc, ++srvc_count, rc != 0);
 394
 395         if (rc == 0)
 396                 active_cmd = command;
 397
 398         return rc;
 399 }
 400
 401 /* Try to start a request. Return zero if the request was successfully
 402  * started or if it will be started at a later time. Return non-zero otherwise.
 403  * Called while sclp_lock is locked. */
 404 static int
 405 __sclp_start_request(struct sclp_req *req)
 406 {
 407         int rc;
 408
 409         if (sclp_running_state != sclp_running_state_idle)
 410                 return 0;
 411         del_timer(&sclp_request_timer);
 412         rc = sclp_service_call_trace(req->command, req->sccb);
 413         req->start_count++;
 414
 415         if (rc == 0) {
 416                 /* Successfully started request */
 417                 req->status = SCLP_REQ_RUNNING;
 418                 sclp_running_state = sclp_running_state_running;
 419                 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
 420                                          sclp_request_timeout_restart);
 421                 return 0;
 422         } else if (rc == -EBUSY) {
 423                 /* Try again later */
 424                 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 425                                          sclp_request_timeout_normal);
 426                 return 0;
 427         }
 428         /* Request failed */
 429         req->status = SCLP_REQ_FAILED;
 430         return rc;
 431 }
 432
 433 /* Try to start queued requests. */
 434 static void
 435 sclp_process_queue(void)
 436 {
 437         struct sclp_req *req;
 438         int rc;
 439         unsigned long flags;
 440
 441         spin_lock_irqsave(&sclp_lock, flags);
 442         if (sclp_running_state != sclp_running_state_idle) {
 443                 spin_unlock_irqrestore(&sclp_lock, flags);
 444                 return;
 445         }
 446         del_timer(&sclp_request_timer);
 447         while (!list_empty(&sclp_req_queue)) {
 448                 req = list_entry(sclp_req_queue.next, struct sclp_req, list);
 449                 rc = __sclp_start_request(req);
 450                 if (rc == 0)
 451                         break;
 452                 /* Request failed */
 453                 if (req->start_count > 1) {
 454                         /* Cannot abort already submitted request - could still
 455                          * be active at the SCLP */
 456                         __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 457                                                  sclp_request_timeout_normal);
 458                         break;
 459                 }
 460                 /* Post-processing for aborted request */
 461                 list_del(&req->list);
 462
 463                 /* RQAB: Request aborted (a=sccb, b=summary) */
 464                 sclp_trace_req(2, "RQAB", req, true);
 465
 466                 if (req->callback) {
 467                         spin_unlock_irqrestore(&sclp_lock, flags);
 468                         req->callback(req, req->callback_data);
 469                         spin_lock_irqsave(&sclp_lock, flags);
 470                 }
 471         }
 472         spin_unlock_irqrestore(&sclp_lock, flags);
 473 }
 474
 475 static int __sclp_can_add_request(struct sclp_req *req)
 476 {
 477         if (req == &sclp_init_req)
 478                 return 1;
 479         if (sclp_init_state != sclp_init_state_initialized)
 480                 return 0;
 481         if (sclp_activation_state != sclp_activation_state_active)
 482                 return 0;
 483         return 1;
 484 }
 485
 486 /* Queue a new request. Return zero on success, non-zero otherwise. */
 487 int
 488 sclp_add_request(struct sclp_req *req)
 489 {
 490         unsigned long flags;
 491         int rc;
 492
 493         spin_lock_irqsave(&sclp_lock, flags);
 494         if (!__sclp_can_add_request(req)) {
 495                 spin_unlock_irqrestore(&sclp_lock, flags);
 496                 return -EIO;
 497         }
 498
 499         /* RQAD: Request was added (a=sccb, b=caller) */
 500         sclp_trace(2, "RQAD", __pa(req->sccb), _RET_IP_, false);
 501
 502         req->status = SCLP_REQ_QUEUED;
 503         req->start_count = 0;
 504         list_add_tail(&req->list, &sclp_req_queue);
 505         rc = 0;
 506         if (req->queue_timeout) {
 507                 req->queue_expires = jiffies + req->queue_timeout * HZ;
 508                 if (!timer_pending(&sclp_queue_timer) ||
 509                     time_after(sclp_queue_timer.expires, req->queue_expires))
 510                         mod_timer(&sclp_queue_timer, req->queue_expires);
 511         } else
 512                 req->queue_expires = 0;
 513         /* Start if request is first in list */
 514         if (sclp_running_state == sclp_running_state_idle &&
 515             req->list.prev == &sclp_req_queue) {
 516                 rc = __sclp_start_request(req);
 517                 if (rc)
 518                         list_del(&req->list);
 519         }
 520         spin_unlock_irqrestore(&sclp_lock, flags);
 521         return rc;
 522 }
 523
 524 EXPORT_SYMBOL(sclp_add_request);
 525
 526 /* Dispatch events found in request buffer to registered listeners. Return 0
 527  * if all events were dispatched, non-zero otherwise. */
 528 static int
 529 sclp_dispatch_evbufs(struct sccb_header *sccb)
 530 {
 531         unsigned long flags;
 532         struct evbuf_header *evbuf;
 533         struct list_head *l;
 534         struct sclp_register *reg;
 535         int offset;
 536         int rc;
 537
 538         spin_lock_irqsave(&sclp_lock, flags);
 539         rc = 0;
 540         for (offset = sizeof(struct sccb_header); offset < sccb->length;
 541              offset += evbuf->length) {
 542                 evbuf = (struct evbuf_header *) ((addr_t) sccb + offset);
 543                 /* Check for malformed hardware response */
 544                 if (evbuf->length == 0)
 545                         break;
 546                 /* Search for event handler */
 547                 reg = NULL;
 548                 list_for_each(l, &sclp_reg_list) {
 549                         reg = list_entry(l, struct sclp_register, list);
 550                         if (reg->receive_mask & SCLP_EVTYP_MASK(evbuf->type))
 551                                 break;
 552                         else
 553                                 reg = NULL;
 554                 }
 555
 556                 /* EVNT: Event callback (b=receiver) */
 557                 sclp_trace_evbuf(2, "EVNT", 0, reg ? (u64)reg->receiver_fn : 0,
 558                                  evbuf, !reg);
 559
 560                 if (reg && reg->receiver_fn) {
 561                         spin_unlock_irqrestore(&sclp_lock, flags);
 562                         reg->receiver_fn(evbuf);
 563                         spin_lock_irqsave(&sclp_lock, flags);
 564                 } else if (reg == NULL)
 565                         rc = -EOPNOTSUPP;
 566         }
 567         spin_unlock_irqrestore(&sclp_lock, flags);
 568         return rc;
 569 }
 570
 571 /* Read event data request callback. */
 572 static void
 573 sclp_read_cb(struct sclp_req *req, void *data)
 574 {
 575         unsigned long flags;
 576         struct sccb_header *sccb;
 577
 578         sccb = (struct sccb_header *) req->sccb;
 579         if (req->status == SCLP_REQ_DONE && (sccb->response_code == 0x20 ||
 580             sccb->response_code == 0x220))
 581                 sclp_dispatch_evbufs(sccb);
 582         spin_lock_irqsave(&sclp_lock, flags);
 583         sclp_reading_state = sclp_reading_state_idle;
 584         spin_unlock_irqrestore(&sclp_lock, flags);
 585 }
 586
 587 /* Prepare read event data request. Called while sclp_lock is locked. */
 588 static void __sclp_make_read_req(void)
 589 {
 590         struct sccb_header *sccb;
 591
 592         sccb = (struct sccb_header *) sclp_read_sccb;
 593         clear_page(sccb);
 594         memset(&sclp_read_req, 0, sizeof(struct sclp_req));
 595         sclp_read_req.command = SCLP_CMDW_READ_EVENT_DATA;
 596         sclp_read_req.status = SCLP_REQ_QUEUED;
 597         sclp_read_req.start_count = 0;
 598         sclp_read_req.callback = sclp_read_cb;
 599         sclp_read_req.sccb = sccb;
 600         sccb->length = PAGE_SIZE;
 601         sccb->function_code = 0;
 602         sccb->control_mask[2] = 0x80;
 603 }
 604
 605 /* Search request list for request with matching sccb. Return request if found,
 606  * NULL otherwise. Called while sclp_lock is locked. */
 607 static inline struct sclp_req *
 608 __sclp_find_req(u32 sccb)
 609 {
 610         struct list_head *l;
 611         struct sclp_req *req;
 612
 613         list_for_each(l, &sclp_req_queue) {
 614                 req = list_entry(l, struct sclp_req, list);
 615                 if (sccb == __pa(req->sccb))
 616                         return req;
 617         }
 618         return NULL;
 619 }
 620
 621 static bool ok_response(u32 sccb_int, sclp_cmdw_t cmd)
 622 {
 623         struct sccb_header *sccb = (struct sccb_header *)__va(sccb_int);
 624         struct evbuf_header *evbuf;
 625         u16 response;
 626
 627         if (!sccb)
 628                 return true;
 629
 630         /* Check SCCB response. */
 631         response = sccb->response_code & 0xff;
 632         if (response != 0x10 && response != 0x20)
 633                 return false;
 634
 635         /* Check event-processed flag on outgoing events. */
 636         if (cmd == SCLP_CMDW_WRITE_EVENT_DATA) {
 637                 evbuf = (struct evbuf_header *)(sccb + 1);
 638                 if (!(evbuf->flags & 0x80))
 639                         return false;
 640         }
 641
 642         return true;
 643 }
 644
 645 /* Handler for external interruption. Perform request post-processing.
 646  * Prepare read event data request if necessary. Start processing of next
 647  * request on queue. */
 648 static void sclp_interrupt_handler(struct ext_code ext_code,
 649                                    unsigned int param32, unsigned long param64)
 650 {
 651         struct sclp_req *req;
 652         u32 finished_sccb;
 653         u32 evbuf_pending;
 654
 655         inc_irq_stat(IRQEXT_SCP);
 656         spin_lock(&sclp_lock);
 657         finished_sccb = param32 & 0xfffffff8;
 658         evbuf_pending = param32 & 0x3;
 659
 660         /* INT: Interrupt received (a=intparm, b=cmd) */
 661         sclp_trace_sccb(0, "INT", param32, active_cmd, active_cmd,
 662                         (struct sccb_header *)__va(finished_sccb),
 663                         !ok_response(finished_sccb, active_cmd));
 664
 665         if (finished_sccb) {
 666                 del_timer(&sclp_request_timer);
 667                 sclp_running_state = sclp_running_state_reset_pending;
 668                 req = __sclp_find_req(finished_sccb);
 669                 if (req) {
 670                         /* Request post-processing */
 671                         list_del(&req->list);
 672                         req->status = SCLP_REQ_DONE;
 673
 674                         /* RQOK: Request success (a=sccb, b=summary) */
 675                         sclp_trace_req(2, "RQOK", req, false);
 676
 677                         if (req->callback) {
 678                                 spin_unlock(&sclp_lock);
 679                                 req->callback(req, req->callback_data);
 680                                 spin_lock(&sclp_lock);
 681                         }
 682                 } else {
 683                         /* UNEX: Unexpected SCCB completion (a=sccb address) */
 684                         sclp_trace(0, "UNEX", finished_sccb, 0, true);
 685                 }
 686                 sclp_running_state = sclp_running_state_idle;
 687                 active_cmd = 0;
 688         }
 689         if (evbuf_pending &&
 690             sclp_activation_state == sclp_activation_state_active)
 691                 __sclp_queue_read_req();
 692         spin_unlock(&sclp_lock);
 693         sclp_process_queue();
 694 }
 695
 696 /* Convert interval in jiffies to TOD ticks. */
 697 static inline u64
 698 sclp_tod_from_jiffies(unsigned long jiffies)
 699 {
 700         return (u64) (jiffies / HZ) << 32;
 701 }
 702
 703 /* Wait until a currently running request finished. Note: while this function
 704  * is running, no timers are served on the calling CPU. */
 705 void
 706 sclp_sync_wait(void)
 707 {
 708         unsigned long long old_tick;
 709         struct ctlreg cr0, cr0_sync;
 710         unsigned long flags;
 711         static u64 sync_count;
 712         u64 timeout;
 713         int irq_context;
 714
 715         /* SYN1: Synchronous wait start (a=runstate, b=sync count) */
 716         sclp_trace(4, "SYN1", sclp_running_state, ++sync_count, false);
 717
 718         /* We'll be disabling timer interrupts, so we need a custom timeout
 719          * mechanism */
 720         timeout = 0;
 721         if (timer_pending(&sclp_request_timer)) {
 722                 /* Get timeout TOD value */
 723                 timeout = get_tod_clock_fast() +
 724                           sclp_tod_from_jiffies(sclp_request_timer.expires -
 725                                                 jiffies);
 726         }
 727         local_irq_save(flags);
 728         /* Prevent bottom half from executing once we force interrupts open */
 729         irq_context = in_interrupt();
 730         if (!irq_context)
 731                 local_bh_disable();
 732         /* Enable service-signal interruption, disable timer interrupts */
 733         old_tick = local_tick_disable();
 734         trace_hardirqs_on();
 735         local_ctl_store(0, &cr0);
 736         cr0_sync.val = cr0.val & ~CR0_IRQ_SUBCLASS_MASK;
 737         cr0_sync.val |= 1UL << (63 - 54);
 738         local_ctl_load(0, &cr0_sync);
 739         __arch_local_irq_stosm(0x01);
 740         /* Loop until driver state indicates finished request */
 741         while (sclp_running_state != sclp_running_state_idle) {
 742                 /* Check for expired request timer */
 743                 if (get_tod_clock_fast() > timeout && del_timer(&sclp_request_timer))
 744                         sclp_request_timer.function(&sclp_request_timer);
 745                 cpu_relax();
 746         }
 747         local_irq_disable();
 748         local_ctl_load(0, &cr0);
 749         if (!irq_context)
 750                 _local_bh_enable();
 751         local_tick_enable(old_tick);
 752         local_irq_restore(flags);
 753
 754         /* SYN2: Synchronous wait end (a=runstate, b=sync_count) */
 755         sclp_trace(4, "SYN2", sclp_running_state, sync_count, false);
 756 }
 757 EXPORT_SYMBOL(sclp_sync_wait);
 758
 759 /* Dispatch changes in send and receive mask to registered listeners. */
 760 static void
 761 sclp_dispatch_state_change(void)
 762 {
 763         struct list_head *l;
 764         struct sclp_register *reg;
 765         unsigned long flags;
 766         sccb_mask_t receive_mask;
 767         sccb_mask_t send_mask;
 768
 769         do {
 770                 spin_lock_irqsave(&sclp_lock, flags);
 771                 reg = NULL;
 772                 list_for_each(l, &sclp_reg_list) {
 773                         reg = list_entry(l, struct sclp_register, list);
 774                         receive_mask = reg->send_mask & sclp_receive_mask;
 775                         send_mask = reg->receive_mask & sclp_send_mask;
 776                         if (reg->sclp_receive_mask != receive_mask ||
 777                             reg->sclp_send_mask != send_mask) {
 778                                 reg->sclp_receive_mask = receive_mask;
 779                                 reg->sclp_send_mask = send_mask;
 780                                 break;
 781                         } else
 782                                 reg = NULL;
 783                 }
 784                 spin_unlock_irqrestore(&sclp_lock, flags);
 785                 if (reg && reg->state_change_fn) {
 786                         /* STCG: State-change callback (b=callback) */
 787                         sclp_trace(2, "STCG", 0, (u64)reg->state_change_fn,
 788                                    false);
 789
 790                         reg->state_change_fn(reg);
 791                 }
 792         } while (reg);
 793 }
 794
 795 struct sclp_statechangebuf {
 796         struct evbuf_header     header;
 797         u8              validity_sclp_active_facility_mask : 1;
 798         u8              validity_sclp_receive_mask : 1;
 799         u8              validity_sclp_send_mask : 1;
 800         u8              validity_read_data_function_mask : 1;
 801         u16             _zeros : 12;
 802         u16             mask_length;
 803         u64             sclp_active_facility_mask;
 804         u8              masks[2 * 1021 + 4];    /* variable length */
 805         /*
 806          * u8           sclp_receive_mask[mask_length];
 807          * u8           sclp_send_mask[mask_length];
 808          * u32          read_data_function_mask;
 809          */
 810 } __attribute__((packed));
 811
 812
 813 /* State change event callback. Inform listeners of changes. */
 814 static void
 815 sclp_state_change_cb(struct evbuf_header *evbuf)
 816 {
 817         unsigned long flags;
 818         struct sclp_statechangebuf *scbuf;
 819
 820         BUILD_BUG_ON(sizeof(struct sclp_statechangebuf) > PAGE_SIZE);
 821
 822         scbuf = (struct sclp_statechangebuf *) evbuf;
 823         spin_lock_irqsave(&sclp_lock, flags);
 824         if (scbuf->validity_sclp_receive_mask)
 825                 sclp_receive_mask = sccb_get_recv_mask(scbuf);
 826         if (scbuf->validity_sclp_send_mask)
 827                 sclp_send_mask = sccb_get_send_mask(scbuf);
 828         spin_unlock_irqrestore(&sclp_lock, flags);
 829         if (scbuf->validity_sclp_active_facility_mask)
 830                 sclp.facilities = scbuf->sclp_active_facility_mask;
 831         sclp_dispatch_state_change();
 832 }
 833
 834 static struct sclp_register sclp_state_change_event = {
 835         .receive_mask = EVTYP_STATECHANGE_MASK,
 836         .receiver_fn = sclp_state_change_cb
 837 };
 838
 839 /* Calculate receive and send mask of currently registered listeners.
 840  * Called while sclp_lock is locked. */
 841 static inline void
 842 __sclp_get_mask(sccb_mask_t *receive_mask, sccb_mask_t *send_mask)
 843 {
 844         struct list_head *l;
 845         struct sclp_register *t;
 846
 847         *receive_mask = 0;
 848         *send_mask = 0;
 849         list_for_each(l, &sclp_reg_list) {
 850                 t = list_entry(l, struct sclp_register, list);
 851                 *receive_mask |= t->receive_mask;
 852                 *send_mask |= t->send_mask;
 853         }
 854 }
 855
 856 /* Register event listener. Return 0 on success, non-zero otherwise. */
 857 int
 858 sclp_register(struct sclp_register *reg)
 859 {
 860         unsigned long flags;
 861         sccb_mask_t receive_mask;
 862         sccb_mask_t send_mask;
 863         int rc;
 864
 865         /* REG: Event listener registered (b=caller) */
 866         sclp_trace_register(2, "REG", 0, _RET_IP_, reg);
 867
 868         rc = sclp_init();
 869         if (rc)
 870                 return rc;
 871         spin_lock_irqsave(&sclp_lock, flags);
 872         /* Check event mask for collisions */
 873         __sclp_get_mask(&receive_mask, &send_mask);
 874         if (reg->receive_mask & receive_mask || reg->send_mask & send_mask) {
 875                 spin_unlock_irqrestore(&sclp_lock, flags);
 876                 return -EBUSY;
 877         }
 878         /* Trigger initial state change callback */
 879         reg->sclp_receive_mask = 0;
 880         reg->sclp_send_mask = 0;
 881         list_add(&reg->list, &sclp_reg_list);
 882         spin_unlock_irqrestore(&sclp_lock, flags);
 883         rc = sclp_init_mask(1);
 884         if (rc) {
 885                 spin_lock_irqsave(&sclp_lock, flags);
 886                 list_del(&reg->list);
 887                 spin_unlock_irqrestore(&sclp_lock, flags);
 888         }
 889         return rc;
 890 }
 891
 892 EXPORT_SYMBOL(sclp_register);
 893
 894 /* Unregister event listener. */
 895 void
 896 sclp_unregister(struct sclp_register *reg)
 897 {
 898         unsigned long flags;
 899
 900         /* UREG: Event listener unregistered (b=caller) */
 901         sclp_trace_register(2, "UREG", 0, _RET_IP_, reg);
 902
 903         spin_lock_irqsave(&sclp_lock, flags);
 904         list_del(&reg->list);
 905         spin_unlock_irqrestore(&sclp_lock, flags);
 906         sclp_init_mask(1);
 907 }
 908
 909 EXPORT_SYMBOL(sclp_unregister);
 910
 911 /* Remove event buffers which are marked processed. Return the number of
 912  * remaining event buffers. */
 913 int
 914 sclp_remove_processed(struct sccb_header *sccb)
 915 {
 916         struct evbuf_header *evbuf;
 917         int unprocessed;
 918         u16 remaining;
 919
 920         evbuf = (struct evbuf_header *) (sccb + 1);
 921         unprocessed = 0;
 922         remaining = sccb->length - sizeof(struct sccb_header);
 923         while (remaining > 0) {
 924                 remaining -= evbuf->length;
 925                 if (evbuf->flags & 0x80) {
 926                         sccb->length -= evbuf->length;
 927                         memcpy(evbuf, (void *) ((addr_t) evbuf + evbuf->length),
 928                                remaining);
 929                 } else {
 930                         unprocessed++;
 931                         evbuf = (struct evbuf_header *)
 932                                         ((addr_t) evbuf + evbuf->length);
 933                 }
 934         }
 935         return unprocessed;
 936 }
 937
 938 EXPORT_SYMBOL(sclp_remove_processed);
 939
 940 /* Prepare init mask request. Called while sclp_lock is locked. */
 941 static inline void
 942 __sclp_make_init_req(sccb_mask_t receive_mask, sccb_mask_t send_mask)
 943 {
 944         struct init_sccb *sccb = sclp_init_sccb;
 945
 946         clear_page(sccb);
 947         memset(&sclp_init_req, 0, sizeof(struct sclp_req));
 948         sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
 949         sclp_init_req.status = SCLP_REQ_FILLED;
 950         sclp_init_req.start_count = 0;
 951         sclp_init_req.callback = NULL;
 952         sclp_init_req.callback_data = NULL;
 953         sclp_init_req.sccb = sccb;
 954         sccb->header.length = sizeof(*sccb);
 955         if (sclp_mask_compat_mode)
 956                 sccb->mask_length = SCLP_MASK_SIZE_COMPAT;
 957         else
 958                 sccb->mask_length = sizeof(sccb_mask_t);
 959         sccb_set_recv_mask(sccb, receive_mask);
 960         sccb_set_send_mask(sccb, send_mask);
 961         sccb_set_sclp_recv_mask(sccb, 0);
 962         sccb_set_sclp_send_mask(sccb, 0);
 963 }
 964
 965 /* Start init mask request. If calculate is non-zero, calculate the mask as
 966  * requested by registered listeners. Use zero mask otherwise. Return 0 on
 967  * success, non-zero otherwise. */
 968 static int
 969 sclp_init_mask(int calculate)
 970 {
 971         unsigned long flags;
 972         struct init_sccb *sccb = sclp_init_sccb;
 973         sccb_mask_t receive_mask;
 974         sccb_mask_t send_mask;
 975         int retry;
 976         int rc;
 977         unsigned long wait;
 978
 979         spin_lock_irqsave(&sclp_lock, flags);
 980         /* Check if interface is in appropriate state */
 981         if (sclp_mask_state != sclp_mask_state_idle) {
 982                 spin_unlock_irqrestore(&sclp_lock, flags);
 983                 return -EBUSY;
 984         }
 985         if (sclp_activation_state == sclp_activation_state_inactive) {
 986                 spin_unlock_irqrestore(&sclp_lock, flags);
 987                 return -EINVAL;
 988         }
 989         sclp_mask_state = sclp_mask_state_initializing;
 990         /* Determine mask */
 991         if (calculate)
 992                 __sclp_get_mask(&receive_mask, &send_mask);
 993         else {
 994                 receive_mask = 0;
 995                 send_mask = 0;
 996         }
 997         rc = -EIO;
 998         for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
 999                 /* Prepare request */
1000                 __sclp_make_init_req(receive_mask, send_mask);
1001                 spin_unlock_irqrestore(&sclp_lock, flags);
1002                 if (sclp_add_request(&sclp_init_req)) {
1003                         /* Try again later */
1004                         wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
1005                         while (time_before(jiffies, wait))
1006                                 sclp_sync_wait();
1007                         spin_lock_irqsave(&sclp_lock, flags);
1008                         continue;
1009                 }
1010                 while (sclp_init_req.status != SCLP_REQ_DONE &&
1011                        sclp_init_req.status != SCLP_REQ_FAILED)
1012                         sclp_sync_wait();
1013                 spin_lock_irqsave(&sclp_lock, flags);
1014                 if (sclp_init_req.status == SCLP_REQ_DONE &&
1015                     sccb->header.response_code == 0x20) {
1016                         /* Successful request */
1017                         if (calculate) {
1018                                 sclp_receive_mask = sccb_get_sclp_recv_mask(sccb);
1019                                 sclp_send_mask = sccb_get_sclp_send_mask(sccb);
1020                         } else {
1021                                 sclp_receive_mask = 0;
1022                                 sclp_send_mask = 0;
1023                         }
1024                         spin_unlock_irqrestore(&sclp_lock, flags);
1025                         sclp_dispatch_state_change();
1026                         spin_lock_irqsave(&sclp_lock, flags);
1027                         rc = 0;
1028                         break;
1029                 }
1030         }
1031         sclp_mask_state = sclp_mask_state_idle;
1032         spin_unlock_irqrestore(&sclp_lock, flags);
1033         return rc;
1034 }
1035
1036 /* Deactivate SCLP interface. On success, new requests will be rejected,
1037  * events will no longer be dispatched. Return 0 on success, non-zero
1038  * otherwise. */
1039 int
1040 sclp_deactivate(void)
1041 {
1042         unsigned long flags;
1043         int rc;
1044
1045         spin_lock_irqsave(&sclp_lock, flags);
1046         /* Deactivate can only be called when active */
1047         if (sclp_activation_state != sclp_activation_state_active) {
1048                 spin_unlock_irqrestore(&sclp_lock, flags);
1049                 return -EINVAL;
1050         }
1051         sclp_activation_state = sclp_activation_state_deactivating;
1052         spin_unlock_irqrestore(&sclp_lock, flags);
1053         rc = sclp_init_mask(0);
1054         spin_lock_irqsave(&sclp_lock, flags);
1055         if (rc == 0)
1056                 sclp_activation_state = sclp_activation_state_inactive;
1057         else
1058                 sclp_activation_state = sclp_activation_state_active;
1059         spin_unlock_irqrestore(&sclp_lock, flags);
1060         return rc;
1061 }
1062
1063 EXPORT_SYMBOL(sclp_deactivate);
1064
1065 /* Reactivate SCLP interface after sclp_deactivate. On success, new
1066  * requests will be accepted, events will be dispatched again. Return 0 on
1067  * success, non-zero otherwise. */
1068 int
1069 sclp_reactivate(void)
1070 {
1071         unsigned long flags;
1072         int rc;
1073
1074         spin_lock_irqsave(&sclp_lock, flags);
1075         /* Reactivate can only be called when inactive */
1076         if (sclp_activation_state != sclp_activation_state_inactive) {
1077                 spin_unlock_irqrestore(&sclp_lock, flags);
1078                 return -EINVAL;
1079         }
1080         sclp_activation_state = sclp_activation_state_activating;
1081         spin_unlock_irqrestore(&sclp_lock, flags);
1082         rc = sclp_init_mask(1);
1083         spin_lock_irqsave(&sclp_lock, flags);
1084         if (rc == 0)
1085                 sclp_activation_state = sclp_activation_state_active;
1086         else
1087                 sclp_activation_state = sclp_activation_state_inactive;
1088         spin_unlock_irqrestore(&sclp_lock, flags);
1089         return rc;
1090 }
1091
1092 EXPORT_SYMBOL(sclp_reactivate);
1093
1094 /* Handler for external interruption used during initialization. Modify
1095  * request state to done. */
1096 static void sclp_check_handler(struct ext_code ext_code,
1097                                unsigned int param32, unsigned long param64)
1098 {
1099         u32 finished_sccb;
1100
1101         inc_irq_stat(IRQEXT_SCP);
1102         finished_sccb = param32 & 0xfffffff8;
1103         /* Is this the interrupt we are waiting for? */
1104         if (finished_sccb == 0)
1105                 return;
1106         if (finished_sccb != __pa(sclp_init_sccb))
1107                 panic("sclp: unsolicited interrupt for buffer at 0x%x\n",
1108                       finished_sccb);
1109         spin_lock(&sclp_lock);
1110         if (sclp_running_state == sclp_running_state_running) {
1111                 sclp_init_req.status = SCLP_REQ_DONE;
1112                 sclp_running_state = sclp_running_state_idle;
1113         }
1114         spin_unlock(&sclp_lock);
1115 }
1116
1117 /* Initial init mask request timed out. Modify request state to failed. */
1118 static void
1119 sclp_check_timeout(struct timer_list *unused)
1120 {
1121         unsigned long flags;
1122
1123         spin_lock_irqsave(&sclp_lock, flags);
1124         if (sclp_running_state == sclp_running_state_running) {
1125                 sclp_init_req.status = SCLP_REQ_FAILED;
1126                 sclp_running_state = sclp_running_state_idle;
1127         }
1128         spin_unlock_irqrestore(&sclp_lock, flags);
1129 }
1130
1131 /* Perform a check of the SCLP interface. Return zero if the interface is
1132  * available and there are no pending requests from a previous instance.
1133  * Return non-zero otherwise. */
1134 static int
1135 sclp_check_interface(void)
1136 {
1137         struct init_sccb *sccb;
1138         unsigned long flags;
1139         int retry;
1140         int rc;
1141
1142         spin_lock_irqsave(&sclp_lock, flags);
1143         /* Prepare init mask command */
1144         rc = register_external_irq(EXT_IRQ_SERVICE_SIG, sclp_check_handler);
1145         if (rc) {
1146                 spin_unlock_irqrestore(&sclp_lock, flags);
1147                 return rc;
1148         }
1149         for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
1150                 __sclp_make_init_req(0, 0);
1151                 sccb = (struct init_sccb *) sclp_init_req.sccb;
1152                 rc = sclp_service_call_trace(sclp_init_req.command, sccb);
1153                 if (rc == -EIO)
1154                         break;
1155                 sclp_init_req.status = SCLP_REQ_RUNNING;
1156                 sclp_running_state = sclp_running_state_running;
1157                 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
1158                                          sclp_check_timeout);
1159                 spin_unlock_irqrestore(&sclp_lock, flags);
1160                 /* Enable service-signal interruption - needs to happen
1161                  * with IRQs enabled. */
1162                 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
1163                 /* Wait for signal from interrupt or timeout */
1164                 sclp_sync_wait();
1165                 /* Disable service-signal interruption - needs to happen
1166                  * with IRQs enabled. */
1167                 irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL);
1168                 spin_lock_irqsave(&sclp_lock, flags);
1169                 del_timer(&sclp_request_timer);
1170                 rc = -EBUSY;
1171                 if (sclp_init_req.status == SCLP_REQ_DONE) {
1172                         if (sccb->header.response_code == 0x20) {
1173                                 rc = 0;
1174                                 break;
1175                         } else if (sccb->header.response_code == 0x74f0) {
1176                                 if (!sclp_mask_compat_mode) {
1177                                         sclp_mask_compat_mode = true;
1178                                         retry = 0;
1179                                 }
1180                         }
1181                 }
1182         }
1183         unregister_external_irq(EXT_IRQ_SERVICE_SIG, sclp_check_handler);
1184         spin_unlock_irqrestore(&sclp_lock, flags);
1185         return rc;
1186 }
1187
1188 /* Reboot event handler. Reset send and receive mask to prevent pending SCLP
1189  * events from interfering with rebooted system. */
1190 static int
1191 sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
1192 {
1193         sclp_deactivate();
1194         return NOTIFY_DONE;
1195 }
1196
1197 static struct notifier_block sclp_reboot_notifier = {
1198         .notifier_call = sclp_reboot_event
1199 };
1200
1201 static ssize_t con_pages_show(struct device_driver *dev, char *buf)
1202 {
1203         return sysfs_emit(buf, "%i\n", sclp_console_pages);
1204 }
1205
1206 static DRIVER_ATTR_RO(con_pages);
1207
1208 static ssize_t con_drop_store(struct device_driver *dev, const char *buf, size_t count)
1209 {
1210         int rc;
1211
1212         rc = kstrtobool(buf, &sclp_console_drop);
1213         return rc ?: count;
1214 }
1215
1216 static ssize_t con_drop_show(struct device_driver *dev, char *buf)
1217 {
1218         return sysfs_emit(buf, "%i\n", sclp_console_drop);
1219 }
1220
1221 static DRIVER_ATTR_RW(con_drop);
1222
1223 static ssize_t con_full_show(struct device_driver *dev, char *buf)
1224 {
1225         return sysfs_emit(buf, "%lu\n", sclp_console_full);
1226 }
1227
1228 static DRIVER_ATTR_RO(con_full);
1229
1230 static struct attribute *sclp_drv_attrs[] = {
1231         &driver_attr_con_pages.attr,
1232         &driver_attr_con_drop.attr,
1233         &driver_attr_con_full.attr,
1234         NULL,
1235 };
1236 static struct attribute_group sclp_drv_attr_group = {
1237         .attrs = sclp_drv_attrs,
1238 };
1239 static const struct attribute_group *sclp_drv_attr_groups[] = {
1240         &sclp_drv_attr_group,
1241         NULL,
1242 };
1243
1244 static struct platform_driver sclp_pdrv = {
1245         .driver = {
1246                 .name   = "sclp",
1247                 .groups = sclp_drv_attr_groups,
1248         },
1249 };
1250
1251 /* Initialize SCLP driver. Return zero if driver is operational, non-zero
1252  * otherwise. */
1253 static int
1254 sclp_init(void)
1255 {
1256         unsigned long flags;
1257         int rc = 0;
1258
1259         spin_lock_irqsave(&sclp_lock, flags);
1260         /* Check for previous or running initialization */
1261         if (sclp_init_state != sclp_init_state_uninitialized)
1262                 goto fail_unlock;
1263         sclp_init_state = sclp_init_state_initializing;
1264         sclp_read_sccb = (void *) __get_free_page(GFP_ATOMIC | GFP_DMA);
1265         sclp_init_sccb = (void *) __get_free_page(GFP_ATOMIC | GFP_DMA);
1266         BUG_ON(!sclp_read_sccb || !sclp_init_sccb);
1267         /* Set up variables */
1268         list_add(&sclp_state_change_event.list, &sclp_reg_list);
1269         timer_setup(&sclp_request_timer, NULL, 0);
1270         timer_setup(&sclp_queue_timer, sclp_req_queue_timeout, 0);
1271         /* Check interface */
1272         spin_unlock_irqrestore(&sclp_lock, flags);
1273         rc = sclp_check_interface();
1274         spin_lock_irqsave(&sclp_lock, flags);
1275         if (rc)
1276                 goto fail_init_state_uninitialized;
1277         /* Register reboot handler */
1278         rc = register_reboot_notifier(&sclp_reboot_notifier);
1279         if (rc)
1280                 goto fail_init_state_uninitialized;
1281         /* Register interrupt handler */
1282         rc = register_external_irq(EXT_IRQ_SERVICE_SIG, sclp_interrupt_handler);
1283         if (rc)
1284                 goto fail_unregister_reboot_notifier;
1285         sclp_init_state = sclp_init_state_initialized;
1286         spin_unlock_irqrestore(&sclp_lock, flags);
1287         /* Enable service-signal external interruption - needs to happen with
1288          * IRQs enabled. */
1289         irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
1290         sclp_init_mask(1);
1291         return 0;
1292
1293 fail_unregister_reboot_notifier:
1294         unregister_reboot_notifier(&sclp_reboot_notifier);
1295 fail_init_state_uninitialized:
1296         list_del(&sclp_state_change_event.list);
1297         sclp_init_state = sclp_init_state_uninitialized;
1298         free_page((unsigned long) sclp_read_sccb);
1299         free_page((unsigned long) sclp_init_sccb);
1300 fail_unlock:
1301         spin_unlock_irqrestore(&sclp_lock, flags);
1302         return rc;
1303 }
1304
1305 static __init int sclp_initcall(void)
1306 {
1307         int rc;
1308
1309         rc = platform_driver_register(&sclp_pdrv);
1310         if (rc)
1311                 return rc;
1312
1313         return sclp_init();
1314 }
1315
1316 arch_initcall(sclp_initcall);