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