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