Blame view
drivers/ps3/ps3-sys-manager.c
19.8 KB
873e65bc0
|
1 |
// SPDX-License-Identifier: GPL-2.0-only |
fde5efd0e
|
2 3 4 5 6 |
/* * PS3 System Manager. * * Copyright (C) 2007 Sony Computer Entertainment Inc. * Copyright 2007 Sony Corp. |
fde5efd0e
|
7 8 9 10 11 12 |
*/ #include <linux/kernel.h> #include <linux/module.h> #include <linux/workqueue.h> #include <linux/reboot.h> |
3f07c0144
|
13 |
#include <linux/sched/signal.h> |
ef596c697
|
14 15 |
#include <asm/firmware.h> |
ca052f792
|
16 |
#include <asm/lv1call.h> |
fde5efd0e
|
17 |
#include <asm/ps3.h> |
ef596c697
|
18 |
|
fde5efd0e
|
19 |
#include "vuart.h" |
fde5efd0e
|
20 21 22 |
/** * ps3_sys_manager - PS3 system manager driver. * |
66c63b84b
|
23 |
* The system manager provides an asynchronous system event notification |
fde5efd0e
|
24 25 26 27 28 29 30 31 32 33 34 35 36 |
* mechanism for reporting events like thermal alert and button presses to * guests. It also provides support to control system shutdown and startup. * * The actual system manager is implemented as an application running in the * system policy module in lpar_1. Guests communicate with the system manager * through port 2 of the vuart using a simple packet message protocol. * Messages are comprised of a fixed field header followed by a message * specific payload. */ /** * struct ps3_sys_manager_header - System manager message header. * @version: Header version, currently 1. |
af901ca18
|
37 |
* @size: Header size in bytes, currently 16. |
fde5efd0e
|
38 39 |
* @payload_size: Message payload size in bytes. * @service_id: Message type, one of enum ps3_sys_manager_service_id. |
66c63b84b
|
40 |
* @request_tag: Unique number to identify reply. |
fde5efd0e
|
41 42 43 44 45 46 47 48 49 |
*/ struct ps3_sys_manager_header { /* version 1 */ u8 version; u8 size; u16 reserved_1; u32 payload_size; u16 service_id; |
66c63b84b
|
50 51 |
u16 reserved_2; u32 request_tag; |
fde5efd0e
|
52 |
}; |
66c63b84b
|
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
#define dump_sm_header(_h) _dump_sm_header(_h, __func__, __LINE__) static void __maybe_unused _dump_sm_header( const struct ps3_sys_manager_header *h, const char *func, int line) { pr_debug("%s:%d: version: %xh ", func, line, h->version); pr_debug("%s:%d: size: %xh ", func, line, h->size); pr_debug("%s:%d: payload_size: %xh ", func, line, h->payload_size); pr_debug("%s:%d: service_id: %xh ", func, line, h->service_id); pr_debug("%s:%d: request_tag: %xh ", func, line, h->request_tag); } |
fde5efd0e
|
68 |
/** |
66c63b84b
|
69 70 |
* @PS3_SM_RX_MSG_LEN_MIN - Shortest received message length. * @PS3_SM_RX_MSG_LEN_MAX - Longest received message length. |
fde5efd0e
|
71 |
* |
66c63b84b
|
72 73 |
* Currently all messages received from the system manager are either * (16 bytes header + 8 bytes payload = 24 bytes) or (16 bytes header |
25985edce
|
74 |
* + 16 bytes payload = 32 bytes). This knowledge is used to simplify |
66c63b84b
|
75 |
* the logic. |
fde5efd0e
|
76 77 78 |
*/ enum { |
66c63b84b
|
79 80 |
PS3_SM_RX_MSG_LEN_MIN = 24, PS3_SM_RX_MSG_LEN_MAX = 32, |
fde5efd0e
|
81 82 83 84 |
}; /** * enum ps3_sys_manager_service_id - Message header service_id. |
66c63b84b
|
85 86 87 88 89 90 91 92 93 94 95 |
* @PS3_SM_SERVICE_ID_REQUEST: guest --> sys_manager. * @PS3_SM_SERVICE_ID_REQUEST_ERROR: guest <-- sys_manager. * @PS3_SM_SERVICE_ID_COMMAND: guest <-- sys_manager. * @PS3_SM_SERVICE_ID_RESPONSE: guest --> sys_manager. * @PS3_SM_SERVICE_ID_SET_ATTR: guest --> sys_manager. * @PS3_SM_SERVICE_ID_EXTERN_EVENT: guest <-- sys_manager. * @PS3_SM_SERVICE_ID_SET_NEXT_OP: guest --> sys_manager. * * PS3_SM_SERVICE_ID_REQUEST_ERROR is returned for invalid data values in a * a PS3_SM_SERVICE_ID_REQUEST message. It also seems to be returned when * a REQUEST message is sent at the wrong time. |
fde5efd0e
|
96 97 98 99 100 101 102 103 104 |
*/ enum ps3_sys_manager_service_id { /* version 1 */ PS3_SM_SERVICE_ID_REQUEST = 1, PS3_SM_SERVICE_ID_RESPONSE = 2, PS3_SM_SERVICE_ID_COMMAND = 3, PS3_SM_SERVICE_ID_EXTERN_EVENT = 4, PS3_SM_SERVICE_ID_SET_NEXT_OP = 5, |
66c63b84b
|
105 |
PS3_SM_SERVICE_ID_REQUEST_ERROR = 6, |
fde5efd0e
|
106 107 108 109 110 111 112 |
PS3_SM_SERVICE_ID_SET_ATTR = 8, }; /** * enum ps3_sys_manager_attr - Notification attribute (bit position mask). * @PS3_SM_ATTR_POWER: Power button. * @PS3_SM_ATTR_RESET: Reset button, not available on retail console. |
883931612
|
113 |
* @PS3_SM_ATTR_THERMAL: System thermal alert. |
fde5efd0e
|
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
* @PS3_SM_ATTR_CONTROLLER: Remote controller event. * @PS3_SM_ATTR_ALL: Logical OR of all. * * The guest tells the system manager which events it is interested in receiving * notice of by sending the system manager a logical OR of notification * attributes via the ps3_sys_manager_send_attr() routine. */ enum ps3_sys_manager_attr { /* version 1 */ PS3_SM_ATTR_POWER = 1, PS3_SM_ATTR_RESET = 2, PS3_SM_ATTR_THERMAL = 4, PS3_SM_ATTR_CONTROLLER = 8, /* bogus? */ PS3_SM_ATTR_ALL = 0x0f, }; /** * enum ps3_sys_manager_event - External event type, reported by system manager. |
ea24608f0
|
133 134 |
* @PS3_SM_EVENT_POWER_PRESSED: payload.value = * enum ps3_sys_manager_button_event. |
fde5efd0e
|
135 |
* @PS3_SM_EVENT_POWER_RELEASED: payload.value = time pressed in millisec. |
ea24608f0
|
136 137 |
* @PS3_SM_EVENT_RESET_PRESSED: payload.value = * enum ps3_sys_manager_button_event. |
fde5efd0e
|
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
* @PS3_SM_EVENT_RESET_RELEASED: payload.value = time pressed in millisec. * @PS3_SM_EVENT_THERMAL_ALERT: payload.value = thermal zone id. * @PS3_SM_EVENT_THERMAL_CLEARED: payload.value = thermal zone id. */ enum ps3_sys_manager_event { /* version 1 */ PS3_SM_EVENT_POWER_PRESSED = 3, PS3_SM_EVENT_POWER_RELEASED = 4, PS3_SM_EVENT_RESET_PRESSED = 5, PS3_SM_EVENT_RESET_RELEASED = 6, PS3_SM_EVENT_THERMAL_ALERT = 7, PS3_SM_EVENT_THERMAL_CLEARED = 8, /* no info on controller events */ }; /** |
ea24608f0
|
155 156 157 158 159 160 161 162 163 164 165 |
* enum ps3_sys_manager_button_event - Button event payload values. * @PS3_SM_BUTTON_EVENT_HARD: Hardware generated event. * @PS3_SM_BUTTON_EVENT_SOFT: Software generated event. */ enum ps3_sys_manager_button_event { PS3_SM_BUTTON_EVENT_HARD = 0, PS3_SM_BUTTON_EVENT_SOFT = 1, }; /** |
fde5efd0e
|
166 167 168 169 170 171 172 173 174 175 176 177 |
* enum ps3_sys_manager_next_op - Operation to perform after lpar is destroyed. */ enum ps3_sys_manager_next_op { /* version 3 */ PS3_SM_NEXT_OP_SYS_SHUTDOWN = 1, PS3_SM_NEXT_OP_SYS_REBOOT = 2, PS3_SM_NEXT_OP_LPAR_REBOOT = 0x82, }; /** * enum ps3_sys_manager_wake_source - Next-op wakeup source (bit position mask). |
5442381cd
|
178 |
* @PS3_SM_WAKE_DEFAULT: Disk insert, power button, eject button. |
1c43d265f
|
179 |
* @PS3_SM_WAKE_W_O_L: Ether or wireless LAN. |
fde5efd0e
|
180 181 182 |
* @PS3_SM_WAKE_P_O_R: Power on reset. * * Additional wakeup sources when specifying PS3_SM_NEXT_OP_SYS_SHUTDOWN. |
50dad9026
|
183 184 185 |
* The system will always wake from the PS3_SM_WAKE_DEFAULT sources. * Sources listed here are the only ones available to guests in the * other-os lpar. |
fde5efd0e
|
186 187 188 189 190 |
*/ enum ps3_sys_manager_wake_source { /* version 3 */ PS3_SM_WAKE_DEFAULT = 0, |
1c43d265f
|
191 |
PS3_SM_WAKE_W_O_L = 0x00000400, |
50dad9026
|
192 |
PS3_SM_WAKE_P_O_R = 0x80000000, |
fde5efd0e
|
193 194 195 |
}; /** |
1c43d265f
|
196 197 198 199 200 201 202 203 |
* user_wake_sources - User specified wakeup sources. * * Logical OR of enum ps3_sys_manager_wake_source types. */ static u32 user_wake_sources = PS3_SM_WAKE_DEFAULT; /** |
fde5efd0e
|
204 205 206 207 208 209 210 211 212 213 214 215 216 217 |
* enum ps3_sys_manager_cmd - Command from system manager to guest. * * The guest completes the actions needed, then acks or naks the command via * ps3_sys_manager_send_response(). In the case of @PS3_SM_CMD_SHUTDOWN, * the guest must be fully prepared for a system poweroff prior to acking the * command. */ enum ps3_sys_manager_cmd { /* version 1 */ PS3_SM_CMD_SHUTDOWN = 1, /* shutdown guest OS */ }; /** |
66c63b84b
|
218 219 220 221 222 223 224 225 226 227 |
* ps3_sm_force_power_off - Poweroff helper. * * A global variable used to force a poweroff when the power button has * been pressed irrespective of how init handles the ctrl_alt_del signal. * */ static unsigned int ps3_sm_force_power_off; /** |
fde5efd0e
|
228 229 230 |
* ps3_sys_manager_write - Helper to write a two part message to the vuart. * */ |
66c63b84b
|
231 |
static int ps3_sys_manager_write(struct ps3_system_bus_device *dev, |
fde5efd0e
|
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 |
const struct ps3_sys_manager_header *header, const void *payload) { int result; BUG_ON(header->version != 1); BUG_ON(header->size != 16); BUG_ON(header->payload_size != 8 && header->payload_size != 16); BUG_ON(header->service_id > 8); result = ps3_vuart_write(dev, header, sizeof(struct ps3_sys_manager_header)); if (!result) result = ps3_vuart_write(dev, payload, header->payload_size); return result; } /** * ps3_sys_manager_send_attr - Send a 'set attribute' to the system manager. * */ |
66c63b84b
|
254 |
static int ps3_sys_manager_send_attr(struct ps3_system_bus_device *dev, |
fde5efd0e
|
255 256 |
enum ps3_sys_manager_attr attr) { |
66c63b84b
|
257 |
struct ps3_sys_manager_header header; |
fde5efd0e
|
258 259 260 261 262 263 264 265 266 267 |
struct { u8 version; u8 reserved_1[3]; u32 attribute; } payload; BUILD_BUG_ON(sizeof(payload) != 8); dev_dbg(&dev->core, "%s:%d: %xh ", __func__, __LINE__, attr); |
66c63b84b
|
268 269 270 271 272 |
memset(&header, 0, sizeof(header)); header.version = 1; header.size = 16; header.payload_size = 16; header.service_id = PS3_SM_SERVICE_ID_SET_ATTR; |
fde5efd0e
|
273 274 275 276 277 278 279 280 281 282 283 284 |
memset(&payload, 0, sizeof(payload)); payload.version = 1; payload.attribute = attr; return ps3_sys_manager_write(dev, &header, &payload); } /** * ps3_sys_manager_send_next_op - Send a 'set next op' to the system manager. * * Tell the system manager what to do after this lpar is destroyed. */ |
66c63b84b
|
285 |
static int ps3_sys_manager_send_next_op(struct ps3_system_bus_device *dev, |
fde5efd0e
|
286 287 288 |
enum ps3_sys_manager_next_op op, enum ps3_sys_manager_wake_source wake_source) { |
66c63b84b
|
289 |
struct ps3_sys_manager_header header; |
fde5efd0e
|
290 291 292 293 294 295 296 297 298 299 300 301 302 |
struct { u8 version; u8 type; u8 gos_id; u8 reserved_1; u32 wake_source; u8 reserved_2[8]; } payload; BUILD_BUG_ON(sizeof(payload) != 16); dev_dbg(&dev->core, "%s:%d: (%xh) ", __func__, __LINE__, op); |
66c63b84b
|
303 304 305 306 307 |
memset(&header, 0, sizeof(header)); header.version = 1; header.size = 16; header.payload_size = 16; header.service_id = PS3_SM_SERVICE_ID_SET_NEXT_OP; |
fde5efd0e
|
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 |
memset(&payload, 0, sizeof(payload)); payload.version = 3; payload.type = op; payload.gos_id = 3; /* other os */ payload.wake_source = wake_source; return ps3_sys_manager_write(dev, &header, &payload); } /** * ps3_sys_manager_send_request_shutdown - Send 'request' to the system manager. * * The guest sends this message to request an operation or action of the system * manager. The reply is a command message from the system manager. In the * command handler the guest performs the requested operation. The result of * the command is then communicated back to the system manager with a response * message. * |
66c63b84b
|
326 |
* Currently, the only supported request is the 'shutdown self' request. |
fde5efd0e
|
327 |
*/ |
66c63b84b
|
328 329 |
static int ps3_sys_manager_send_request_shutdown( struct ps3_system_bus_device *dev) |
fde5efd0e
|
330 |
{ |
66c63b84b
|
331 |
struct ps3_sys_manager_header header; |
fde5efd0e
|
332 333 334 335 336 |
struct { u8 version; u8 type; u8 gos_id; u8 reserved_1[13]; |
66c63b84b
|
337 |
} payload; |
fde5efd0e
|
338 339 340 341 342 |
BUILD_BUG_ON(sizeof(payload) != 16); dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); |
66c63b84b
|
343 344 345 346 347 348 349 350 351 352 |
memset(&header, 0, sizeof(header)); header.version = 1; header.size = 16; header.payload_size = 16; header.service_id = PS3_SM_SERVICE_ID_REQUEST; memset(&payload, 0, sizeof(payload)); payload.version = 1; payload.type = 1; /* shutdown */ payload.gos_id = 0; /* self */ |
fde5efd0e
|
353 354 355 356 357 358 359 360 361 362 |
return ps3_sys_manager_write(dev, &header, &payload); } /** * ps3_sys_manager_send_response - Send a 'response' to the system manager. * @status: zero = success, others fail. * * The guest sends this message to the system manager to acnowledge success or * failure of a command sent by the system manager. */ |
66c63b84b
|
363 |
static int ps3_sys_manager_send_response(struct ps3_system_bus_device *dev, |
fde5efd0e
|
364 365 |
u64 status) { |
66c63b84b
|
366 |
struct ps3_sys_manager_header header; |
fde5efd0e
|
367 368 369 370 371 372 373 374 375 376 377 378 |
struct { u8 version; u8 reserved_1[3]; u8 status; u8 reserved_2[11]; } payload; BUILD_BUG_ON(sizeof(payload) != 16); dev_dbg(&dev->core, "%s:%d: (%s) ", __func__, __LINE__, (status ? "nak" : "ack")); |
66c63b84b
|
379 380 381 382 383 |
memset(&header, 0, sizeof(header)); header.version = 1; header.size = 16; header.payload_size = 16; header.service_id = PS3_SM_SERVICE_ID_RESPONSE; |
fde5efd0e
|
384 385 386 387 388 389 390 391 392 393 394 |
memset(&payload, 0, sizeof(payload)); payload.version = 1; payload.status = status; return ps3_sys_manager_write(dev, &header, &payload); } /** * ps3_sys_manager_handle_event - Second stage event msg handler. * */ |
66c63b84b
|
395 |
static int ps3_sys_manager_handle_event(struct ps3_system_bus_device *dev) |
fde5efd0e
|
396 397 398 399 400 401 402 403 404 405 406 407 408 |
{ int result; struct { u8 version; u8 type; u8 reserved_1[2]; u32 value; u8 reserved_2[8]; } event; BUILD_BUG_ON(sizeof(event) != 16); result = ps3_vuart_read(dev, &event, sizeof(event)); |
66c63b84b
|
409 |
BUG_ON(result && "need to retry here"); |
fde5efd0e
|
410 411 412 413 414 415 416 417 418 419 |
if (event.version != 1) { dev_dbg(&dev->core, "%s:%d: unsupported event version (%u) ", __func__, __LINE__, event.version); return -EIO; } switch (event.type) { case PS3_SM_EVENT_POWER_PRESSED: |
ea24608f0
|
420 421 422 423 424 |
dev_dbg(&dev->core, "%s:%d: POWER_PRESSED (%s) ", __func__, __LINE__, (event.value == PS3_SM_BUTTON_EVENT_SOFT ? "soft" : "hard")); |
66c63b84b
|
425 426 427 428 429 430 431 432 |
ps3_sm_force_power_off = 1; /* * A memory barrier is use here to sync memory since * ps3_sys_manager_final_restart() could be called on * another cpu. */ wmb(); kill_cad_pid(SIGINT, 1); /* ctrl_alt_del */ |
fde5efd0e
|
433 434 435 436 437 |
break; case PS3_SM_EVENT_POWER_RELEASED: dev_dbg(&dev->core, "%s:%d: POWER_RELEASED (%u ms) ", __func__, __LINE__, event.value); |
66c63b84b
|
438 439 |
break; case PS3_SM_EVENT_RESET_PRESSED: |
ea24608f0
|
440 441 442 443 444 |
dev_dbg(&dev->core, "%s:%d: RESET_PRESSED (%s) ", __func__, __LINE__, (event.value == PS3_SM_BUTTON_EVENT_SOFT ? "soft" : "hard")); |
66c63b84b
|
445 446 447 448 449 450 451 452 453 454 455 456 457 |
ps3_sm_force_power_off = 0; /* * A memory barrier is use here to sync memory since * ps3_sys_manager_final_restart() could be called on * another cpu. */ wmb(); kill_cad_pid(SIGINT, 1); /* ctrl_alt_del */ break; case PS3_SM_EVENT_RESET_RELEASED: dev_dbg(&dev->core, "%s:%d: RESET_RELEASED (%u ms) ", __func__, __LINE__, event.value); |
fde5efd0e
|
458 459 460 461 462 |
break; case PS3_SM_EVENT_THERMAL_ALERT: dev_dbg(&dev->core, "%s:%d: THERMAL_ALERT (zone %u) ", __func__, __LINE__, event.value); |
eff56c92a
|
463 464 |
pr_info("PS3 Thermal Alert Zone %u ", event.value); |
fde5efd0e
|
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 |
break; case PS3_SM_EVENT_THERMAL_CLEARED: dev_dbg(&dev->core, "%s:%d: THERMAL_CLEARED (zone %u) ", __func__, __LINE__, event.value); break; default: dev_dbg(&dev->core, "%s:%d: unknown event (%u) ", __func__, __LINE__, event.type); return -EIO; } return 0; } /** * ps3_sys_manager_handle_cmd - Second stage command msg handler. * * The system manager sends this in reply to a 'request' message from the guest. */ |
66c63b84b
|
485 |
static int ps3_sys_manager_handle_cmd(struct ps3_system_bus_device *dev) |
fde5efd0e
|
486 487 488 489 490 491 492 493 494 495 496 497 498 499 |
{ int result; struct { u8 version; u8 type; u8 reserved_1[14]; } cmd; BUILD_BUG_ON(sizeof(cmd) != 16); dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); result = ps3_vuart_read(dev, &cmd, sizeof(cmd)); |
66c63b84b
|
500 |
BUG_ON(result && "need to retry here"); |
fde5efd0e
|
501 |
|
eff56c92a
|
502 |
if (result) |
fde5efd0e
|
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 |
return result; if (cmd.version != 1) { dev_dbg(&dev->core, "%s:%d: unsupported cmd version (%u) ", __func__, __LINE__, cmd.version); return -EIO; } if (cmd.type != PS3_SM_CMD_SHUTDOWN) { dev_dbg(&dev->core, "%s:%d: unknown cmd (%u) ", __func__, __LINE__, cmd.type); return -EIO; } ps3_sys_manager_send_response(dev, 0); return 0; } /** * ps3_sys_manager_handle_msg - First stage msg handler. * |
66c63b84b
|
526 |
* Can be called directly to manually poll vuart and pump message handler. |
fde5efd0e
|
527 |
*/ |
66c63b84b
|
528 |
static int ps3_sys_manager_handle_msg(struct ps3_system_bus_device *dev) |
fde5efd0e
|
529 530 531 532 533 534 |
{ int result; struct ps3_sys_manager_header header; result = ps3_vuart_read(dev, &header, sizeof(struct ps3_sys_manager_header)); |
eff56c92a
|
535 |
if (result) |
fde5efd0e
|
536 537 538 539 540 541 |
return result; if (header.version != 1) { dev_dbg(&dev->core, "%s:%d: unsupported header version (%u) ", __func__, __LINE__, header.version); |
66c63b84b
|
542 |
dump_sm_header(&header); |
fde5efd0e
|
543 544 545 546 |
goto fail_header; } BUILD_BUG_ON(sizeof(header) != 16); |
66c63b84b
|
547 548 549 550 551 552 |
if (header.size != 16 || (header.payload_size != 8 && header.payload_size != 16)) { dump_sm_header(&header); BUG(); } |
fde5efd0e
|
553 554 555 556 557 558 559 560 561 562 |
switch (header.service_id) { case PS3_SM_SERVICE_ID_EXTERN_EVENT: dev_dbg(&dev->core, "%s:%d: EVENT ", __func__, __LINE__); return ps3_sys_manager_handle_event(dev); case PS3_SM_SERVICE_ID_COMMAND: dev_dbg(&dev->core, "%s:%d: COMMAND ", __func__, __LINE__); return ps3_sys_manager_handle_cmd(dev); |
66c63b84b
|
563 564 565 566 567 568 |
case PS3_SM_SERVICE_ID_REQUEST_ERROR: dev_dbg(&dev->core, "%s:%d: REQUEST_ERROR ", __func__, __LINE__); dump_sm_header(&header); break; |
fde5efd0e
|
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 |
default: dev_dbg(&dev->core, "%s:%d: unknown service_id (%u) ", __func__, __LINE__, header.service_id); break; } goto fail_id; fail_header: ps3_vuart_clear_rx_bytes(dev, 0); return -EIO; fail_id: ps3_vuart_clear_rx_bytes(dev, header.payload_size); return -EIO; } |
ca052f792
|
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 |
static void ps3_sys_manager_fin(struct ps3_system_bus_device *dev) { ps3_sys_manager_send_request_shutdown(dev); pr_emerg("System Halted, OK to turn off power "); while (ps3_sys_manager_handle_msg(dev)) { /* pause until next DEC interrupt */ lv1_pause(0); } while (1) { /* pause, ignoring DEC interrupt */ lv1_pause(1); } } |
fde5efd0e
|
601 |
/** |
66c63b84b
|
602 |
* ps3_sys_manager_final_power_off - The final platform machine_power_off routine. |
fde5efd0e
|
603 |
* |
66c63b84b
|
604 |
* This routine never returns. The routine disables asynchronous vuart reads |
fde5efd0e
|
605 606 607 |
* then spins calling ps3_sys_manager_handle_msg() to receive and acknowledge * the shutdown command sent from the system manager. Soon after the * acknowledgement is sent the lpar is destroyed by the HV. This routine |
66c63b84b
|
608 609 |
* should only be called from ps3_power_off() through * ps3_sys_manager_ops.power_off. |
fde5efd0e
|
610 |
*/ |
66c63b84b
|
611 |
static void ps3_sys_manager_final_power_off(struct ps3_system_bus_device *dev) |
fde5efd0e
|
612 |
{ |
66c63b84b
|
613 |
BUG_ON(!dev); |
fde5efd0e
|
614 615 616 617 618 |
dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); ps3_vuart_cancel_async(dev); |
66c63b84b
|
619 |
ps3_sys_manager_send_next_op(dev, PS3_SM_NEXT_OP_SYS_SHUTDOWN, |
1c43d265f
|
620 |
user_wake_sources); |
fde5efd0e
|
621 |
|
ca052f792
|
622 |
ps3_sys_manager_fin(dev); |
fde5efd0e
|
623 624 625 |
} /** |
66c63b84b
|
626 |
* ps3_sys_manager_final_restart - The final platform machine_restart routine. |
fde5efd0e
|
627 |
* |
66c63b84b
|
628 |
* This routine never returns. The routine disables asynchronous vuart reads |
fde5efd0e
|
629 630 631 |
* then spins calling ps3_sys_manager_handle_msg() to receive and acknowledge * the shutdown command sent from the system manager. Soon after the * acknowledgement is sent the lpar is destroyed by the HV. This routine |
66c63b84b
|
632 |
* should only be called from ps3_restart() through ps3_sys_manager_ops.restart. |
fde5efd0e
|
633 |
*/ |
66c63b84b
|
634 |
static void ps3_sys_manager_final_restart(struct ps3_system_bus_device *dev) |
fde5efd0e
|
635 |
{ |
66c63b84b
|
636 |
BUG_ON(!dev); |
fde5efd0e
|
637 638 639 |
dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); |
66c63b84b
|
640 641 642 643 644 645 646 647 |
/* Check if we got here via a power button event. */ if (ps3_sm_force_power_off) { dev_dbg(&dev->core, "%s:%d: forcing poweroff ", __func__, __LINE__); ps3_sys_manager_final_power_off(dev); } |
fde5efd0e
|
648 |
ps3_vuart_cancel_async(dev); |
66c63b84b
|
649 |
ps3_sys_manager_send_attr(dev, 0); |
75ffe88d2
|
650 |
ps3_sys_manager_send_next_op(dev, PS3_SM_NEXT_OP_SYS_REBOOT, |
1c43d265f
|
651 |
user_wake_sources); |
fde5efd0e
|
652 |
|
ca052f792
|
653 |
ps3_sys_manager_fin(dev); |
fde5efd0e
|
654 |
} |
66c63b84b
|
655 |
/** |
1c43d265f
|
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 |
* ps3_sys_manager_get_wol - Get wake-on-lan setting. */ int ps3_sys_manager_get_wol(void) { pr_debug("%s:%d ", __func__, __LINE__); return (user_wake_sources & PS3_SM_WAKE_W_O_L) != 0; } EXPORT_SYMBOL_GPL(ps3_sys_manager_get_wol); /** * ps3_sys_manager_set_wol - Set wake-on-lan setting. */ void ps3_sys_manager_set_wol(int state) { static DEFINE_MUTEX(mutex); mutex_lock(&mutex); pr_debug("%s:%d: %d ", __func__, __LINE__, state); if (state) user_wake_sources |= PS3_SM_WAKE_W_O_L; else user_wake_sources &= ~PS3_SM_WAKE_W_O_L; mutex_unlock(&mutex); } EXPORT_SYMBOL_GPL(ps3_sys_manager_set_wol); /** |
66c63b84b
|
690 691 692 693 694 695 696 697 698 699 |
* ps3_sys_manager_work - Asynchronous read handler. * * Signaled when PS3_SM_RX_MSG_LEN_MIN bytes arrive at the vuart port. */ static void ps3_sys_manager_work(struct ps3_system_bus_device *dev) { ps3_sys_manager_handle_msg(dev); ps3_vuart_read_async(dev, PS3_SM_RX_MSG_LEN_MIN); } |
0fe763c57
|
700 |
static int ps3_sys_manager_probe(struct ps3_system_bus_device *dev) |
fde5efd0e
|
701 702 |
{ int result; |
66c63b84b
|
703 |
struct ps3_sys_manager_ops ops; |
fde5efd0e
|
704 705 706 |
dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); |
66c63b84b
|
707 708 709 710 711 712 713 |
ops.power_off = ps3_sys_manager_final_power_off; ops.restart = ps3_sys_manager_final_restart; ops.dev = dev; /* ps3_sys_manager_register_ops copies ops. */ ps3_sys_manager_register_ops(&ops); |
fde5efd0e
|
714 715 716 |
result = ps3_sys_manager_send_attr(dev, PS3_SM_ATTR_ALL); BUG_ON(result); |
66c63b84b
|
717 |
result = ps3_vuart_read_async(dev, PS3_SM_RX_MSG_LEN_MIN); |
fde5efd0e
|
718 719 720 721 |
BUG_ON(result); return result; } |
66c63b84b
|
722 723 724 725 726 727 728 729 730 731 732 733 |
static int ps3_sys_manager_remove(struct ps3_system_bus_device *dev) { dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); return 0; } static void ps3_sys_manager_shutdown(struct ps3_system_bus_device *dev) { dev_dbg(&dev->core, "%s:%d ", __func__, __LINE__); } |
fde5efd0e
|
734 |
static struct ps3_vuart_port_driver ps3_sys_manager = { |
66c63b84b
|
735 736 |
.core.match_id = PS3_MATCH_ID_SYSTEM_MANAGER, .core.core.name = "ps3_sys_manager", |
fde5efd0e
|
737 |
.probe = ps3_sys_manager_probe, |
66c63b84b
|
738 739 740 |
.remove = ps3_sys_manager_remove, .shutdown = ps3_sys_manager_shutdown, .work = ps3_sys_manager_work, |
fde5efd0e
|
741 742 743 744 |
}; static int __init ps3_sys_manager_init(void) { |
ef596c697
|
745 746 |
if (!firmware_has_feature(FW_FEATURE_PS3_LV1)) return -ENODEV; |
fde5efd0e
|
747 748 749 750 |
return ps3_vuart_port_driver_register(&ps3_sys_manager); } module_init(ps3_sys_manager_init); |
66c63b84b
|
751 |
/* Module remove not supported. */ |
50dad9026
|
752 753 754 |
MODULE_AUTHOR("Sony Corporation"); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("PS3 System Manager"); |
66c63b84b
|
755 |
MODULE_ALIAS(PS3_MODULE_ALIAS_SYSTEM_MANAGER); |