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