drivers/s390/char/sclp.c

   1 /*
   2  *  drivers/s390/char/sclp.c
   3  *     core function to access sclp interface
   4  *
   5  *  S390 version
   6  *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
   7  *    Author(s): Martin Peschke <mpeschke@de.ibm.com>
   8  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/err.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/timer.h>
  16 #include <linux/reboot.h>
  17 #include <linux/jiffies.h>
  18 #include <asm/types.h>
  19 #include <asm/s390_ext.h>
  20
  21 #include "sclp.h"
  22
  23 #define SCLP_HEADER             "sclp: "
  24
  25 /* Structure for register_early_external_interrupt. */
  26 static ext_int_info_t ext_int_info_hwc;
  27
  28 /* Lock to protect internal data consistency. */
  29 static DEFINE_SPINLOCK(sclp_lock);
  30
  31 /* Mask of events that we can receive from the sclp interface. */
  32 static sccb_mask_t sclp_receive_mask;
  33
  34 /* Mask of events that we can send to the sclp interface. */
  35 static sccb_mask_t sclp_send_mask;
  36
  37 /* List of registered event listeners and senders. */
  38 static struct list_head sclp_reg_list;
  39
  40 /* List of queued requests. */
  41 static struct list_head sclp_req_queue;
  42
  43 /* Data for read and and init requests. */
  44 static struct sclp_req sclp_read_req;
  45 static struct sclp_req sclp_init_req;
  46 static char sclp_read_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
  47 static char sclp_init_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
  48
  49 /* Timer for request retries. */
  50 static struct timer_list sclp_request_timer;
  51
  52 /* Internal state: is the driver initialized? */
  53 static volatile enum sclp_init_state_t {
  54         sclp_init_state_uninitialized,
  55         sclp_init_state_initializing,
  56         sclp_init_state_initialized
  57 } sclp_init_state = sclp_init_state_uninitialized;
  58
  59 /* Internal state: is a request active at the sclp? */
  60 static volatile enum sclp_running_state_t {
  61         sclp_running_state_idle,
  62         sclp_running_state_running
  63 } sclp_running_state = sclp_running_state_idle;
  64
  65 /* Internal state: is a read request pending? */
  66 static volatile enum sclp_reading_state_t {
  67         sclp_reading_state_idle,
  68         sclp_reading_state_reading
  69 } sclp_reading_state = sclp_reading_state_idle;
  70
  71 /* Internal state: is the driver currently serving requests? */
  72 static volatile enum sclp_activation_state_t {
  73         sclp_activation_state_active,
  74         sclp_activation_state_deactivating,
  75         sclp_activation_state_inactive,
  76         sclp_activation_state_activating
  77 } sclp_activation_state = sclp_activation_state_active;
  78
  79 /* Internal state: is an init mask request pending? */
  80 static volatile enum sclp_mask_state_t {
  81         sclp_mask_state_idle,
  82         sclp_mask_state_initializing
  83 } sclp_mask_state = sclp_mask_state_idle;
  84
  85 /* Maximum retry counts */
  86 #define SCLP_INIT_RETRY         3
  87 #define SCLP_MASK_RETRY         3
  88 #define SCLP_REQUEST_RETRY      3
  89
  90 /* Timeout intervals in seconds.*/
  91 #define SCLP_BUSY_INTERVAL      2
  92 #define SCLP_RETRY_INTERVAL     5
  93
  94 static void sclp_process_queue(void);
  95 static int sclp_init_mask(int calculate);
  96 static int sclp_init(void);
  97
  98 /* Perform service call. Return 0 on success, non-zero otherwise. */
  99 static int
 100 service_call(sclp_cmdw_t command, void *sccb)
 101 {
 102         int cc;
 103
 104         __asm__ __volatile__(
 105                 "   .insn rre,0xb2200000,%1,%2\n"  /* servc %1,%2 */
 106                 "   ipm   %0\n"
 107                 "   srl   %0,28"
 108                 : "=&d" (cc)
 109                 : "d" (command), "a" (__pa(sccb))
 110                 : "cc", "memory" );
 111         if (cc == 3)
 112                 return -EIO;
 113         if (cc == 2)
 114                 return -EBUSY;
 115         return 0;
 116 }
 117
 118 /* Request timeout handler. Restart the request queue. If DATA is non-zero,
 119  * force restart of running request. */
 120 static void
 121 sclp_request_timeout(unsigned long data)
 122 {
 123         unsigned long flags;
 124
 125         if (data) {
 126                 spin_lock_irqsave(&sclp_lock, flags);
 127                 sclp_running_state = sclp_running_state_idle;
 128                 spin_unlock_irqrestore(&sclp_lock, flags);
 129         }
 130         sclp_process_queue();
 131 }
 132
 133 /* Set up request retry timer. Called while sclp_lock is locked. */
 134 static inline void
 135 __sclp_set_request_timer(unsigned long time, void (*function)(unsigned long),
 136                          unsigned long data)
 137 {
 138         del_timer(&sclp_request_timer);
 139         sclp_request_timer.function = function;
 140         sclp_request_timer.data = data;
 141         sclp_request_timer.expires = jiffies + time;
 142         add_timer(&sclp_request_timer);
 143 }
 144
 145 /* Try to start a request. Return zero if the request was successfully
 146  * started or if it will be started at a later time. Return non-zero otherwise.
 147  * Called while sclp_lock is locked. */
 148 static int
 149 __sclp_start_request(struct sclp_req *req)
 150 {
 151         int rc;
 152
 153         if (sclp_running_state != sclp_running_state_idle)
 154                 return 0;
 155         del_timer(&sclp_request_timer);
 156         if (req->start_count <= SCLP_REQUEST_RETRY) {
 157                 rc = service_call(req->command, req->sccb);
 158                 req->start_count++;
 159         } else
 160                 rc = -EIO;
 161         if (rc == 0) {
 162                 /* Sucessfully started request */
 163                 req->status = SCLP_REQ_RUNNING;
 164                 sclp_running_state = sclp_running_state_running;
 165                 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
 166                                          sclp_request_timeout, 1);
 167                 return 0;
 168         } else if (rc == -EBUSY) {
 169                 /* Try again later */
 170                 __sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 171                                          sclp_request_timeout, 0);
 172                 return 0;
 173         }
 174         /* Request failed */
 175         req->status = SCLP_REQ_FAILED;
 176         return rc;
 177 }
 178
 179 /* Try to start queued requests. */
 180 static void
 181 sclp_process_queue(void)
 182 {
 183         struct sclp_req *req;
 184         int rc;
 185         unsigned long flags;
 186
 187         spin_lock_irqsave(&sclp_lock, flags);
 188         if (sclp_running_state != sclp_running_state_idle) {
 189                 spin_unlock_irqrestore(&sclp_lock, flags);
 190                 return;
 191         }
 192         del_timer(&sclp_request_timer);
 193         while (!list_empty(&sclp_req_queue)) {
 194                 req = list_entry(sclp_req_queue.next, struct sclp_req, list);
 195                 rc = __sclp_start_request(req);
 196                 if (rc == 0)
 197                         break;
 198                 /* Request failed. */
 199                 list_del(&req->list);
 200                 if (req->callback) {
 201                         spin_unlock_irqrestore(&sclp_lock, flags);
 202                         req->callback(req, req->callback_data);
 203                         spin_lock_irqsave(&sclp_lock, flags);
 204                 }
 205         }
 206         spin_unlock_irqrestore(&sclp_lock, flags);
 207 }
 208
 209 /* Queue a new request. Return zero on success, non-zero otherwise. */
 210 int
 211 sclp_add_request(struct sclp_req *req)
 212 {
 213         unsigned long flags;
 214         int rc;
 215
 216         spin_lock_irqsave(&sclp_lock, flags);
 217         if ((sclp_init_state != sclp_init_state_initialized ||
 218              sclp_activation_state != sclp_activation_state_active) &&
 219             req != &sclp_init_req) {
 220                 spin_unlock_irqrestore(&sclp_lock, flags);
 221                 return -EIO;
 222         }
 223         req->status = SCLP_REQ_QUEUED;
 224         req->start_count = 0;
 225         list_add_tail(&req->list, &sclp_req_queue);
 226         rc = 0;
 227         /* Start if request is first in list */
 228         if (req->list.prev == &sclp_req_queue) {
 229                 rc = __sclp_start_request(req);
 230                 if (rc)
 231                         list_del(&req->list);
 232         }
 233         spin_unlock_irqrestore(&sclp_lock, flags);
 234         return rc;
 235 }
 236
 237 EXPORT_SYMBOL(sclp_add_request);
 238
 239 /* Dispatch events found in request buffer to registered listeners. Return 0
 240  * if all events were dispatched, non-zero otherwise. */
 241 static int
 242 sclp_dispatch_evbufs(struct sccb_header *sccb)
 243 {
 244         unsigned long flags;
 245         struct evbuf_header *evbuf;
 246         struct list_head *l;
 247         struct sclp_register *reg;
 248         int offset;
 249         int rc;
 250
 251         spin_lock_irqsave(&sclp_lock, flags);
 252         rc = 0;
 253         for (offset = sizeof(struct sccb_header); offset < sccb->length;
 254              offset += evbuf->length) {
 255                 /* Search for event handler */
 256                 evbuf = (struct evbuf_header *) ((addr_t) sccb + offset);
 257                 reg = NULL;
 258                 list_for_each(l, &sclp_reg_list) {
 259                         reg = list_entry(l, struct sclp_register, list);
 260                         if (reg->receive_mask & (1 << (32 - evbuf->type)))
 261                                 break;
 262                         else
 263                                 reg = NULL;
 264                 }
 265                 if (reg && reg->receiver_fn) {
 266                         spin_unlock_irqrestore(&sclp_lock, flags);
 267                         reg->receiver_fn(evbuf);
 268                         spin_lock_irqsave(&sclp_lock, flags);
 269                 } else if (reg == NULL)
 270                         rc = -ENOSYS;
 271         }
 272         spin_unlock_irqrestore(&sclp_lock, flags);
 273         return rc;
 274 }
 275
 276 /* Read event data request callback. */
 277 static void
 278 sclp_read_cb(struct sclp_req *req, void *data)
 279 {
 280         unsigned long flags;
 281         struct sccb_header *sccb;
 282
 283         sccb = (struct sccb_header *) req->sccb;
 284         if (req->status == SCLP_REQ_DONE && (sccb->response_code == 0x20 ||
 285             sccb->response_code == 0x220))
 286                 sclp_dispatch_evbufs(sccb);
 287         spin_lock_irqsave(&sclp_lock, flags);
 288         sclp_reading_state = sclp_reading_state_idle;
 289         spin_unlock_irqrestore(&sclp_lock, flags);
 290 }
 291
 292 /* Prepare read event data request. Called while sclp_lock is locked. */
 293 static inline void
 294 __sclp_make_read_req(void)
 295 {
 296         struct sccb_header *sccb;
 297
 298         sccb = (struct sccb_header *) sclp_read_sccb;
 299         clear_page(sccb);
 300         memset(&sclp_read_req, 0, sizeof(struct sclp_req));
 301         sclp_read_req.command = SCLP_CMDW_READDATA;
 302         sclp_read_req.status = SCLP_REQ_QUEUED;
 303         sclp_read_req.start_count = 0;
 304         sclp_read_req.callback = sclp_read_cb;
 305         sclp_read_req.sccb = sccb;
 306         sccb->length = PAGE_SIZE;
 307         sccb->function_code = 0;
 308         sccb->control_mask[2] = 0x80;
 309 }
 310
 311 /* Search request list for request with matching sccb. Return request if found,
 312  * NULL otherwise. Called while sclp_lock is locked. */
 313 static inline struct sclp_req *
 314 __sclp_find_req(u32 sccb)
 315 {
 316         struct list_head *l;
 317         struct sclp_req *req;
 318
 319         list_for_each(l, &sclp_req_queue) {
 320                 req = list_entry(l, struct sclp_req, list);
 321                 if (sccb == (u32) (addr_t) req->sccb)
 322                                 return req;
 323         }
 324         return NULL;
 325 }
 326
 327 /* Handler for external interruption. Perform request post-processing.
 328  * Prepare read event data request if necessary. Start processing of next
 329  * request on queue. */
 330 static void
 331 sclp_interrupt_handler(struct pt_regs *regs, __u16 code)
 332 {
 333         struct sclp_req *req;
 334         u32 finished_sccb;
 335         u32 evbuf_pending;
 336
 337         spin_lock(&sclp_lock);
 338         finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
 339         evbuf_pending = S390_lowcore.ext_params & 0x3;
 340         if (finished_sccb) {
 341                 req = __sclp_find_req(finished_sccb);
 342                 if (req) {
 343                         /* Request post-processing */
 344                         list_del(&req->list);
 345                         req->status = SCLP_REQ_DONE;
 346                         if (req->callback) {
 347                                 spin_unlock(&sclp_lock);
 348                                 req->callback(req, req->callback_data);
 349                                 spin_lock(&sclp_lock);
 350                         }
 351                 }
 352                 sclp_running_state = sclp_running_state_idle;
 353         }
 354         if (evbuf_pending && sclp_receive_mask != 0 &&
 355             sclp_reading_state == sclp_reading_state_idle &&
 356             sclp_activation_state == sclp_activation_state_active ) {
 357                 sclp_reading_state = sclp_reading_state_reading;
 358                 __sclp_make_read_req();
 359                 /* Add request to head of queue */
 360                 list_add(&sclp_read_req.list, &sclp_req_queue);
 361         }
 362         spin_unlock(&sclp_lock);
 363         sclp_process_queue();
 364 }
 365
 366 /* Return current Time-Of-Day clock. */
 367 static inline u64
 368 sclp_get_clock(void)
 369 {
 370         u64 result;
 371
 372         asm volatile ("STCK 0(%1)" : "=m" (result) : "a" (&(result)) : "cc");
 373         return result;
 374 }
 375
 376 /* Convert interval in jiffies to TOD ticks. */
 377 static inline u64
 378 sclp_tod_from_jiffies(unsigned long jiffies)
 379 {
 380         return (u64) (jiffies / HZ) << 32;
 381 }
 382
 383 /* Wait until a currently running request finished. Note: while this function
 384  * is running, no timers are served on the calling CPU. */
 385 void
 386 sclp_sync_wait(void)
 387 {
 388         unsigned long psw_mask;
 389         unsigned long cr0, cr0_sync;
 390         u64 timeout;
 391
 392         /* We'll be disabling timer interrupts, so we need a custom timeout
 393          * mechanism */
 394         timeout = 0;
 395         if (timer_pending(&sclp_request_timer)) {
 396                 /* Get timeout TOD value */
 397                 timeout = sclp_get_clock() +
 398                           sclp_tod_from_jiffies(sclp_request_timer.expires -
 399                                                 jiffies);
 400         }
 401         /* Prevent bottom half from executing once we force interrupts open */
 402         local_bh_disable();
 403         /* Enable service-signal interruption, disable timer interrupts */
 404         __ctl_store(cr0, 0, 0);
 405         cr0_sync = cr0;
 406         cr0_sync |= 0x00000200;
 407         cr0_sync &= 0xFFFFF3AC;
 408         __ctl_load(cr0_sync, 0, 0);
 409         asm volatile ("STOSM 0(%1),0x01"
 410                       : "=m" (psw_mask) : "a" (&psw_mask) : "memory");
 411         /* Loop until driver state indicates finished request */
 412         while (sclp_running_state != sclp_running_state_idle) {
 413                 /* Check for expired request timer */
 414                 if (timer_pending(&sclp_request_timer) &&
 415                     sclp_get_clock() > timeout &&
 416                     del_timer(&sclp_request_timer))
 417                         sclp_request_timer.function(sclp_request_timer.data);
 418                 barrier();
 419                 cpu_relax();
 420         }
 421         /* Restore interrupt settings */
 422         asm volatile ("SSM 0(%0)"
 423                       : : "a" (&psw_mask) : "memory");
 424         __ctl_load(cr0, 0, 0);
 425         __local_bh_enable();
 426 }
 427
 428 EXPORT_SYMBOL(sclp_sync_wait);
 429
 430 /* Dispatch changes in send and receive mask to registered listeners. */
 431 static inline void
 432 sclp_dispatch_state_change(void)
 433 {
 434         struct list_head *l;
 435         struct sclp_register *reg;
 436         unsigned long flags;
 437         sccb_mask_t receive_mask;
 438         sccb_mask_t send_mask;
 439
 440         do {
 441                 spin_lock_irqsave(&sclp_lock, flags);
 442                 reg = NULL;
 443                 list_for_each(l, &sclp_reg_list) {
 444                         reg = list_entry(l, struct sclp_register, list);
 445                         receive_mask = reg->receive_mask & sclp_receive_mask;
 446                         send_mask = reg->send_mask & sclp_send_mask;
 447                         if (reg->sclp_receive_mask != receive_mask ||
 448                             reg->sclp_send_mask != send_mask) {
 449                                 reg->sclp_receive_mask = receive_mask;
 450                                 reg->sclp_send_mask = send_mask;
 451                                 break;
 452                         } else
 453                                 reg = NULL;
 454                 }
 455                 spin_unlock_irqrestore(&sclp_lock, flags);
 456                 if (reg && reg->state_change_fn)
 457                         reg->state_change_fn(reg);
 458         } while (reg);
 459 }
 460
 461 struct sclp_statechangebuf {
 462         struct evbuf_header     header;
 463         u8              validity_sclp_active_facility_mask : 1;
 464         u8              validity_sclp_receive_mask : 1;
 465         u8              validity_sclp_send_mask : 1;
 466         u8              validity_read_data_function_mask : 1;
 467         u16             _zeros : 12;
 468         u16             mask_length;
 469         u64             sclp_active_facility_mask;
 470         sccb_mask_t     sclp_receive_mask;
 471         sccb_mask_t     sclp_send_mask;
 472         u32             read_data_function_mask;
 473 } __attribute__((packed));
 474
 475
 476 /* State change event callback. Inform listeners of changes. */
 477 static void
 478 sclp_state_change_cb(struct evbuf_header *evbuf)
 479 {
 480         unsigned long flags;
 481         struct sclp_statechangebuf *scbuf;
 482
 483         scbuf = (struct sclp_statechangebuf *) evbuf;
 484         if (scbuf->mask_length != sizeof(sccb_mask_t))
 485                 return;
 486         spin_lock_irqsave(&sclp_lock, flags);
 487         if (scbuf->validity_sclp_receive_mask)
 488                 sclp_receive_mask = scbuf->sclp_receive_mask;
 489         if (scbuf->validity_sclp_send_mask)
 490                 sclp_send_mask = scbuf->sclp_send_mask;
 491         spin_unlock_irqrestore(&sclp_lock, flags);
 492         sclp_dispatch_state_change();
 493 }
 494
 495 static struct sclp_register sclp_state_change_event = {
 496         .receive_mask = EvTyp_StateChange_Mask,
 497         .receiver_fn = sclp_state_change_cb
 498 };
 499
 500 /* Calculate receive and send mask of currently registered listeners.
 501  * Called while sclp_lock is locked. */
 502 static inline void
 503 __sclp_get_mask(sccb_mask_t *receive_mask, sccb_mask_t *send_mask)
 504 {
 505         struct list_head *l;
 506         struct sclp_register *t;
 507
 508         *receive_mask = 0;
 509         *send_mask = 0;
 510         list_for_each(l, &sclp_reg_list) {
 511                 t = list_entry(l, struct sclp_register, list);
 512                 *receive_mask |= t->receive_mask;
 513                 *send_mask |= t->send_mask;
 514         }
 515 }
 516
 517 /* Register event listener. Return 0 on success, non-zero otherwise. */
 518 int
 519 sclp_register(struct sclp_register *reg)
 520 {
 521         unsigned long flags;
 522         sccb_mask_t receive_mask;
 523         sccb_mask_t send_mask;
 524         int rc;
 525
 526         rc = sclp_init();
 527         if (rc)
 528                 return rc;
 529         spin_lock_irqsave(&sclp_lock, flags);
 530         /* Check event mask for collisions */
 531         __sclp_get_mask(&receive_mask, &send_mask);
 532         if (reg->receive_mask & receive_mask || reg->send_mask & send_mask) {
 533                 spin_unlock_irqrestore(&sclp_lock, flags);
 534                 return -EBUSY;
 535         }
 536         /* Trigger initial state change callback */
 537         reg->sclp_receive_mask = 0;
 538         reg->sclp_send_mask = 0;
 539         list_add(&reg->list, &sclp_reg_list);
 540         spin_unlock_irqrestore(&sclp_lock, flags);
 541         rc = sclp_init_mask(1);
 542         if (rc) {
 543                 spin_lock_irqsave(&sclp_lock, flags);
 544                 list_del(&reg->list);
 545                 spin_unlock_irqrestore(&sclp_lock, flags);
 546         }
 547         return rc;
 548 }
 549
 550 EXPORT_SYMBOL(sclp_register);
 551
 552 /* Unregister event listener. */
 553 void
 554 sclp_unregister(struct sclp_register *reg)
 555 {
 556         unsigned long flags;
 557
 558         spin_lock_irqsave(&sclp_lock, flags);
 559         list_del(&reg->list);
 560         spin_unlock_irqrestore(&sclp_lock, flags);
 561         sclp_init_mask(1);
 562 }
 563
 564 EXPORT_SYMBOL(sclp_unregister);
 565
 566 /* Remove event buffers which are marked processed. Return the number of
 567  * remaining event buffers. */
 568 int
 569 sclp_remove_processed(struct sccb_header *sccb)
 570 {
 571         struct evbuf_header *evbuf;
 572         int unprocessed;
 573         u16 remaining;
 574
 575         evbuf = (struct evbuf_header *) (sccb + 1);
 576         unprocessed = 0;
 577         remaining = sccb->length - sizeof(struct sccb_header);
 578         while (remaining > 0) {
 579                 remaining -= evbuf->length;
 580                 if (evbuf->flags & 0x80) {
 581                         sccb->length -= evbuf->length;
 582                         memcpy(evbuf, (void *) ((addr_t) evbuf + evbuf->length),
 583                                remaining);
 584                 } else {
 585                         unprocessed++;
 586                         evbuf = (struct evbuf_header *)
 587                                         ((addr_t) evbuf + evbuf->length);
 588                 }
 589         }
 590         return unprocessed;
 591 }
 592
 593 EXPORT_SYMBOL(sclp_remove_processed);
 594
 595 struct init_sccb {
 596         struct sccb_header header;
 597         u16 _reserved;
 598         u16 mask_length;
 599         sccb_mask_t receive_mask;
 600         sccb_mask_t send_mask;
 601         sccb_mask_t sclp_send_mask;
 602         sccb_mask_t sclp_receive_mask;
 603 } __attribute__((packed));
 604
 605 /* Prepare init mask request. Called while sclp_lock is locked. */
 606 static inline void
 607 __sclp_make_init_req(u32 receive_mask, u32 send_mask)
 608 {
 609         struct init_sccb *sccb;
 610
 611         sccb = (struct init_sccb *) sclp_init_sccb;
 612         clear_page(sccb);
 613         memset(&sclp_init_req, 0, sizeof(struct sclp_req));
 614         sclp_init_req.command = SCLP_CMDW_WRITEMASK;
 615         sclp_init_req.status = SCLP_REQ_FILLED;
 616         sclp_init_req.start_count = 0;
 617         sclp_init_req.callback = NULL;
 618         sclp_init_req.callback_data = NULL;
 619         sclp_init_req.sccb = sccb;
 620         sccb->header.length = sizeof(struct init_sccb);
 621         sccb->mask_length = sizeof(sccb_mask_t);
 622         sccb->receive_mask = receive_mask;
 623         sccb->send_mask = send_mask;
 624         sccb->sclp_receive_mask = 0;
 625         sccb->sclp_send_mask = 0;
 626 }
 627
 628 /* Start init mask request. If calculate is non-zero, calculate the mask as
 629  * requested by registered listeners. Use zero mask otherwise. Return 0 on
 630  * success, non-zero otherwise. */
 631 static int
 632 sclp_init_mask(int calculate)
 633 {
 634         unsigned long flags;
 635         struct init_sccb *sccb = (struct init_sccb *) sclp_init_sccb;
 636         sccb_mask_t receive_mask;
 637         sccb_mask_t send_mask;
 638         int retry;
 639         int rc;
 640         unsigned long wait;
 641
 642         spin_lock_irqsave(&sclp_lock, flags);
 643         /* Check if interface is in appropriate state */
 644         if (sclp_mask_state != sclp_mask_state_idle) {
 645                 spin_unlock_irqrestore(&sclp_lock, flags);
 646                 return -EBUSY;
 647         }
 648         if (sclp_activation_state == sclp_activation_state_inactive) {
 649                 spin_unlock_irqrestore(&sclp_lock, flags);
 650                 return -EINVAL;
 651         }
 652         sclp_mask_state = sclp_mask_state_initializing;
 653         /* Determine mask */
 654         if (calculate)
 655                 __sclp_get_mask(&receive_mask, &send_mask);
 656         else {
 657                 receive_mask = 0;
 658                 send_mask = 0;
 659         }
 660         rc = -EIO;
 661         for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
 662                 /* Prepare request */
 663                 __sclp_make_init_req(receive_mask, send_mask);
 664                 spin_unlock_irqrestore(&sclp_lock, flags);
 665                 if (sclp_add_request(&sclp_init_req)) {
 666                         /* Try again later */
 667                         wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
 668                         while (time_before(jiffies, wait))
 669                                 sclp_sync_wait();
 670                         spin_lock_irqsave(&sclp_lock, flags);
 671                         continue;
 672                 }
 673                 while (sclp_init_req.status != SCLP_REQ_DONE &&
 674                        sclp_init_req.status != SCLP_REQ_FAILED)
 675                         sclp_sync_wait();
 676                 spin_lock_irqsave(&sclp_lock, flags);
 677                 if (sclp_init_req.status == SCLP_REQ_DONE &&
 678                     sccb->header.response_code == 0x20) {
 679                         /* Successful request */
 680                         if (calculate) {
 681                                 sclp_receive_mask = sccb->sclp_receive_mask;
 682                                 sclp_send_mask = sccb->sclp_send_mask;
 683                         } else {
 684                                 sclp_receive_mask = 0;
 685                                 sclp_send_mask = 0;
 686                         }
 687                         spin_unlock_irqrestore(&sclp_lock, flags);
 688                         sclp_dispatch_state_change();
 689                         spin_lock_irqsave(&sclp_lock, flags);
 690                         rc = 0;
 691                         break;
 692                 }
 693         }
 694         sclp_mask_state = sclp_mask_state_idle;
 695         spin_unlock_irqrestore(&sclp_lock, flags);
 696         return rc;
 697 }
 698
 699 /* Deactivate SCLP interface. On success, new requests will be rejected,
 700  * events will no longer be dispatched. Return 0 on success, non-zero
 701  * otherwise. */
 702 int
 703 sclp_deactivate(void)
 704 {
 705         unsigned long flags;
 706         int rc;
 707
 708         spin_lock_irqsave(&sclp_lock, flags);
 709         /* Deactivate can only be called when active */
 710         if (sclp_activation_state != sclp_activation_state_active) {
 711                 spin_unlock_irqrestore(&sclp_lock, flags);
 712                 return -EINVAL;
 713         }
 714         sclp_activation_state = sclp_activation_state_deactivating;
 715         spin_unlock_irqrestore(&sclp_lock, flags);
 716         rc = sclp_init_mask(0);
 717         spin_lock_irqsave(&sclp_lock, flags);
 718         if (rc == 0)
 719                 sclp_activation_state = sclp_activation_state_inactive;
 720         else
 721                 sclp_activation_state = sclp_activation_state_active;
 722         spin_unlock_irqrestore(&sclp_lock, flags);
 723         return rc;
 724 }
 725
 726 EXPORT_SYMBOL(sclp_deactivate);
 727
 728 /* Reactivate SCLP interface after sclp_deactivate. On success, new
 729  * requests will be accepted, events will be dispatched again. Return 0 on
 730  * success, non-zero otherwise. */
 731 int
 732 sclp_reactivate(void)
 733 {
 734         unsigned long flags;
 735         int rc;
 736
 737         spin_lock_irqsave(&sclp_lock, flags);
 738         /* Reactivate can only be called when inactive */
 739         if (sclp_activation_state != sclp_activation_state_inactive) {
 740                 spin_unlock_irqrestore(&sclp_lock, flags);
 741                 return -EINVAL;
 742         }
 743         sclp_activation_state = sclp_activation_state_activating;
 744         spin_unlock_irqrestore(&sclp_lock, flags);
 745         rc = sclp_init_mask(1);
 746         spin_lock_irqsave(&sclp_lock, flags);
 747         if (rc == 0)
 748                 sclp_activation_state = sclp_activation_state_active;
 749         else
 750                 sclp_activation_state = sclp_activation_state_inactive;
 751         spin_unlock_irqrestore(&sclp_lock, flags);
 752         return rc;
 753 }
 754
 755 EXPORT_SYMBOL(sclp_reactivate);
 756
 757 /* Handler for external interruption used during initialization. Modify
 758  * request state to done. */
 759 static void
 760 sclp_check_handler(struct pt_regs *regs, __u16 code)
 761 {
 762         u32 finished_sccb;
 763
 764         finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
 765         /* Is this the interrupt we are waiting for? */
 766         if (finished_sccb == 0)
 767                 return;
 768         if (finished_sccb != (u32) (addr_t) sclp_init_sccb) {
 769                 printk(KERN_WARNING SCLP_HEADER "unsolicited interrupt "
 770                        "for buffer at 0x%x\n", finished_sccb);
 771                 return;
 772         }
 773         spin_lock(&sclp_lock);
 774         if (sclp_running_state == sclp_running_state_running) {
 775                 sclp_init_req.status = SCLP_REQ_DONE;
 776                 sclp_running_state = sclp_running_state_idle;
 777         }
 778         spin_unlock(&sclp_lock);
 779 }
 780
 781 /* Initial init mask request timed out. Modify request state to failed. */
 782 static void
 783 sclp_check_timeout(unsigned long data)
 784 {
 785         unsigned long flags;
 786
 787         spin_lock_irqsave(&sclp_lock, flags);
 788         if (sclp_running_state == sclp_running_state_running) {
 789                 sclp_init_req.status = SCLP_REQ_FAILED;
 790                 sclp_running_state = sclp_running_state_idle;
 791         }
 792         spin_unlock_irqrestore(&sclp_lock, flags);
 793 }
 794
 795 /* Perform a check of the SCLP interface. Return zero if the interface is
 796  * available and there are no pending requests from a previous instance.
 797  * Return non-zero otherwise. */
 798 static int
 799 sclp_check_interface(void)
 800 {
 801         struct init_sccb *sccb;
 802         unsigned long flags;
 803         int retry;
 804         int rc;
 805
 806         spin_lock_irqsave(&sclp_lock, flags);
 807         /* Prepare init mask command */
 808         rc = register_early_external_interrupt(0x2401, sclp_check_handler,
 809                                                &ext_int_info_hwc);
 810         if (rc) {
 811                 spin_unlock_irqrestore(&sclp_lock, flags);
 812                 return rc;
 813         }
 814         for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
 815                 __sclp_make_init_req(0, 0);
 816                 sccb = (struct init_sccb *) sclp_init_req.sccb;
 817                 rc = service_call(sclp_init_req.command, sccb);
 818                 if (rc == -EIO)
 819                         break;
 820                 sclp_init_req.status = SCLP_REQ_RUNNING;
 821                 sclp_running_state = sclp_running_state_running;
 822                 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
 823                                          sclp_check_timeout, 0);
 824                 spin_unlock_irqrestore(&sclp_lock, flags);
 825                 /* Enable service-signal interruption - needs to happen
 826                  * with IRQs enabled. */
 827                 ctl_set_bit(0, 9);
 828                 /* Wait for signal from interrupt or timeout */
 829                 sclp_sync_wait();
 830                 /* Disable service-signal interruption - needs to happen
 831                  * with IRQs enabled. */
 832                 ctl_clear_bit(0,9);
 833                 spin_lock_irqsave(&sclp_lock, flags);
 834                 del_timer(&sclp_request_timer);
 835                 if (sclp_init_req.status == SCLP_REQ_DONE &&
 836                     sccb->header.response_code == 0x20) {
 837                         rc = 0;
 838                         break;
 839                 } else
 840                         rc = -EBUSY;
 841         }
 842         unregister_early_external_interrupt(0x2401, sclp_check_handler,
 843                                             &ext_int_info_hwc);
 844         spin_unlock_irqrestore(&sclp_lock, flags);
 845         return rc;
 846 }
 847
 848 /* Reboot event handler. Reset send and receive mask to prevent pending SCLP
 849  * events from interfering with rebooted system. */
 850 static int
 851 sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
 852 {
 853         sclp_deactivate();
 854         return NOTIFY_DONE;
 855 }
 856
 857 static struct notifier_block sclp_reboot_notifier = {
 858         .notifier_call = sclp_reboot_event
 859 };
 860
 861 /* Initialize SCLP driver. Return zero if driver is operational, non-zero
 862  * otherwise. */
 863 static int
 864 sclp_init(void)
 865 {
 866         unsigned long flags;
 867         int rc;
 868
 869         if (!MACHINE_HAS_SCLP)
 870                 return -ENODEV;
 871         spin_lock_irqsave(&sclp_lock, flags);
 872         /* Check for previous or running initialization */
 873         if (sclp_init_state != sclp_init_state_uninitialized) {
 874                 spin_unlock_irqrestore(&sclp_lock, flags);
 875                 return 0;
 876         }
 877         sclp_init_state = sclp_init_state_initializing;
 878         /* Set up variables */
 879         INIT_LIST_HEAD(&sclp_req_queue);
 880         INIT_LIST_HEAD(&sclp_reg_list);
 881         list_add(&sclp_state_change_event.list, &sclp_reg_list);
 882         init_timer(&sclp_request_timer);
 883         /* Check interface */
 884         spin_unlock_irqrestore(&sclp_lock, flags);
 885         rc = sclp_check_interface();
 886         spin_lock_irqsave(&sclp_lock, flags);
 887         if (rc) {
 888                 sclp_init_state = sclp_init_state_uninitialized;
 889                 spin_unlock_irqrestore(&sclp_lock, flags);
 890                 return rc;
 891         }
 892         /* Register reboot handler */
 893         rc = register_reboot_notifier(&sclp_reboot_notifier);
 894         if (rc) {
 895                 sclp_init_state = sclp_init_state_uninitialized;
 896                 spin_unlock_irqrestore(&sclp_lock, flags);
 897                 return rc;
 898         }
 899         /* Register interrupt handler */
 900         rc = register_early_external_interrupt(0x2401, sclp_interrupt_handler,
 901                                                &ext_int_info_hwc);
 902         if (rc) {
 903                 unregister_reboot_notifier(&sclp_reboot_notifier);
 904                 sclp_init_state = sclp_init_state_uninitialized;
 905                 spin_unlock_irqrestore(&sclp_lock, flags);
 906                 return rc;
 907         }
 908         sclp_init_state = sclp_init_state_initialized;
 909         spin_unlock_irqrestore(&sclp_lock, flags);
 910         /* Enable service-signal external interruption - needs to happen with
 911          * IRQs enabled. */
 912         ctl_set_bit(0, 9);
 913         sclp_init_mask(1);
 914         return 0;
 915 }