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