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(®->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(®->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(®->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 } 916