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