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