block/sed-opal.c

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