1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright © 2016 Intel Corporation 4 * 5 * Authors: 6 * Scott Bauer <scott.bauer@intel.com> 7 * Rafael Antognolli <rafael.antognolli@intel.com> 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ":OPAL: " fmt 11 12 #include <linux/delay.h> 13 #include <linux/device.h> 14 #include <linux/kernel.h> 15 #include <linux/list.h> 16 #include <linux/genhd.h> 17 #include <linux/slab.h> 18 #include <linux/uaccess.h> 19 #include <uapi/linux/sed-opal.h> 20 #include <linux/sed-opal.h> 21 #include <linux/string.h> 22 #include <linux/kdev_t.h> 23 24 #include "opal_proto.h" 25 26 #define IO_BUFFER_LENGTH 2048 27 #define MAX_TOKS 64 28 29 /* Number of bytes needed by cmd_finalize. */ 30 #define CMD_FINALIZE_BYTES_NEEDED 7 31 32 struct opal_step { 33 int (*fn)(struct opal_dev *dev, void *data); 34 void *data; 35 }; 36 typedef int (cont_fn)(struct opal_dev *dev); 37 38 enum opal_atom_width { 39 OPAL_WIDTH_TINY, 40 OPAL_WIDTH_SHORT, 41 OPAL_WIDTH_MEDIUM, 42 OPAL_WIDTH_LONG, 43 OPAL_WIDTH_TOKEN 44 }; 45 46 /* 47 * On the parsed response, we don't store again the toks that are already 48 * stored in the response buffer. Instead, for each token, we just store a 49 * pointer to the position in the buffer where the token starts, and the size 50 * of the token in bytes. 51 */ 52 struct opal_resp_tok { 53 const u8 *pos; 54 size_t len; 55 enum opal_response_token type; 56 enum opal_atom_width width; 57 union { 58 u64 u; 59 s64 s; 60 } stored; 61 }; 62 63 /* 64 * From the response header it's not possible to know how many tokens there are 65 * on the payload. So we hardcode that the maximum will be MAX_TOKS, and later 66 * if we start dealing with messages that have more than that, we can increase 67 * this number. This is done to avoid having to make two passes through the 68 * response, the first one counting how many tokens we have and the second one 69 * actually storing the positions. 70 */ 71 struct parsed_resp { 72 int num; 73 struct opal_resp_tok toks[MAX_TOKS]; 74 }; 75 76 struct opal_dev { 77 bool supported; 78 bool mbr_enabled; 79 80 void *data; 81 sec_send_recv *send_recv; 82 83 struct mutex dev_lock; 84 u16 comid; 85 u32 hsn; 86 u32 tsn; 87 u64 align; 88 u64 lowest_lba; 89 90 size_t pos; 91 u8 cmd[IO_BUFFER_LENGTH]; 92 u8 resp[IO_BUFFER_LENGTH]; 93 94 struct parsed_resp parsed; 95 size_t prev_d_len; 96 void *prev_data; 97 98 struct list_head unlk_lst; 99 }; 100 101 102 static const u8 opaluid[][OPAL_UID_LENGTH] = { 103 /* users */ 104 [OPAL_SMUID_UID] = 105 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff }, 106 [OPAL_THISSP_UID] = 107 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, 108 [OPAL_ADMINSP_UID] = 109 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x01 }, 110 [OPAL_LOCKINGSP_UID] = 111 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x02 }, 112 [OPAL_ENTERPRISE_LOCKINGSP_UID] = 113 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x01, 0x00, 0x01 }, 114 [OPAL_ANYBODY_UID] = 115 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01 }, 116 [OPAL_SID_UID] = 117 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06 }, 118 [OPAL_ADMIN1_UID] = 119 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x01 }, 120 [OPAL_USER1_UID] = 121 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x01 }, 122 [OPAL_USER2_UID] = 123 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x02 }, 124 [OPAL_PSID_UID] = 125 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0xff, 0x01 }, 126 [OPAL_ENTERPRISE_BANDMASTER0_UID] = 127 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x80, 0x01 }, 128 [OPAL_ENTERPRISE_ERASEMASTER_UID] = 129 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x84, 0x01 }, 130 131 /* tables */ 132 133 [OPAL_TABLE_TABLE] 134 { 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01 }, 135 [OPAL_LOCKINGRANGE_GLOBAL] = 136 { 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 }, 137 [OPAL_LOCKINGRANGE_ACE_RDLOCKED] = 138 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE0, 0x01 }, 139 [OPAL_LOCKINGRANGE_ACE_WRLOCKED] = 140 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE8, 0x01 }, 141 [OPAL_MBRCONTROL] = 142 { 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x01 }, 143 [OPAL_MBR] = 144 { 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00 }, 145 [OPAL_AUTHORITY_TABLE] = 146 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00}, 147 [OPAL_C_PIN_TABLE] = 148 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00}, 149 [OPAL_LOCKING_INFO_TABLE] = 150 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01 }, 151 [OPAL_ENTERPRISE_LOCKING_INFO_TABLE] = 152 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00 }, 153 154 /* C_PIN_TABLE object ID's */ 155 156 [OPAL_C_PIN_MSID] = 157 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x84, 0x02}, 158 [OPAL_C_PIN_SID] = 159 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01}, 160 [OPAL_C_PIN_ADMIN1] = 161 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x01}, 162 163 /* half UID's (only first 4 bytes used) */ 164 165 [OPAL_HALF_UID_AUTHORITY_OBJ_REF] = 166 { 0x00, 0x00, 0x0C, 0x05, 0xff, 0xff, 0xff, 0xff }, 167 [OPAL_HALF_UID_BOOLEAN_ACE] = 168 { 0x00, 0x00, 0x04, 0x0E, 0xff, 0xff, 0xff, 0xff }, 169 170 /* special value for omitted optional parameter */ 171 [OPAL_UID_HEXFF] = 172 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 173 }; 174 175 /* 176 * TCG Storage SSC Methods. 177 * Derived from: TCG_Storage_Architecture_Core_Spec_v2.01_r1.00 178 * Section: 6.3 Assigned UIDs 179 */ 180 static const u8 opalmethod[][OPAL_METHOD_LENGTH] = { 181 [OPAL_PROPERTIES] = 182 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01 }, 183 [OPAL_STARTSESSION] = 184 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x02 }, 185 [OPAL_REVERT] = 186 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x02 }, 187 [OPAL_ACTIVATE] = 188 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x03 }, 189 [OPAL_EGET] = 190 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06 }, 191 [OPAL_ESET] = 192 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07 }, 193 [OPAL_NEXT] = 194 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08 }, 195 [OPAL_EAUTHENTICATE] = 196 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c }, 197 [OPAL_GETACL] = 198 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d }, 199 [OPAL_GENKEY] = 200 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10 }, 201 [OPAL_REVERTSP] = 202 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11 }, 203 [OPAL_GET] = 204 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16 }, 205 [OPAL_SET] = 206 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17 }, 207 [OPAL_AUTHENTICATE] = 208 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1c }, 209 [OPAL_RANDOM] = 210 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x01 }, 211 [OPAL_ERASE] = 212 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x08, 0x03 }, 213 }; 214 215 static int end_opal_session_error(struct opal_dev *dev); 216 static int opal_discovery0_step(struct opal_dev *dev); 217 218 struct opal_suspend_data { 219 struct opal_lock_unlock unlk; 220 u8 lr; 221 struct list_head node; 222 }; 223 224 /* 225 * Derived from: 226 * TCG_Storage_Architecture_Core_Spec_v2.01_r1.00 227 * Section: 5.1.5 Method Status Codes 228 */ 229 static const char * const opal_errors[] = { 230 "Success", 231 "Not Authorized", 232 "Unknown Error", 233 "SP Busy", 234 "SP Failed", 235 "SP Disabled", 236 "SP Frozen", 237 "No Sessions Available", 238 "Uniqueness Conflict", 239 "Insufficient Space", 240 "Insufficient Rows", 241 "Invalid Function", 242 "Invalid Parameter", 243 "Invalid Reference", 244 "Unknown Error", 245 "TPER Malfunction", 246 "Transaction Failure", 247 "Response Overflow", 248 "Authority Locked Out", 249 }; 250 251 static const char *opal_error_to_human(int error) 252 { 253 if (error == 0x3f) 254 return "Failed"; 255 256 if (error >= ARRAY_SIZE(opal_errors) || error < 0) 257 return "Unknown Error"; 258 259 return opal_errors[error]; 260 } 261 262 static void print_buffer(const u8 *ptr, u32 length) 263 { 264 #ifdef DEBUG 265 print_hex_dump_bytes("OPAL: ", DUMP_PREFIX_OFFSET, ptr, length); 266 pr_debug("\n"); 267 #endif 268 } 269 270 static bool check_tper(const void *data) 271 { 272 const struct d0_tper_features *tper = data; 273 u8 flags = tper->supported_features; 274 275 if (!(flags & TPER_SYNC_SUPPORTED)) { 276 pr_debug("TPer sync not supported. flags = %d\n", 277 tper->supported_features); 278 return false; 279 } 280 281 return true; 282 } 283 284 static bool check_mbrenabled(const void *data) 285 { 286 const struct d0_locking_features *lfeat = data; 287 u8 sup_feat = lfeat->supported_features; 288 289 return !!(sup_feat & MBR_ENABLED_MASK); 290 } 291 292 static bool check_sum(const void *data) 293 { 294 const struct d0_single_user_mode *sum = data; 295 u32 nlo = be32_to_cpu(sum->num_locking_objects); 296 297 if (nlo == 0) { 298 pr_debug("Need at least one locking object.\n"); 299 return false; 300 } 301 302 pr_debug("Number of locking objects: %d\n", nlo); 303 304 return true; 305 } 306 307 static u16 get_comid_v100(const void *data) 308 { 309 const struct d0_opal_v100 *v100 = data; 310 311 return be16_to_cpu(v100->baseComID); 312 } 313 314 static u16 get_comid_v200(const void *data) 315 { 316 const struct d0_opal_v200 *v200 = data; 317 318 return be16_to_cpu(v200->baseComID); 319 } 320 321 static int opal_send_cmd(struct opal_dev *dev) 322 { 323 return dev->send_recv(dev->data, dev->comid, TCG_SECP_01, 324 dev->cmd, IO_BUFFER_LENGTH, 325 true); 326 } 327 328 static int opal_recv_cmd(struct opal_dev *dev) 329 { 330 return dev->send_recv(dev->data, dev->comid, TCG_SECP_01, 331 dev->resp, IO_BUFFER_LENGTH, 332 false); 333 } 334 335 static int opal_recv_check(struct opal_dev *dev) 336 { 337 size_t buflen = IO_BUFFER_LENGTH; 338 void *buffer = dev->resp; 339 struct opal_header *hdr = buffer; 340 int ret; 341 342 do { 343 pr_debug("Sent OPAL command: outstanding=%d, minTransfer=%d\n", 344 hdr->cp.outstandingData, 345 hdr->cp.minTransfer); 346 347 if (hdr->cp.outstandingData == 0 || 348 hdr->cp.minTransfer != 0) 349 return 0; 350 351 memset(buffer, 0, buflen); 352 ret = opal_recv_cmd(dev); 353 } while (!ret); 354 355 return ret; 356 } 357 358 static int opal_send_recv(struct opal_dev *dev, cont_fn *cont) 359 { 360 int ret; 361 362 ret = opal_send_cmd(dev); 363 if (ret) 364 return ret; 365 ret = opal_recv_cmd(dev); 366 if (ret) 367 return ret; 368 ret = opal_recv_check(dev); 369 if (ret) 370 return ret; 371 return cont(dev); 372 } 373 374 static void check_geometry(struct opal_dev *dev, const void *data) 375 { 376 const struct d0_geometry_features *geo = data; 377 378 dev->align = geo->alignment_granularity; 379 dev->lowest_lba = geo->lowest_aligned_lba; 380 } 381 382 static int execute_step(struct opal_dev *dev, 383 const struct opal_step *step, size_t stepIndex) 384 { 385 int error = step->fn(dev, step->data); 386 387 if (error) { 388 pr_debug("Step %zu (%pS) failed with error %d: %s\n", 389 stepIndex, step->fn, error, 390 opal_error_to_human(error)); 391 } 392 393 return error; 394 } 395 396 static int execute_steps(struct opal_dev *dev, 397 const struct opal_step *steps, size_t n_steps) 398 { 399 size_t state = 0; 400 int error; 401 402 /* first do a discovery0 */ 403 error = opal_discovery0_step(dev); 404 if (error) 405 return error; 406 407 for (state = 0; state < n_steps; state++) { 408 error = execute_step(dev, &steps[state], state); 409 if (error) 410 goto out_error; 411 } 412 413 return 0; 414 415 out_error: 416 /* 417 * For each OPAL command the first step in steps starts some sort of 418 * session. If an error occurred in the initial discovery0 or if an 419 * error occurred in the first step (and thus stopping the loop with 420 * state == 0) then there was an error before or during the attempt to 421 * start a session. Therefore we shouldn't attempt to terminate a 422 * session, as one has not yet been created. 423 */ 424 if (state > 0) 425 end_opal_session_error(dev); 426 427 return error; 428 } 429 430 static int opal_discovery0_end(struct opal_dev *dev) 431 { 432 bool found_com_id = false, supported = true, single_user = false; 433 const struct d0_header *hdr = (struct d0_header *)dev->resp; 434 const u8 *epos = dev->resp, *cpos = dev->resp; 435 u16 comid = 0; 436 u32 hlen = be32_to_cpu(hdr->length); 437 438 print_buffer(dev->resp, hlen); 439 dev->mbr_enabled = false; 440 441 if (hlen > IO_BUFFER_LENGTH - sizeof(*hdr)) { 442 pr_debug("Discovery length overflows buffer (%zu+%u)/%u\n", 443 sizeof(*hdr), hlen, IO_BUFFER_LENGTH); 444 return -EFAULT; 445 } 446 447 epos += hlen; /* end of buffer */ 448 cpos += sizeof(*hdr); /* current position on buffer */ 449 450 while (cpos < epos && supported) { 451 const struct d0_features *body = 452 (const struct d0_features *)cpos; 453 454 switch (be16_to_cpu(body->code)) { 455 case FC_TPER: 456 supported = check_tper(body->features); 457 break; 458 case FC_SINGLEUSER: 459 single_user = check_sum(body->features); 460 break; 461 case FC_GEOMETRY: 462 check_geometry(dev, body); 463 break; 464 case FC_LOCKING: 465 dev->mbr_enabled = check_mbrenabled(body->features); 466 break; 467 case FC_ENTERPRISE: 468 case FC_DATASTORE: 469 /* some ignored properties */ 470 pr_debug("Found OPAL feature description: %d\n", 471 be16_to_cpu(body->code)); 472 break; 473 case FC_OPALV100: 474 comid = get_comid_v100(body->features); 475 found_com_id = true; 476 break; 477 case FC_OPALV200: 478 comid = get_comid_v200(body->features); 479 found_com_id = true; 480 break; 481 case 0xbfff ... 0xffff: 482 /* vendor specific, just ignore */ 483 break; 484 default: 485 pr_debug("OPAL Unknown feature: %d\n", 486 be16_to_cpu(body->code)); 487 488 } 489 cpos += body->length + 4; 490 } 491 492 if (!supported) { 493 pr_debug("This device is not Opal enabled. Not Supported!\n"); 494 return -EOPNOTSUPP; 495 } 496 497 if (!single_user) 498 pr_debug("Device doesn't support single user mode\n"); 499 500 501 if (!found_com_id) { 502 pr_debug("Could not find OPAL comid for device. Returning early\n"); 503 return -EOPNOTSUPP; 504 } 505 506 dev->comid = comid; 507 508 return 0; 509 } 510 511 static int opal_discovery0(struct opal_dev *dev, void *data) 512 { 513 int ret; 514 515 memset(dev->resp, 0, IO_BUFFER_LENGTH); 516 dev->comid = OPAL_DISCOVERY_COMID; 517 ret = opal_recv_cmd(dev); 518 if (ret) 519 return ret; 520 return opal_discovery0_end(dev); 521 } 522 523 static int opal_discovery0_step(struct opal_dev *dev) 524 { 525 const struct opal_step discovery0_step = { 526 opal_discovery0, 527 }; 528 return execute_step(dev, &discovery0_step, 0); 529 } 530 531 static size_t remaining_size(struct opal_dev *cmd) 532 { 533 return IO_BUFFER_LENGTH - cmd->pos; 534 } 535 536 static bool can_add(int *err, struct opal_dev *cmd, size_t len) 537 { 538 if (*err) 539 return false; 540 541 if (remaining_size(cmd) < len) { 542 pr_debug("Error adding %zu bytes: end of buffer.\n", len); 543 *err = -ERANGE; 544 return false; 545 } 546 547 return true; 548 } 549 550 static void add_token_u8(int *err, struct opal_dev *cmd, u8 tok) 551 { 552 if (!can_add(err, cmd, 1)) 553 return; 554 cmd->cmd[cmd->pos++] = tok; 555 } 556 557 static void add_short_atom_header(struct opal_dev *cmd, bool bytestring, 558 bool has_sign, int len) 559 { 560 u8 atom; 561 int err = 0; 562 563 atom = SHORT_ATOM_ID; 564 atom |= bytestring ? SHORT_ATOM_BYTESTRING : 0; 565 atom |= has_sign ? SHORT_ATOM_SIGNED : 0; 566 atom |= len & SHORT_ATOM_LEN_MASK; 567 568 add_token_u8(&err, cmd, atom); 569 } 570 571 static void add_medium_atom_header(struct opal_dev *cmd, bool bytestring, 572 bool has_sign, int len) 573 { 574 u8 header0; 575 576 header0 = MEDIUM_ATOM_ID; 577 header0 |= bytestring ? MEDIUM_ATOM_BYTESTRING : 0; 578 header0 |= has_sign ? MEDIUM_ATOM_SIGNED : 0; 579 header0 |= (len >> 8) & MEDIUM_ATOM_LEN_MASK; 580 cmd->cmd[cmd->pos++] = header0; 581 cmd->cmd[cmd->pos++] = len; 582 } 583 584 static void add_token_u64(int *err, struct opal_dev *cmd, u64 number) 585 { 586 size_t len; 587 int msb; 588 589 if (!(number & ~TINY_ATOM_DATA_MASK)) { 590 add_token_u8(err, cmd, number); 591 return; 592 } 593 594 msb = fls64(number); 595 len = DIV_ROUND_UP(msb, 8); 596 597 if (!can_add(err, cmd, len + 1)) { 598 pr_debug("Error adding u64: end of buffer.\n"); 599 return; 600 } 601 add_short_atom_header(cmd, false, false, len); 602 while (len--) 603 add_token_u8(err, cmd, number >> (len * 8)); 604 } 605 606 static u8 *add_bytestring_header(int *err, struct opal_dev *cmd, size_t len) 607 { 608 size_t header_len = 1; 609 bool is_short_atom = true; 610 611 if (len & ~SHORT_ATOM_LEN_MASK) { 612 header_len = 2; 613 is_short_atom = false; 614 } 615 616 if (!can_add(err, cmd, header_len + len)) { 617 pr_debug("Error adding bytestring: end of buffer.\n"); 618 return NULL; 619 } 620 621 if (is_short_atom) 622 add_short_atom_header(cmd, true, false, len); 623 else 624 add_medium_atom_header(cmd, true, false, len); 625 626 return &cmd->cmd[cmd->pos]; 627 } 628 629 static void add_token_bytestring(int *err, struct opal_dev *cmd, 630 const u8 *bytestring, size_t len) 631 { 632 u8 *start; 633 634 start = add_bytestring_header(err, cmd, len); 635 if (!start) 636 return; 637 memcpy(start, bytestring, len); 638 cmd->pos += len; 639 } 640 641 static int build_locking_range(u8 *buffer, size_t length, u8 lr) 642 { 643 if (length > OPAL_UID_LENGTH) { 644 pr_debug("Can't build locking range. Length OOB\n"); 645 return -ERANGE; 646 } 647 648 memcpy(buffer, opaluid[OPAL_LOCKINGRANGE_GLOBAL], OPAL_UID_LENGTH); 649 650 if (lr == 0) 651 return 0; 652 buffer[5] = LOCKING_RANGE_NON_GLOBAL; 653 buffer[7] = lr; 654 655 return 0; 656 } 657 658 static int build_locking_user(u8 *buffer, size_t length, u8 lr) 659 { 660 if (length > OPAL_UID_LENGTH) { 661 pr_debug("Can't build locking range user. Length OOB\n"); 662 return -ERANGE; 663 } 664 665 memcpy(buffer, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH); 666 667 buffer[7] = lr + 1; 668 669 return 0; 670 } 671 672 static void set_comid(struct opal_dev *cmd, u16 comid) 673 { 674 struct opal_header *hdr = (struct opal_header *)cmd->cmd; 675 676 hdr->cp.extendedComID[0] = comid >> 8; 677 hdr->cp.extendedComID[1] = comid; 678 hdr->cp.extendedComID[2] = 0; 679 hdr->cp.extendedComID[3] = 0; 680 } 681 682 static int cmd_finalize(struct opal_dev *cmd, u32 hsn, u32 tsn) 683 { 684 struct opal_header *hdr; 685 int err = 0; 686 687 /* 688 * Close the parameter list opened from cmd_start. 689 * The number of bytes added must be equal to 690 * CMD_FINALIZE_BYTES_NEEDED. 691 */ 692 add_token_u8(&err, cmd, OPAL_ENDLIST); 693 694 add_token_u8(&err, cmd, OPAL_ENDOFDATA); 695 add_token_u8(&err, cmd, OPAL_STARTLIST); 696 add_token_u8(&err, cmd, 0); 697 add_token_u8(&err, cmd, 0); 698 add_token_u8(&err, cmd, 0); 699 add_token_u8(&err, cmd, OPAL_ENDLIST); 700 701 if (err) { 702 pr_debug("Error finalizing command.\n"); 703 return -EFAULT; 704 } 705 706 hdr = (struct opal_header *) cmd->cmd; 707 708 hdr->pkt.tsn = cpu_to_be32(tsn); 709 hdr->pkt.hsn = cpu_to_be32(hsn); 710 711 hdr->subpkt.length = cpu_to_be32(cmd->pos - sizeof(*hdr)); 712 while (cmd->pos % 4) { 713 if (cmd->pos >= IO_BUFFER_LENGTH) { 714 pr_debug("Error: Buffer overrun\n"); 715 return -ERANGE; 716 } 717 cmd->cmd[cmd->pos++] = 0; 718 } 719 hdr->pkt.length = cpu_to_be32(cmd->pos - sizeof(hdr->cp) - 720 sizeof(hdr->pkt)); 721 hdr->cp.length = cpu_to_be32(cmd->pos - sizeof(hdr->cp)); 722 723 return 0; 724 } 725 726 static const struct opal_resp_tok *response_get_token( 727 const struct parsed_resp *resp, 728 int n) 729 { 730 const struct opal_resp_tok *tok; 731 732 if (!resp) { 733 pr_debug("Response is NULL\n"); 734 return ERR_PTR(-EINVAL); 735 } 736 737 if (n >= resp->num) { 738 pr_debug("Token number doesn't exist: %d, resp: %d\n", 739 n, resp->num); 740 return ERR_PTR(-EINVAL); 741 } 742 743 tok = &resp->toks[n]; 744 if (tok->len == 0) { 745 pr_debug("Token length must be non-zero\n"); 746 return ERR_PTR(-EINVAL); 747 } 748 749 return tok; 750 } 751 752 static ssize_t response_parse_tiny(struct opal_resp_tok *tok, 753 const u8 *pos) 754 { 755 tok->pos = pos; 756 tok->len = 1; 757 tok->width = OPAL_WIDTH_TINY; 758 759 if (pos[0] & TINY_ATOM_SIGNED) { 760 tok->type = OPAL_DTA_TOKENID_SINT; 761 } else { 762 tok->type = OPAL_DTA_TOKENID_UINT; 763 tok->stored.u = pos[0] & 0x3f; 764 } 765 766 return tok->len; 767 } 768 769 static ssize_t response_parse_short(struct opal_resp_tok *tok, 770 const u8 *pos) 771 { 772 tok->pos = pos; 773 tok->len = (pos[0] & SHORT_ATOM_LEN_MASK) + 1; 774 tok->width = OPAL_WIDTH_SHORT; 775 776 if (pos[0] & SHORT_ATOM_BYTESTRING) { 777 tok->type = OPAL_DTA_TOKENID_BYTESTRING; 778 } else if (pos[0] & SHORT_ATOM_SIGNED) { 779 tok->type = OPAL_DTA_TOKENID_SINT; 780 } else { 781 u64 u_integer = 0; 782 ssize_t i, b = 0; 783 784 tok->type = OPAL_DTA_TOKENID_UINT; 785 if (tok->len > 9) { 786 pr_debug("uint64 with more than 8 bytes\n"); 787 return -EINVAL; 788 } 789 for (i = tok->len - 1; i > 0; i--) { 790 u_integer |= ((u64)pos[i] << (8 * b)); 791 b++; 792 } 793 tok->stored.u = u_integer; 794 } 795 796 return tok->len; 797 } 798 799 static ssize_t response_parse_medium(struct opal_resp_tok *tok, 800 const u8 *pos) 801 { 802 tok->pos = pos; 803 tok->len = (((pos[0] & MEDIUM_ATOM_LEN_MASK) << 8) | pos[1]) + 2; 804 tok->width = OPAL_WIDTH_MEDIUM; 805 806 if (pos[0] & MEDIUM_ATOM_BYTESTRING) 807 tok->type = OPAL_DTA_TOKENID_BYTESTRING; 808 else if (pos[0] & MEDIUM_ATOM_SIGNED) 809 tok->type = OPAL_DTA_TOKENID_SINT; 810 else 811 tok->type = OPAL_DTA_TOKENID_UINT; 812 813 return tok->len; 814 } 815 816 static ssize_t response_parse_long(struct opal_resp_tok *tok, 817 const u8 *pos) 818 { 819 tok->pos = pos; 820 tok->len = ((pos[1] << 16) | (pos[2] << 8) | pos[3]) + 4; 821 tok->width = OPAL_WIDTH_LONG; 822 823 if (pos[0] & LONG_ATOM_BYTESTRING) 824 tok->type = OPAL_DTA_TOKENID_BYTESTRING; 825 else if (pos[0] & LONG_ATOM_SIGNED) 826 tok->type = OPAL_DTA_TOKENID_SINT; 827 else 828 tok->type = OPAL_DTA_TOKENID_UINT; 829 830 return tok->len; 831 } 832 833 static ssize_t response_parse_token(struct opal_resp_tok *tok, 834 const u8 *pos) 835 { 836 tok->pos = pos; 837 tok->len = 1; 838 tok->type = OPAL_DTA_TOKENID_TOKEN; 839 tok->width = OPAL_WIDTH_TOKEN; 840 841 return tok->len; 842 } 843 844 static int response_parse(const u8 *buf, size_t length, 845 struct parsed_resp *resp) 846 { 847 const struct opal_header *hdr; 848 struct opal_resp_tok *iter; 849 int num_entries = 0; 850 int total; 851 ssize_t token_length; 852 const u8 *pos; 853 u32 clen, plen, slen; 854 855 if (!buf) 856 return -EFAULT; 857 858 if (!resp) 859 return -EFAULT; 860 861 hdr = (struct opal_header *)buf; 862 pos = buf; 863 pos += sizeof(*hdr); 864 865 clen = be32_to_cpu(hdr->cp.length); 866 plen = be32_to_cpu(hdr->pkt.length); 867 slen = be32_to_cpu(hdr->subpkt.length); 868 pr_debug("Response size: cp: %u, pkt: %u, subpkt: %u\n", 869 clen, plen, slen); 870 871 if (clen == 0 || plen == 0 || slen == 0 || 872 slen > IO_BUFFER_LENGTH - sizeof(*hdr)) { 873 pr_debug("Bad header length. cp: %u, pkt: %u, subpkt: %u\n", 874 clen, plen, slen); 875 print_buffer(pos, sizeof(*hdr)); 876 return -EINVAL; 877 } 878 879 if (pos > buf + length) 880 return -EFAULT; 881 882 iter = resp->toks; 883 total = slen; 884 print_buffer(pos, total); 885 while (total > 0) { 886 if (pos[0] <= TINY_ATOM_BYTE) /* tiny atom */ 887 token_length = response_parse_tiny(iter, pos); 888 else if (pos[0] <= SHORT_ATOM_BYTE) /* short atom */ 889 token_length = response_parse_short(iter, pos); 890 else if (pos[0] <= MEDIUM_ATOM_BYTE) /* medium atom */ 891 token_length = response_parse_medium(iter, pos); 892 else if (pos[0] <= LONG_ATOM_BYTE) /* long atom */ 893 token_length = response_parse_long(iter, pos); 894 else /* TOKEN */ 895 token_length = response_parse_token(iter, pos); 896 897 if (token_length < 0) 898 return token_length; 899 900 pos += token_length; 901 total -= token_length; 902 iter++; 903 num_entries++; 904 } 905 906 if (num_entries == 0) { 907 pr_debug("Couldn't parse response.\n"); 908 return -EINVAL; 909 } 910 resp->num = num_entries; 911 912 return 0; 913 } 914 915 static size_t response_get_string(const struct parsed_resp *resp, int n, 916 const char **store) 917 { 918 u8 skip; 919 const struct opal_resp_tok *tok; 920 921 *store = NULL; 922 tok = response_get_token(resp, n); 923 if (IS_ERR(tok)) 924 return 0; 925 926 if (tok->type != OPAL_DTA_TOKENID_BYTESTRING) { 927 pr_debug("Token is not a byte string!\n"); 928 return 0; 929 } 930 931 switch (tok->width) { 932 case OPAL_WIDTH_TINY: 933 case OPAL_WIDTH_SHORT: 934 skip = 1; 935 break; 936 case OPAL_WIDTH_MEDIUM: 937 skip = 2; 938 break; 939 case OPAL_WIDTH_LONG: 940 skip = 4; 941 break; 942 default: 943 pr_debug("Token has invalid width!\n"); 944 return 0; 945 } 946 947 *store = tok->pos + skip; 948 return tok->len - skip; 949 } 950 951 static u64 response_get_u64(const struct parsed_resp *resp, int n) 952 { 953 const struct opal_resp_tok *tok; 954 955 tok = response_get_token(resp, n); 956 if (IS_ERR(tok)) 957 return 0; 958 959 if (tok->type != OPAL_DTA_TOKENID_UINT) { 960 pr_debug("Token is not unsigned int: %d\n", tok->type); 961 return 0; 962 } 963 964 if (tok->width != OPAL_WIDTH_TINY && tok->width != OPAL_WIDTH_SHORT) { 965 pr_debug("Atom is not short or tiny: %d\n", tok->width); 966 return 0; 967 } 968 969 return tok->stored.u; 970 } 971 972 static bool response_token_matches(const struct opal_resp_tok *token, u8 match) 973 { 974 if (IS_ERR(token) || 975 token->type != OPAL_DTA_TOKENID_TOKEN || 976 token->pos[0] != match) 977 return false; 978 return true; 979 } 980 981 static u8 response_status(const struct parsed_resp *resp) 982 { 983 const struct opal_resp_tok *tok; 984 985 tok = response_get_token(resp, 0); 986 if (response_token_matches(tok, OPAL_ENDOFSESSION)) 987 return 0; 988 989 if (resp->num < 5) 990 return DTAERROR_NO_METHOD_STATUS; 991 992 tok = response_get_token(resp, resp->num - 5); 993 if (!response_token_matches(tok, OPAL_STARTLIST)) 994 return DTAERROR_NO_METHOD_STATUS; 995 996 tok = response_get_token(resp, resp->num - 1); 997 if (!response_token_matches(tok, OPAL_ENDLIST)) 998 return DTAERROR_NO_METHOD_STATUS; 999 1000 return response_get_u64(resp, resp->num - 4); 1001 } 1002 1003 /* Parses and checks for errors */ 1004 static int parse_and_check_status(struct opal_dev *dev) 1005 { 1006 int error; 1007 1008 print_buffer(dev->cmd, dev->pos); 1009 1010 error = response_parse(dev->resp, IO_BUFFER_LENGTH, &dev->parsed); 1011 if (error) { 1012 pr_debug("Couldn't parse response.\n"); 1013 return error; 1014 } 1015 1016 return response_status(&dev->parsed); 1017 } 1018 1019 static void clear_opal_cmd(struct opal_dev *dev) 1020 { 1021 dev->pos = sizeof(struct opal_header); 1022 memset(dev->cmd, 0, IO_BUFFER_LENGTH); 1023 } 1024 1025 static int cmd_start(struct opal_dev *dev, const u8 *uid, const u8 *method) 1026 { 1027 int err = 0; 1028 1029 clear_opal_cmd(dev); 1030 set_comid(dev, dev->comid); 1031 1032 add_token_u8(&err, dev, OPAL_CALL); 1033 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH); 1034 add_token_bytestring(&err, dev, method, OPAL_METHOD_LENGTH); 1035 1036 /* 1037 * Every method call is followed by its parameters enclosed within 1038 * OPAL_STARTLIST and OPAL_ENDLIST tokens. We automatically open the 1039 * parameter list here and close it later in cmd_finalize. 1040 */ 1041 add_token_u8(&err, dev, OPAL_STARTLIST); 1042 1043 return err; 1044 } 1045 1046 static int start_opal_session_cont(struct opal_dev *dev) 1047 { 1048 u32 hsn, tsn; 1049 int error = 0; 1050 1051 error = parse_and_check_status(dev); 1052 if (error) 1053 return error; 1054 1055 hsn = response_get_u64(&dev->parsed, 4); 1056 tsn = response_get_u64(&dev->parsed, 5); 1057 1058 if (hsn == 0 && tsn == 0) { 1059 pr_debug("Couldn't authenticate session\n"); 1060 return -EPERM; 1061 } 1062 1063 dev->hsn = hsn; 1064 dev->tsn = tsn; 1065 return 0; 1066 } 1067 1068 static void add_suspend_info(struct opal_dev *dev, 1069 struct opal_suspend_data *sus) 1070 { 1071 struct opal_suspend_data *iter; 1072 1073 list_for_each_entry(iter, &dev->unlk_lst, node) { 1074 if (iter->lr == sus->lr) { 1075 list_del(&iter->node); 1076 kfree(iter); 1077 break; 1078 } 1079 } 1080 list_add_tail(&sus->node, &dev->unlk_lst); 1081 } 1082 1083 static int end_session_cont(struct opal_dev *dev) 1084 { 1085 dev->hsn = 0; 1086 dev->tsn = 0; 1087 return parse_and_check_status(dev); 1088 } 1089 1090 static int finalize_and_send(struct opal_dev *dev, cont_fn cont) 1091 { 1092 int ret; 1093 1094 ret = cmd_finalize(dev, dev->hsn, dev->tsn); 1095 if (ret) { 1096 pr_debug("Error finalizing command buffer: %d\n", ret); 1097 return ret; 1098 } 1099 1100 print_buffer(dev->cmd, dev->pos); 1101 1102 return opal_send_recv(dev, cont); 1103 } 1104 1105 /* 1106 * request @column from table @table on device @dev. On success, the column 1107 * data will be available in dev->resp->tok[4] 1108 */ 1109 static int generic_get_column(struct opal_dev *dev, const u8 *table, 1110 u64 column) 1111 { 1112 int err; 1113 1114 err = cmd_start(dev, table, opalmethod[OPAL_GET]); 1115 1116 add_token_u8(&err, dev, OPAL_STARTLIST); 1117 1118 add_token_u8(&err, dev, OPAL_STARTNAME); 1119 add_token_u8(&err, dev, OPAL_STARTCOLUMN); 1120 add_token_u64(&err, dev, column); 1121 add_token_u8(&err, dev, OPAL_ENDNAME); 1122 1123 add_token_u8(&err, dev, OPAL_STARTNAME); 1124 add_token_u8(&err, dev, OPAL_ENDCOLUMN); 1125 add_token_u64(&err, dev, column); 1126 add_token_u8(&err, dev, OPAL_ENDNAME); 1127 1128 add_token_u8(&err, dev, OPAL_ENDLIST); 1129 1130 if (err) 1131 return err; 1132 1133 return finalize_and_send(dev, parse_and_check_status); 1134 } 1135 1136 /* 1137 * see TCG SAS 5.3.2.3 for a description of the available columns 1138 * 1139 * the result is provided in dev->resp->tok[4] 1140 */ 1141 static int generic_get_table_info(struct opal_dev *dev, enum opal_uid table, 1142 u64 column) 1143 { 1144 u8 uid[OPAL_UID_LENGTH]; 1145 const unsigned int half = OPAL_UID_LENGTH/2; 1146 1147 /* sed-opal UIDs can be split in two halves: 1148 * first: actual table index 1149 * second: relative index in the table 1150 * so we have to get the first half of the OPAL_TABLE_TABLE and use the 1151 * first part of the target table as relative index into that table 1152 */ 1153 memcpy(uid, opaluid[OPAL_TABLE_TABLE], half); 1154 memcpy(uid+half, opaluid[table], half); 1155 1156 return generic_get_column(dev, uid, column); 1157 } 1158 1159 static int gen_key(struct opal_dev *dev, void *data) 1160 { 1161 u8 uid[OPAL_UID_LENGTH]; 1162 int err; 1163 1164 memcpy(uid, dev->prev_data, min(sizeof(uid), dev->prev_d_len)); 1165 kfree(dev->prev_data); 1166 dev->prev_data = NULL; 1167 1168 err = cmd_start(dev, uid, opalmethod[OPAL_GENKEY]); 1169 1170 if (err) { 1171 pr_debug("Error building gen key command\n"); 1172 return err; 1173 1174 } 1175 return finalize_and_send(dev, parse_and_check_status); 1176 } 1177 1178 static int get_active_key_cont(struct opal_dev *dev) 1179 { 1180 const char *activekey; 1181 size_t keylen; 1182 int error = 0; 1183 1184 error = parse_and_check_status(dev); 1185 if (error) 1186 return error; 1187 keylen = response_get_string(&dev->parsed, 4, &activekey); 1188 if (!activekey) { 1189 pr_debug("%s: Couldn't extract the Activekey from the response\n", 1190 __func__); 1191 return OPAL_INVAL_PARAM; 1192 } 1193 dev->prev_data = kmemdup(activekey, keylen, GFP_KERNEL); 1194 1195 if (!dev->prev_data) 1196 return -ENOMEM; 1197 1198 dev->prev_d_len = keylen; 1199 1200 return 0; 1201 } 1202 1203 static int get_active_key(struct opal_dev *dev, void *data) 1204 { 1205 u8 uid[OPAL_UID_LENGTH]; 1206 int err; 1207 u8 *lr = data; 1208 1209 err = build_locking_range(uid, sizeof(uid), *lr); 1210 if (err) 1211 return err; 1212 1213 err = generic_get_column(dev, uid, OPAL_ACTIVEKEY); 1214 if (err) 1215 return err; 1216 1217 return get_active_key_cont(dev); 1218 } 1219 1220 static int generic_lr_enable_disable(struct opal_dev *dev, 1221 u8 *uid, bool rle, bool wle, 1222 bool rl, bool wl) 1223 { 1224 int err; 1225 1226 err = cmd_start(dev, uid, opalmethod[OPAL_SET]); 1227 1228 add_token_u8(&err, dev, OPAL_STARTNAME); 1229 add_token_u8(&err, dev, OPAL_VALUES); 1230 add_token_u8(&err, dev, OPAL_STARTLIST); 1231 1232 add_token_u8(&err, dev, OPAL_STARTNAME); 1233 add_token_u8(&err, dev, OPAL_READLOCKENABLED); 1234 add_token_u8(&err, dev, rle); 1235 add_token_u8(&err, dev, OPAL_ENDNAME); 1236 1237 add_token_u8(&err, dev, OPAL_STARTNAME); 1238 add_token_u8(&err, dev, OPAL_WRITELOCKENABLED); 1239 add_token_u8(&err, dev, wle); 1240 add_token_u8(&err, dev, OPAL_ENDNAME); 1241 1242 add_token_u8(&err, dev, OPAL_STARTNAME); 1243 add_token_u8(&err, dev, OPAL_READLOCKED); 1244 add_token_u8(&err, dev, rl); 1245 add_token_u8(&err, dev, OPAL_ENDNAME); 1246 1247 add_token_u8(&err, dev, OPAL_STARTNAME); 1248 add_token_u8(&err, dev, OPAL_WRITELOCKED); 1249 add_token_u8(&err, dev, wl); 1250 add_token_u8(&err, dev, OPAL_ENDNAME); 1251 1252 add_token_u8(&err, dev, OPAL_ENDLIST); 1253 add_token_u8(&err, dev, OPAL_ENDNAME); 1254 return err; 1255 } 1256 1257 static inline int enable_global_lr(struct opal_dev *dev, u8 *uid, 1258 struct opal_user_lr_setup *setup) 1259 { 1260 int err; 1261 1262 err = generic_lr_enable_disable(dev, uid, !!setup->RLE, !!setup->WLE, 1263 0, 0); 1264 if (err) 1265 pr_debug("Failed to create enable global lr command\n"); 1266 return err; 1267 } 1268 1269 static int setup_locking_range(struct opal_dev *dev, void *data) 1270 { 1271 u8 uid[OPAL_UID_LENGTH]; 1272 struct opal_user_lr_setup *setup = data; 1273 u8 lr; 1274 int err; 1275 1276 lr = setup->session.opal_key.lr; 1277 err = build_locking_range(uid, sizeof(uid), lr); 1278 if (err) 1279 return err; 1280 1281 if (lr == 0) 1282 err = enable_global_lr(dev, uid, setup); 1283 else { 1284 err = cmd_start(dev, uid, opalmethod[OPAL_SET]); 1285 1286 add_token_u8(&err, dev, OPAL_STARTNAME); 1287 add_token_u8(&err, dev, OPAL_VALUES); 1288 add_token_u8(&err, dev, OPAL_STARTLIST); 1289 1290 add_token_u8(&err, dev, OPAL_STARTNAME); 1291 add_token_u8(&err, dev, OPAL_RANGESTART); 1292 add_token_u64(&err, dev, setup->range_start); 1293 add_token_u8(&err, dev, OPAL_ENDNAME); 1294 1295 add_token_u8(&err, dev, OPAL_STARTNAME); 1296 add_token_u8(&err, dev, OPAL_RANGELENGTH); 1297 add_token_u64(&err, dev, setup->range_length); 1298 add_token_u8(&err, dev, OPAL_ENDNAME); 1299 1300 add_token_u8(&err, dev, OPAL_STARTNAME); 1301 add_token_u8(&err, dev, OPAL_READLOCKENABLED); 1302 add_token_u64(&err, dev, !!setup->RLE); 1303 add_token_u8(&err, dev, OPAL_ENDNAME); 1304 1305 add_token_u8(&err, dev, OPAL_STARTNAME); 1306 add_token_u8(&err, dev, OPAL_WRITELOCKENABLED); 1307 add_token_u64(&err, dev, !!setup->WLE); 1308 add_token_u8(&err, dev, OPAL_ENDNAME); 1309 1310 add_token_u8(&err, dev, OPAL_ENDLIST); 1311 add_token_u8(&err, dev, OPAL_ENDNAME); 1312 } 1313 if (err) { 1314 pr_debug("Error building Setup Locking range command.\n"); 1315 return err; 1316 1317 } 1318 1319 return finalize_and_send(dev, parse_and_check_status); 1320 } 1321 1322 static int start_generic_opal_session(struct opal_dev *dev, 1323 enum opal_uid auth, 1324 enum opal_uid sp_type, 1325 const char *key, 1326 u8 key_len) 1327 { 1328 u32 hsn; 1329 int err; 1330 1331 if (key == NULL && auth != OPAL_ANYBODY_UID) 1332 return OPAL_INVAL_PARAM; 1333 1334 hsn = GENERIC_HOST_SESSION_NUM; 1335 err = cmd_start(dev, opaluid[OPAL_SMUID_UID], 1336 opalmethod[OPAL_STARTSESSION]); 1337 1338 add_token_u64(&err, dev, hsn); 1339 add_token_bytestring(&err, dev, opaluid[sp_type], OPAL_UID_LENGTH); 1340 add_token_u8(&err, dev, 1); 1341 1342 switch (auth) { 1343 case OPAL_ANYBODY_UID: 1344 break; 1345 case OPAL_ADMIN1_UID: 1346 case OPAL_SID_UID: 1347 case OPAL_PSID_UID: 1348 add_token_u8(&err, dev, OPAL_STARTNAME); 1349 add_token_u8(&err, dev, 0); /* HostChallenge */ 1350 add_token_bytestring(&err, dev, key, key_len); 1351 add_token_u8(&err, dev, OPAL_ENDNAME); 1352 add_token_u8(&err, dev, OPAL_STARTNAME); 1353 add_token_u8(&err, dev, 3); /* HostSignAuth */ 1354 add_token_bytestring(&err, dev, opaluid[auth], 1355 OPAL_UID_LENGTH); 1356 add_token_u8(&err, dev, OPAL_ENDNAME); 1357 break; 1358 default: 1359 pr_debug("Cannot start Admin SP session with auth %d\n", auth); 1360 return OPAL_INVAL_PARAM; 1361 } 1362 1363 if (err) { 1364 pr_debug("Error building start adminsp session command.\n"); 1365 return err; 1366 } 1367 1368 return finalize_and_send(dev, start_opal_session_cont); 1369 } 1370 1371 static int start_anybodyASP_opal_session(struct opal_dev *dev, void *data) 1372 { 1373 return start_generic_opal_session(dev, OPAL_ANYBODY_UID, 1374 OPAL_ADMINSP_UID, NULL, 0); 1375 } 1376 1377 static int start_SIDASP_opal_session(struct opal_dev *dev, void *data) 1378 { 1379 int ret; 1380 const u8 *key = dev->prev_data; 1381 1382 if (!key) { 1383 const struct opal_key *okey = data; 1384 1385 ret = start_generic_opal_session(dev, OPAL_SID_UID, 1386 OPAL_ADMINSP_UID, 1387 okey->key, 1388 okey->key_len); 1389 } else { 1390 ret = start_generic_opal_session(dev, OPAL_SID_UID, 1391 OPAL_ADMINSP_UID, 1392 key, dev->prev_d_len); 1393 kfree(key); 1394 dev->prev_data = NULL; 1395 } 1396 return ret; 1397 } 1398 1399 static int start_admin1LSP_opal_session(struct opal_dev *dev, void *data) 1400 { 1401 struct opal_key *key = data; 1402 1403 return start_generic_opal_session(dev, OPAL_ADMIN1_UID, 1404 OPAL_LOCKINGSP_UID, 1405 key->key, key->key_len); 1406 } 1407 1408 static int start_PSID_opal_session(struct opal_dev *dev, void *data) 1409 { 1410 const struct opal_key *okey = data; 1411 1412 return start_generic_opal_session(dev, OPAL_PSID_UID, 1413 OPAL_ADMINSP_UID, 1414 okey->key, 1415 okey->key_len); 1416 } 1417 1418 static int start_auth_opal_session(struct opal_dev *dev, void *data) 1419 { 1420 struct opal_session_info *session = data; 1421 u8 lk_ul_user[OPAL_UID_LENGTH]; 1422 size_t keylen = session->opal_key.key_len; 1423 int err = 0; 1424 1425 u8 *key = session->opal_key.key; 1426 u32 hsn = GENERIC_HOST_SESSION_NUM; 1427 1428 if (session->sum) 1429 err = build_locking_user(lk_ul_user, sizeof(lk_ul_user), 1430 session->opal_key.lr); 1431 else if (session->who != OPAL_ADMIN1 && !session->sum) 1432 err = build_locking_user(lk_ul_user, sizeof(lk_ul_user), 1433 session->who - 1); 1434 else 1435 memcpy(lk_ul_user, opaluid[OPAL_ADMIN1_UID], OPAL_UID_LENGTH); 1436 1437 if (err) 1438 return err; 1439 1440 err = cmd_start(dev, opaluid[OPAL_SMUID_UID], 1441 opalmethod[OPAL_STARTSESSION]); 1442 1443 add_token_u64(&err, dev, hsn); 1444 add_token_bytestring(&err, dev, opaluid[OPAL_LOCKINGSP_UID], 1445 OPAL_UID_LENGTH); 1446 add_token_u8(&err, dev, 1); 1447 add_token_u8(&err, dev, OPAL_STARTNAME); 1448 add_token_u8(&err, dev, 0); 1449 add_token_bytestring(&err, dev, key, keylen); 1450 add_token_u8(&err, dev, OPAL_ENDNAME); 1451 add_token_u8(&err, dev, OPAL_STARTNAME); 1452 add_token_u8(&err, dev, 3); 1453 add_token_bytestring(&err, dev, lk_ul_user, OPAL_UID_LENGTH); 1454 add_token_u8(&err, dev, OPAL_ENDNAME); 1455 1456 if (err) { 1457 pr_debug("Error building STARTSESSION command.\n"); 1458 return err; 1459 } 1460 1461 return finalize_and_send(dev, start_opal_session_cont); 1462 } 1463 1464 static int revert_tper(struct opal_dev *dev, void *data) 1465 { 1466 int err; 1467 1468 err = cmd_start(dev, opaluid[OPAL_ADMINSP_UID], 1469 opalmethod[OPAL_REVERT]); 1470 if (err) { 1471 pr_debug("Error building REVERT TPER command.\n"); 1472 return err; 1473 } 1474 1475 return finalize_and_send(dev, parse_and_check_status); 1476 } 1477 1478 static int internal_activate_user(struct opal_dev *dev, void *data) 1479 { 1480 struct opal_session_info *session = data; 1481 u8 uid[OPAL_UID_LENGTH]; 1482 int err; 1483 1484 memcpy(uid, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH); 1485 uid[7] = session->who; 1486 1487 err = cmd_start(dev, uid, opalmethod[OPAL_SET]); 1488 add_token_u8(&err, dev, OPAL_STARTNAME); 1489 add_token_u8(&err, dev, OPAL_VALUES); 1490 add_token_u8(&err, dev, OPAL_STARTLIST); 1491 add_token_u8(&err, dev, OPAL_STARTNAME); 1492 add_token_u8(&err, dev, 5); /* Enabled */ 1493 add_token_u8(&err, dev, OPAL_TRUE); 1494 add_token_u8(&err, dev, OPAL_ENDNAME); 1495 add_token_u8(&err, dev, OPAL_ENDLIST); 1496 add_token_u8(&err, dev, OPAL_ENDNAME); 1497 1498 if (err) { 1499 pr_debug("Error building Activate UserN command.\n"); 1500 return err; 1501 } 1502 1503 return finalize_and_send(dev, parse_and_check_status); 1504 } 1505 1506 static int erase_locking_range(struct opal_dev *dev, void *data) 1507 { 1508 struct opal_session_info *session = data; 1509 u8 uid[OPAL_UID_LENGTH]; 1510 int err; 1511 1512 if (build_locking_range(uid, sizeof(uid), session->opal_key.lr) < 0) 1513 return -ERANGE; 1514 1515 err = cmd_start(dev, uid, opalmethod[OPAL_ERASE]); 1516 1517 if (err) { 1518 pr_debug("Error building Erase Locking Range Command.\n"); 1519 return err; 1520 } 1521 return finalize_and_send(dev, parse_and_check_status); 1522 } 1523 1524 static int set_mbr_done(struct opal_dev *dev, void *data) 1525 { 1526 u8 *mbr_done_tf = data; 1527 int err; 1528 1529 err = cmd_start(dev, opaluid[OPAL_MBRCONTROL], 1530 opalmethod[OPAL_SET]); 1531 1532 add_token_u8(&err, dev, OPAL_STARTNAME); 1533 add_token_u8(&err, dev, OPAL_VALUES); 1534 add_token_u8(&err, dev, OPAL_STARTLIST); 1535 add_token_u8(&err, dev, OPAL_STARTNAME); 1536 add_token_u8(&err, dev, OPAL_MBRDONE); 1537 add_token_u8(&err, dev, *mbr_done_tf); /* Done T or F */ 1538 add_token_u8(&err, dev, OPAL_ENDNAME); 1539 add_token_u8(&err, dev, OPAL_ENDLIST); 1540 add_token_u8(&err, dev, OPAL_ENDNAME); 1541 1542 if (err) { 1543 pr_debug("Error Building set MBR Done command\n"); 1544 return err; 1545 } 1546 1547 return finalize_and_send(dev, parse_and_check_status); 1548 } 1549 1550 static int set_mbr_enable_disable(struct opal_dev *dev, void *data) 1551 { 1552 u8 *mbr_en_dis = data; 1553 int err; 1554 1555 err = cmd_start(dev, opaluid[OPAL_MBRCONTROL], 1556 opalmethod[OPAL_SET]); 1557 1558 add_token_u8(&err, dev, OPAL_STARTNAME); 1559 add_token_u8(&err, dev, OPAL_VALUES); 1560 add_token_u8(&err, dev, OPAL_STARTLIST); 1561 add_token_u8(&err, dev, OPAL_STARTNAME); 1562 add_token_u8(&err, dev, OPAL_MBRENABLE); 1563 add_token_u8(&err, dev, *mbr_en_dis); 1564 add_token_u8(&err, dev, OPAL_ENDNAME); 1565 add_token_u8(&err, dev, OPAL_ENDLIST); 1566 add_token_u8(&err, dev, OPAL_ENDNAME); 1567 1568 if (err) { 1569 pr_debug("Error Building set MBR done command\n"); 1570 return err; 1571 } 1572 1573 return finalize_and_send(dev, parse_and_check_status); 1574 } 1575 1576 static int write_shadow_mbr(struct opal_dev *dev, void *data) 1577 { 1578 struct opal_shadow_mbr *shadow = data; 1579 const u8 __user *src; 1580 u8 *dst; 1581 size_t off = 0; 1582 u64 len; 1583 int err = 0; 1584 1585 /* do we fit in the available shadow mbr space? */ 1586 err = generic_get_table_info(dev, OPAL_MBR, OPAL_TABLE_ROWS); 1587 if (err) { 1588 pr_debug("MBR: could not get shadow size\n"); 1589 return err; 1590 } 1591 1592 len = response_get_u64(&dev->parsed, 4); 1593 if (shadow->size > len || shadow->offset > len - shadow->size) { 1594 pr_debug("MBR: does not fit in shadow (%llu vs. %llu)\n", 1595 shadow->offset + shadow->size, len); 1596 return -ENOSPC; 1597 } 1598 1599 /* do the actual transmission(s) */ 1600 src = (u8 __user *)(uintptr_t)shadow->data; 1601 while (off < shadow->size) { 1602 err = cmd_start(dev, opaluid[OPAL_MBR], opalmethod[OPAL_SET]); 1603 add_token_u8(&err, dev, OPAL_STARTNAME); 1604 add_token_u8(&err, dev, OPAL_WHERE); 1605 add_token_u64(&err, dev, shadow->offset + off); 1606 add_token_u8(&err, dev, OPAL_ENDNAME); 1607 1608 add_token_u8(&err, dev, OPAL_STARTNAME); 1609 add_token_u8(&err, dev, OPAL_VALUES); 1610 1611 /* 1612 * The bytestring header is either 1 or 2 bytes, so assume 2. 1613 * There also needs to be enough space to accommodate the 1614 * trailing OPAL_ENDNAME (1 byte) and tokens added by 1615 * cmd_finalize. 1616 */ 1617 len = min(remaining_size(dev) - (2+1+CMD_FINALIZE_BYTES_NEEDED), 1618 (size_t)(shadow->size - off)); 1619 pr_debug("MBR: write bytes %zu+%llu/%llu\n", 1620 off, len, shadow->size); 1621 1622 dst = add_bytestring_header(&err, dev, len); 1623 if (!dst) 1624 break; 1625 if (copy_from_user(dst, src + off, len)) 1626 err = -EFAULT; 1627 dev->pos += len; 1628 1629 add_token_u8(&err, dev, OPAL_ENDNAME); 1630 if (err) 1631 break; 1632 1633 err = finalize_and_send(dev, parse_and_check_status); 1634 if (err) 1635 break; 1636 1637 off += len; 1638 } 1639 return err; 1640 } 1641 1642 static int generic_pw_cmd(u8 *key, size_t key_len, u8 *cpin_uid, 1643 struct opal_dev *dev) 1644 { 1645 int err; 1646 1647 err = cmd_start(dev, cpin_uid, opalmethod[OPAL_SET]); 1648 1649 add_token_u8(&err, dev, OPAL_STARTNAME); 1650 add_token_u8(&err, dev, OPAL_VALUES); 1651 add_token_u8(&err, dev, OPAL_STARTLIST); 1652 add_token_u8(&err, dev, OPAL_STARTNAME); 1653 add_token_u8(&err, dev, OPAL_PIN); 1654 add_token_bytestring(&err, dev, key, key_len); 1655 add_token_u8(&err, dev, OPAL_ENDNAME); 1656 add_token_u8(&err, dev, OPAL_ENDLIST); 1657 add_token_u8(&err, dev, OPAL_ENDNAME); 1658 1659 return err; 1660 } 1661 1662 static int set_new_pw(struct opal_dev *dev, void *data) 1663 { 1664 u8 cpin_uid[OPAL_UID_LENGTH]; 1665 struct opal_session_info *usr = data; 1666 1667 memcpy(cpin_uid, opaluid[OPAL_C_PIN_ADMIN1], OPAL_UID_LENGTH); 1668 1669 if (usr->who != OPAL_ADMIN1) { 1670 cpin_uid[5] = 0x03; 1671 if (usr->sum) 1672 cpin_uid[7] = usr->opal_key.lr + 1; 1673 else 1674 cpin_uid[7] = usr->who; 1675 } 1676 1677 if (generic_pw_cmd(usr->opal_key.key, usr->opal_key.key_len, 1678 cpin_uid, dev)) { 1679 pr_debug("Error building set password command.\n"); 1680 return -ERANGE; 1681 } 1682 1683 return finalize_and_send(dev, parse_and_check_status); 1684 } 1685 1686 static int set_sid_cpin_pin(struct opal_dev *dev, void *data) 1687 { 1688 u8 cpin_uid[OPAL_UID_LENGTH]; 1689 struct opal_key *key = data; 1690 1691 memcpy(cpin_uid, opaluid[OPAL_C_PIN_SID], OPAL_UID_LENGTH); 1692 1693 if (generic_pw_cmd(key->key, key->key_len, cpin_uid, dev)) { 1694 pr_debug("Error building Set SID cpin\n"); 1695 return -ERANGE; 1696 } 1697 return finalize_and_send(dev, parse_and_check_status); 1698 } 1699 1700 static int add_user_to_lr(struct opal_dev *dev, void *data) 1701 { 1702 u8 lr_buffer[OPAL_UID_LENGTH]; 1703 u8 user_uid[OPAL_UID_LENGTH]; 1704 struct opal_lock_unlock *lkul = data; 1705 int err; 1706 1707 memcpy(lr_buffer, opaluid[OPAL_LOCKINGRANGE_ACE_RDLOCKED], 1708 OPAL_UID_LENGTH); 1709 1710 if (lkul->l_state == OPAL_RW) 1711 memcpy(lr_buffer, opaluid[OPAL_LOCKINGRANGE_ACE_WRLOCKED], 1712 OPAL_UID_LENGTH); 1713 1714 lr_buffer[7] = lkul->session.opal_key.lr; 1715 1716 memcpy(user_uid, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH); 1717 1718 user_uid[7] = lkul->session.who; 1719 1720 err = cmd_start(dev, lr_buffer, opalmethod[OPAL_SET]); 1721 1722 add_token_u8(&err, dev, OPAL_STARTNAME); 1723 add_token_u8(&err, dev, OPAL_VALUES); 1724 1725 add_token_u8(&err, dev, OPAL_STARTLIST); 1726 add_token_u8(&err, dev, OPAL_STARTNAME); 1727 add_token_u8(&err, dev, 3); 1728 1729 add_token_u8(&err, dev, OPAL_STARTLIST); 1730 1731 1732 add_token_u8(&err, dev, OPAL_STARTNAME); 1733 add_token_bytestring(&err, dev, 1734 opaluid[OPAL_HALF_UID_AUTHORITY_OBJ_REF], 1735 OPAL_UID_LENGTH/2); 1736 add_token_bytestring(&err, dev, user_uid, OPAL_UID_LENGTH); 1737 add_token_u8(&err, dev, OPAL_ENDNAME); 1738 1739 1740 add_token_u8(&err, dev, OPAL_STARTNAME); 1741 add_token_bytestring(&err, dev, 1742 opaluid[OPAL_HALF_UID_AUTHORITY_OBJ_REF], 1743 OPAL_UID_LENGTH/2); 1744 add_token_bytestring(&err, dev, user_uid, OPAL_UID_LENGTH); 1745 add_token_u8(&err, dev, OPAL_ENDNAME); 1746 1747 1748 add_token_u8(&err, dev, OPAL_STARTNAME); 1749 add_token_bytestring(&err, dev, opaluid[OPAL_HALF_UID_BOOLEAN_ACE], 1750 OPAL_UID_LENGTH/2); 1751 add_token_u8(&err, dev, 1); 1752 add_token_u8(&err, dev, OPAL_ENDNAME); 1753 1754 1755 add_token_u8(&err, dev, OPAL_ENDLIST); 1756 add_token_u8(&err, dev, OPAL_ENDNAME); 1757 add_token_u8(&err, dev, OPAL_ENDLIST); 1758 add_token_u8(&err, dev, OPAL_ENDNAME); 1759 1760 if (err) { 1761 pr_debug("Error building add user to locking range command.\n"); 1762 return err; 1763 } 1764 1765 return finalize_and_send(dev, parse_and_check_status); 1766 } 1767 1768 static int lock_unlock_locking_range(struct opal_dev *dev, void *data) 1769 { 1770 u8 lr_buffer[OPAL_UID_LENGTH]; 1771 struct opal_lock_unlock *lkul = data; 1772 u8 read_locked = 1, write_locked = 1; 1773 int err = 0; 1774 1775 if (build_locking_range(lr_buffer, sizeof(lr_buffer), 1776 lkul->session.opal_key.lr) < 0) 1777 return -ERANGE; 1778 1779 switch (lkul->l_state) { 1780 case OPAL_RO: 1781 read_locked = 0; 1782 write_locked = 1; 1783 break; 1784 case OPAL_RW: 1785 read_locked = 0; 1786 write_locked = 0; 1787 break; 1788 case OPAL_LK: 1789 /* vars are initialized to locked */ 1790 break; 1791 default: 1792 pr_debug("Tried to set an invalid locking state... returning to uland\n"); 1793 return OPAL_INVAL_PARAM; 1794 } 1795 1796 err = cmd_start(dev, lr_buffer, opalmethod[OPAL_SET]); 1797 1798 add_token_u8(&err, dev, OPAL_STARTNAME); 1799 add_token_u8(&err, dev, OPAL_VALUES); 1800 add_token_u8(&err, dev, OPAL_STARTLIST); 1801 1802 add_token_u8(&err, dev, OPAL_STARTNAME); 1803 add_token_u8(&err, dev, OPAL_READLOCKED); 1804 add_token_u8(&err, dev, read_locked); 1805 add_token_u8(&err, dev, OPAL_ENDNAME); 1806 1807 add_token_u8(&err, dev, OPAL_STARTNAME); 1808 add_token_u8(&err, dev, OPAL_WRITELOCKED); 1809 add_token_u8(&err, dev, write_locked); 1810 add_token_u8(&err, dev, OPAL_ENDNAME); 1811 1812 add_token_u8(&err, dev, OPAL_ENDLIST); 1813 add_token_u8(&err, dev, OPAL_ENDNAME); 1814 1815 if (err) { 1816 pr_debug("Error building SET command.\n"); 1817 return err; 1818 } 1819 return finalize_and_send(dev, parse_and_check_status); 1820 } 1821 1822 1823 static int lock_unlock_locking_range_sum(struct opal_dev *dev, void *data) 1824 { 1825 u8 lr_buffer[OPAL_UID_LENGTH]; 1826 u8 read_locked = 1, write_locked = 1; 1827 struct opal_lock_unlock *lkul = data; 1828 int ret; 1829 1830 clear_opal_cmd(dev); 1831 set_comid(dev, dev->comid); 1832 1833 if (build_locking_range(lr_buffer, sizeof(lr_buffer), 1834 lkul->session.opal_key.lr) < 0) 1835 return -ERANGE; 1836 1837 switch (lkul->l_state) { 1838 case OPAL_RO: 1839 read_locked = 0; 1840 write_locked = 1; 1841 break; 1842 case OPAL_RW: 1843 read_locked = 0; 1844 write_locked = 0; 1845 break; 1846 case OPAL_LK: 1847 /* vars are initialized to locked */ 1848 break; 1849 default: 1850 pr_debug("Tried to set an invalid locking state.\n"); 1851 return OPAL_INVAL_PARAM; 1852 } 1853 ret = generic_lr_enable_disable(dev, lr_buffer, 1, 1, 1854 read_locked, write_locked); 1855 1856 if (ret < 0) { 1857 pr_debug("Error building SET command.\n"); 1858 return ret; 1859 } 1860 return finalize_and_send(dev, parse_and_check_status); 1861 } 1862 1863 static int activate_lsp(struct opal_dev *dev, void *data) 1864 { 1865 struct opal_lr_act *opal_act = data; 1866 u8 user_lr[OPAL_UID_LENGTH]; 1867 u8 uint_3 = 0x83; 1868 int err, i; 1869 1870 err = cmd_start(dev, opaluid[OPAL_LOCKINGSP_UID], 1871 opalmethod[OPAL_ACTIVATE]); 1872 1873 if (opal_act->sum) { 1874 err = build_locking_range(user_lr, sizeof(user_lr), 1875 opal_act->lr[0]); 1876 if (err) 1877 return err; 1878 1879 add_token_u8(&err, dev, OPAL_STARTNAME); 1880 add_token_u8(&err, dev, uint_3); 1881 add_token_u8(&err, dev, 6); 1882 add_token_u8(&err, dev, 0); 1883 add_token_u8(&err, dev, 0); 1884 1885 add_token_u8(&err, dev, OPAL_STARTLIST); 1886 add_token_bytestring(&err, dev, user_lr, OPAL_UID_LENGTH); 1887 for (i = 1; i < opal_act->num_lrs; i++) { 1888 user_lr[7] = opal_act->lr[i]; 1889 add_token_bytestring(&err, dev, user_lr, OPAL_UID_LENGTH); 1890 } 1891 add_token_u8(&err, dev, OPAL_ENDLIST); 1892 add_token_u8(&err, dev, OPAL_ENDNAME); 1893 } 1894 1895 if (err) { 1896 pr_debug("Error building Activate LockingSP command.\n"); 1897 return err; 1898 } 1899 1900 return finalize_and_send(dev, parse_and_check_status); 1901 } 1902 1903 /* Determine if we're in the Manufactured Inactive or Active state */ 1904 static int get_lsp_lifecycle(struct opal_dev *dev, void *data) 1905 { 1906 u8 lc_status; 1907 int err; 1908 1909 err = generic_get_column(dev, opaluid[OPAL_LOCKINGSP_UID], 1910 OPAL_LIFECYCLE); 1911 if (err) 1912 return err; 1913 1914 lc_status = response_get_u64(&dev->parsed, 4); 1915 /* 0x08 is Manufactured Inactive */ 1916 /* 0x09 is Manufactured */ 1917 if (lc_status != OPAL_MANUFACTURED_INACTIVE) { 1918 pr_debug("Couldn't determine the status of the Lifecycle state\n"); 1919 return -ENODEV; 1920 } 1921 1922 return 0; 1923 } 1924 1925 static int get_msid_cpin_pin(struct opal_dev *dev, void *data) 1926 { 1927 const char *msid_pin; 1928 size_t strlen; 1929 int err; 1930 1931 err = generic_get_column(dev, opaluid[OPAL_C_PIN_MSID], OPAL_PIN); 1932 if (err) 1933 return err; 1934 1935 strlen = response_get_string(&dev->parsed, 4, &msid_pin); 1936 if (!msid_pin) { 1937 pr_debug("Couldn't extract MSID_CPIN from response\n"); 1938 return OPAL_INVAL_PARAM; 1939 } 1940 1941 dev->prev_data = kmemdup(msid_pin, strlen, GFP_KERNEL); 1942 if (!dev->prev_data) 1943 return -ENOMEM; 1944 1945 dev->prev_d_len = strlen; 1946 1947 return 0; 1948 } 1949 1950 static int end_opal_session(struct opal_dev *dev, void *data) 1951 { 1952 int err = 0; 1953 1954 clear_opal_cmd(dev); 1955 set_comid(dev, dev->comid); 1956 add_token_u8(&err, dev, OPAL_ENDOFSESSION); 1957 1958 if (err < 0) 1959 return err; 1960 return finalize_and_send(dev, end_session_cont); 1961 } 1962 1963 static int end_opal_session_error(struct opal_dev *dev) 1964 { 1965 const struct opal_step error_end_session = { 1966 end_opal_session, 1967 }; 1968 return execute_step(dev, &error_end_session, 0); 1969 } 1970 1971 static inline void setup_opal_dev(struct opal_dev *dev) 1972 { 1973 dev->tsn = 0; 1974 dev->hsn = 0; 1975 dev->prev_data = NULL; 1976 } 1977 1978 static int check_opal_support(struct opal_dev *dev) 1979 { 1980 int ret; 1981 1982 mutex_lock(&dev->dev_lock); 1983 setup_opal_dev(dev); 1984 ret = opal_discovery0_step(dev); 1985 dev->supported = !ret; 1986 mutex_unlock(&dev->dev_lock); 1987 return ret; 1988 } 1989 1990 static void clean_opal_dev(struct opal_dev *dev) 1991 { 1992 1993 struct opal_suspend_data *suspend, *next; 1994 1995 mutex_lock(&dev->dev_lock); 1996 list_for_each_entry_safe(suspend, next, &dev->unlk_lst, node) { 1997 list_del(&suspend->node); 1998 kfree(suspend); 1999 } 2000 mutex_unlock(&dev->dev_lock); 2001 } 2002 2003 void free_opal_dev(struct opal_dev *dev) 2004 { 2005 if (!dev) 2006 return; 2007 clean_opal_dev(dev); 2008 kfree(dev); 2009 } 2010 EXPORT_SYMBOL(free_opal_dev); 2011 2012 struct opal_dev *init_opal_dev(void *data, sec_send_recv *send_recv) 2013 { 2014 struct opal_dev *dev; 2015 2016 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 2017 if (!dev) 2018 return NULL; 2019 2020 INIT_LIST_HEAD(&dev->unlk_lst); 2021 mutex_init(&dev->dev_lock); 2022 dev->data = data; 2023 dev->send_recv = send_recv; 2024 if (check_opal_support(dev) != 0) { 2025 pr_debug("Opal is not supported on this device\n"); 2026 kfree(dev); 2027 return NULL; 2028 } 2029 return dev; 2030 } 2031 EXPORT_SYMBOL(init_opal_dev); 2032 2033 static int opal_secure_erase_locking_range(struct opal_dev *dev, 2034 struct opal_session_info *opal_session) 2035 { 2036 const struct opal_step erase_steps[] = { 2037 { start_auth_opal_session, opal_session }, 2038 { get_active_key, &opal_session->opal_key.lr }, 2039 { gen_key, }, 2040 { end_opal_session, } 2041 }; 2042 int ret; 2043 2044 mutex_lock(&dev->dev_lock); 2045 setup_opal_dev(dev); 2046 ret = execute_steps(dev, erase_steps, ARRAY_SIZE(erase_steps)); 2047 mutex_unlock(&dev->dev_lock); 2048 return ret; 2049 } 2050 2051 static int opal_erase_locking_range(struct opal_dev *dev, 2052 struct opal_session_info *opal_session) 2053 { 2054 const struct opal_step erase_steps[] = { 2055 { start_auth_opal_session, opal_session }, 2056 { erase_locking_range, opal_session }, 2057 { end_opal_session, } 2058 }; 2059 int ret; 2060 2061 mutex_lock(&dev->dev_lock); 2062 setup_opal_dev(dev); 2063 ret = execute_steps(dev, erase_steps, ARRAY_SIZE(erase_steps)); 2064 mutex_unlock(&dev->dev_lock); 2065 return ret; 2066 } 2067 2068 static int opal_enable_disable_shadow_mbr(struct opal_dev *dev, 2069 struct opal_mbr_data *opal_mbr) 2070 { 2071 u8 enable_disable = opal_mbr->enable_disable == OPAL_MBR_ENABLE ? 2072 OPAL_TRUE : OPAL_FALSE; 2073 2074 const struct opal_step mbr_steps[] = { 2075 { start_admin1LSP_opal_session, &opal_mbr->key }, 2076 { set_mbr_done, &enable_disable }, 2077 { end_opal_session, }, 2078 { start_admin1LSP_opal_session, &opal_mbr->key }, 2079 { set_mbr_enable_disable, &enable_disable }, 2080 { end_opal_session, } 2081 }; 2082 int ret; 2083 2084 if (opal_mbr->enable_disable != OPAL_MBR_ENABLE && 2085 opal_mbr->enable_disable != OPAL_MBR_DISABLE) 2086 return -EINVAL; 2087 2088 mutex_lock(&dev->dev_lock); 2089 setup_opal_dev(dev); 2090 ret = execute_steps(dev, mbr_steps, ARRAY_SIZE(mbr_steps)); 2091 mutex_unlock(&dev->dev_lock); 2092 return ret; 2093 } 2094 2095 static int opal_set_mbr_done(struct opal_dev *dev, 2096 struct opal_mbr_done *mbr_done) 2097 { 2098 u8 mbr_done_tf = mbr_done->done_flag == OPAL_MBR_DONE ? 2099 OPAL_TRUE : OPAL_FALSE; 2100 2101 const struct opal_step mbr_steps[] = { 2102 { start_admin1LSP_opal_session, &mbr_done->key }, 2103 { set_mbr_done, &mbr_done_tf }, 2104 { end_opal_session, } 2105 }; 2106 int ret; 2107 2108 if (mbr_done->done_flag != OPAL_MBR_DONE && 2109 mbr_done->done_flag != OPAL_MBR_NOT_DONE) 2110 return -EINVAL; 2111 2112 mutex_lock(&dev->dev_lock); 2113 setup_opal_dev(dev); 2114 ret = execute_steps(dev, mbr_steps, ARRAY_SIZE(mbr_steps)); 2115 mutex_unlock(&dev->dev_lock); 2116 return ret; 2117 } 2118 2119 static int opal_write_shadow_mbr(struct opal_dev *dev, 2120 struct opal_shadow_mbr *info) 2121 { 2122 const struct opal_step mbr_steps[] = { 2123 { start_admin1LSP_opal_session, &info->key }, 2124 { write_shadow_mbr, info }, 2125 { end_opal_session, } 2126 }; 2127 int ret; 2128 2129 if (info->size == 0) 2130 return 0; 2131 2132 mutex_lock(&dev->dev_lock); 2133 setup_opal_dev(dev); 2134 ret = execute_steps(dev, mbr_steps, ARRAY_SIZE(mbr_steps)); 2135 mutex_unlock(&dev->dev_lock); 2136 return ret; 2137 } 2138 2139 static int opal_save(struct opal_dev *dev, struct opal_lock_unlock *lk_unlk) 2140 { 2141 struct opal_suspend_data *suspend; 2142 2143 suspend = kzalloc(sizeof(*suspend), GFP_KERNEL); 2144 if (!suspend) 2145 return -ENOMEM; 2146 2147 suspend->unlk = *lk_unlk; 2148 suspend->lr = lk_unlk->session.opal_key.lr; 2149 2150 mutex_lock(&dev->dev_lock); 2151 setup_opal_dev(dev); 2152 add_suspend_info(dev, suspend); 2153 mutex_unlock(&dev->dev_lock); 2154 return 0; 2155 } 2156 2157 static int opal_add_user_to_lr(struct opal_dev *dev, 2158 struct opal_lock_unlock *lk_unlk) 2159 { 2160 const struct opal_step steps[] = { 2161 { start_admin1LSP_opal_session, &lk_unlk->session.opal_key }, 2162 { add_user_to_lr, lk_unlk }, 2163 { end_opal_session, } 2164 }; 2165 int ret; 2166 2167 if (lk_unlk->l_state != OPAL_RO && 2168 lk_unlk->l_state != OPAL_RW) { 2169 pr_debug("Locking state was not RO or RW\n"); 2170 return -EINVAL; 2171 } 2172 if (lk_unlk->session.who < OPAL_USER1 || 2173 lk_unlk->session.who > OPAL_USER9) { 2174 pr_debug("Authority was not within the range of users: %d\n", 2175 lk_unlk->session.who); 2176 return -EINVAL; 2177 } 2178 if (lk_unlk->session.sum) { 2179 pr_debug("%s not supported in sum. Use setup locking range\n", 2180 __func__); 2181 return -EINVAL; 2182 } 2183 2184 mutex_lock(&dev->dev_lock); 2185 setup_opal_dev(dev); 2186 ret = execute_steps(dev, steps, ARRAY_SIZE(steps)); 2187 mutex_unlock(&dev->dev_lock); 2188 return ret; 2189 } 2190 2191 static int opal_reverttper(struct opal_dev *dev, struct opal_key *opal, bool psid) 2192 { 2193 /* controller will terminate session */ 2194 const struct opal_step revert_steps[] = { 2195 { start_SIDASP_opal_session, opal }, 2196 { revert_tper, } 2197 }; 2198 const struct opal_step psid_revert_steps[] = { 2199 { start_PSID_opal_session, opal }, 2200 { revert_tper, } 2201 }; 2202 2203 int ret; 2204 2205 mutex_lock(&dev->dev_lock); 2206 setup_opal_dev(dev); 2207 if (psid) 2208 ret = execute_steps(dev, psid_revert_steps, 2209 ARRAY_SIZE(psid_revert_steps)); 2210 else 2211 ret = execute_steps(dev, revert_steps, 2212 ARRAY_SIZE(revert_steps)); 2213 mutex_unlock(&dev->dev_lock); 2214 2215 /* 2216 * If we successfully reverted lets clean 2217 * any saved locking ranges. 2218 */ 2219 if (!ret) 2220 clean_opal_dev(dev); 2221 2222 return ret; 2223 } 2224 2225 static int __opal_lock_unlock(struct opal_dev *dev, 2226 struct opal_lock_unlock *lk_unlk) 2227 { 2228 const struct opal_step unlock_steps[] = { 2229 { start_auth_opal_session, &lk_unlk->session }, 2230 { lock_unlock_locking_range, lk_unlk }, 2231 { end_opal_session, } 2232 }; 2233 const struct opal_step unlock_sum_steps[] = { 2234 { start_auth_opal_session, &lk_unlk->session }, 2235 { lock_unlock_locking_range_sum, lk_unlk }, 2236 { end_opal_session, } 2237 }; 2238 2239 if (lk_unlk->session.sum) 2240 return execute_steps(dev, unlock_sum_steps, 2241 ARRAY_SIZE(unlock_sum_steps)); 2242 else 2243 return execute_steps(dev, unlock_steps, 2244 ARRAY_SIZE(unlock_steps)); 2245 } 2246 2247 static int __opal_set_mbr_done(struct opal_dev *dev, struct opal_key *key) 2248 { 2249 u8 mbr_done_tf = OPAL_TRUE; 2250 const struct opal_step mbrdone_step[] = { 2251 { start_admin1LSP_opal_session, key }, 2252 { set_mbr_done, &mbr_done_tf }, 2253 { end_opal_session, } 2254 }; 2255 2256 return execute_steps(dev, mbrdone_step, ARRAY_SIZE(mbrdone_step)); 2257 } 2258 2259 static int opal_lock_unlock(struct opal_dev *dev, 2260 struct opal_lock_unlock *lk_unlk) 2261 { 2262 int ret; 2263 2264 if (lk_unlk->session.who > OPAL_USER9) 2265 return -EINVAL; 2266 2267 mutex_lock(&dev->dev_lock); 2268 ret = __opal_lock_unlock(dev, lk_unlk); 2269 mutex_unlock(&dev->dev_lock); 2270 return ret; 2271 } 2272 2273 static int opal_take_ownership(struct opal_dev *dev, struct opal_key *opal) 2274 { 2275 const struct opal_step owner_steps[] = { 2276 { start_anybodyASP_opal_session, }, 2277 { get_msid_cpin_pin, }, 2278 { end_opal_session, }, 2279 { start_SIDASP_opal_session, opal }, 2280 { set_sid_cpin_pin, opal }, 2281 { end_opal_session, } 2282 }; 2283 int ret; 2284 2285 if (!dev) 2286 return -ENODEV; 2287 2288 mutex_lock(&dev->dev_lock); 2289 setup_opal_dev(dev); 2290 ret = execute_steps(dev, owner_steps, ARRAY_SIZE(owner_steps)); 2291 mutex_unlock(&dev->dev_lock); 2292 return ret; 2293 } 2294 2295 static int opal_activate_lsp(struct opal_dev *dev, 2296 struct opal_lr_act *opal_lr_act) 2297 { 2298 const struct opal_step active_steps[] = { 2299 { start_SIDASP_opal_session, &opal_lr_act->key }, 2300 { get_lsp_lifecycle, }, 2301 { activate_lsp, opal_lr_act }, 2302 { end_opal_session, } 2303 }; 2304 int ret; 2305 2306 if (!opal_lr_act->num_lrs || opal_lr_act->num_lrs > OPAL_MAX_LRS) 2307 return -EINVAL; 2308 2309 mutex_lock(&dev->dev_lock); 2310 setup_opal_dev(dev); 2311 ret = execute_steps(dev, active_steps, ARRAY_SIZE(active_steps)); 2312 mutex_unlock(&dev->dev_lock); 2313 return ret; 2314 } 2315 2316 static int opal_setup_locking_range(struct opal_dev *dev, 2317 struct opal_user_lr_setup *opal_lrs) 2318 { 2319 const struct opal_step lr_steps[] = { 2320 { start_auth_opal_session, &opal_lrs->session }, 2321 { setup_locking_range, opal_lrs }, 2322 { end_opal_session, } 2323 }; 2324 int ret; 2325 2326 mutex_lock(&dev->dev_lock); 2327 setup_opal_dev(dev); 2328 ret = execute_steps(dev, lr_steps, ARRAY_SIZE(lr_steps)); 2329 mutex_unlock(&dev->dev_lock); 2330 return ret; 2331 } 2332 2333 static int opal_set_new_pw(struct opal_dev *dev, struct opal_new_pw *opal_pw) 2334 { 2335 const struct opal_step pw_steps[] = { 2336 { start_auth_opal_session, &opal_pw->session }, 2337 { set_new_pw, &opal_pw->new_user_pw }, 2338 { end_opal_session, } 2339 }; 2340 int ret; 2341 2342 if (opal_pw->session.who > OPAL_USER9 || 2343 opal_pw->new_user_pw.who > OPAL_USER9) 2344 return -EINVAL; 2345 2346 mutex_lock(&dev->dev_lock); 2347 setup_opal_dev(dev); 2348 ret = execute_steps(dev, pw_steps, ARRAY_SIZE(pw_steps)); 2349 mutex_unlock(&dev->dev_lock); 2350 return ret; 2351 } 2352 2353 static int opal_activate_user(struct opal_dev *dev, 2354 struct opal_session_info *opal_session) 2355 { 2356 const struct opal_step act_steps[] = { 2357 { start_admin1LSP_opal_session, &opal_session->opal_key }, 2358 { internal_activate_user, opal_session }, 2359 { end_opal_session, } 2360 }; 2361 int ret; 2362 2363 /* We can't activate Admin1 it's active as manufactured */ 2364 if (opal_session->who < OPAL_USER1 || 2365 opal_session->who > OPAL_USER9) { 2366 pr_debug("Who was not a valid user: %d\n", opal_session->who); 2367 return -EINVAL; 2368 } 2369 2370 mutex_lock(&dev->dev_lock); 2371 setup_opal_dev(dev); 2372 ret = execute_steps(dev, act_steps, ARRAY_SIZE(act_steps)); 2373 mutex_unlock(&dev->dev_lock); 2374 return ret; 2375 } 2376 2377 bool opal_unlock_from_suspend(struct opal_dev *dev) 2378 { 2379 struct opal_suspend_data *suspend; 2380 bool was_failure = false; 2381 int ret = 0; 2382 2383 if (!dev) 2384 return false; 2385 if (!dev->supported) 2386 return false; 2387 2388 mutex_lock(&dev->dev_lock); 2389 setup_opal_dev(dev); 2390 2391 list_for_each_entry(suspend, &dev->unlk_lst, node) { 2392 dev->tsn = 0; 2393 dev->hsn = 0; 2394 2395 ret = __opal_lock_unlock(dev, &suspend->unlk); 2396 if (ret) { 2397 pr_debug("Failed to unlock LR %hhu with sum %d\n", 2398 suspend->unlk.session.opal_key.lr, 2399 suspend->unlk.session.sum); 2400 was_failure = true; 2401 } 2402 if (dev->mbr_enabled) { 2403 ret = __opal_set_mbr_done(dev, &suspend->unlk.session.opal_key); 2404 if (ret) 2405 pr_debug("Failed to set MBR Done in S3 resume\n"); 2406 } 2407 } 2408 mutex_unlock(&dev->dev_lock); 2409 return was_failure; 2410 } 2411 EXPORT_SYMBOL(opal_unlock_from_suspend); 2412 2413 int sed_ioctl(struct opal_dev *dev, unsigned int cmd, void __user *arg) 2414 { 2415 void *p; 2416 int ret = -ENOTTY; 2417 2418 if (!capable(CAP_SYS_ADMIN)) 2419 return -EACCES; 2420 if (!dev) 2421 return -ENOTSUPP; 2422 if (!dev->supported) 2423 return -ENOTSUPP; 2424 2425 p = memdup_user(arg, _IOC_SIZE(cmd)); 2426 if (IS_ERR(p)) 2427 return PTR_ERR(p); 2428 2429 switch (cmd) { 2430 case IOC_OPAL_SAVE: 2431 ret = opal_save(dev, p); 2432 break; 2433 case IOC_OPAL_LOCK_UNLOCK: 2434 ret = opal_lock_unlock(dev, p); 2435 break; 2436 case IOC_OPAL_TAKE_OWNERSHIP: 2437 ret = opal_take_ownership(dev, p); 2438 break; 2439 case IOC_OPAL_ACTIVATE_LSP: 2440 ret = opal_activate_lsp(dev, p); 2441 break; 2442 case IOC_OPAL_SET_PW: 2443 ret = opal_set_new_pw(dev, p); 2444 break; 2445 case IOC_OPAL_ACTIVATE_USR: 2446 ret = opal_activate_user(dev, p); 2447 break; 2448 case IOC_OPAL_REVERT_TPR: 2449 ret = opal_reverttper(dev, p, false); 2450 break; 2451 case IOC_OPAL_LR_SETUP: 2452 ret = opal_setup_locking_range(dev, p); 2453 break; 2454 case IOC_OPAL_ADD_USR_TO_LR: 2455 ret = opal_add_user_to_lr(dev, p); 2456 break; 2457 case IOC_OPAL_ENABLE_DISABLE_MBR: 2458 ret = opal_enable_disable_shadow_mbr(dev, p); 2459 break; 2460 case IOC_OPAL_MBR_DONE: 2461 ret = opal_set_mbr_done(dev, p); 2462 break; 2463 case IOC_OPAL_WRITE_SHADOW_MBR: 2464 ret = opal_write_shadow_mbr(dev, p); 2465 break; 2466 case IOC_OPAL_ERASE_LR: 2467 ret = opal_erase_locking_range(dev, p); 2468 break; 2469 case IOC_OPAL_SECURE_ERASE_LR: 2470 ret = opal_secure_erase_locking_range(dev, p); 2471 break; 2472 case IOC_OPAL_PSID_REVERT_TPR: 2473 ret = opal_reverttper(dev, p, true); 2474 break; 2475 default: 2476 break; 2477 } 2478 2479 kfree(p); 2480 return ret; 2481 } 2482 EXPORT_SYMBOL_GPL(sed_ioctl); 2483