2 * Copyright © 2016 Intel Corporation
5 * Scott Bauer <scott.bauer@intel.com>
6 * Rafael Antognolli <rafael.antognolli@intel.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms and conditions of the GNU General Public License,
10 * version 2, as published by the Free Software Foundation.
12 * This program is distributed in the hope it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 #define pr_fmt(fmt) KBUILD_MODNAME ":OPAL: " fmt
20 #include <linux/delay.h>
21 #include <linux/device.h>
22 #include <linux/kernel.h>
23 #include <linux/list.h>
24 #include <linux/genhd.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <uapi/linux/sed-opal.h>
28 #include <linux/sed-opal.h>
29 #include <linux/string.h>
30 #include <linux/kdev_t.h>
32 #include "opal_proto.h"
34 #define IO_BUFFER_LENGTH 2048
38 int (*fn)(struct opal_dev *dev, void *data);
41 typedef int (cont_fn)(struct opal_dev *dev);
43 enum opal_atom_width {
52 * On the parsed response, we don't store again the toks that are already
53 * stored in the response buffer. Instead, for each token, we just store a
54 * pointer to the position in the buffer where the token starts, and the size
55 * of the token in bytes.
57 struct opal_resp_tok {
60 enum opal_response_token type;
61 enum opal_atom_width width;
69 * From the response header it's not possible to know how many tokens there are
70 * on the payload. So we hardcode that the maximum will be MAX_TOKS, and later
71 * if we start dealing with messages that have more than that, we can increase
72 * this number. This is done to avoid having to make two passes through the
73 * response, the first one counting how many tokens we have and the second one
74 * actually storing the positions.
78 struct opal_resp_tok toks[MAX_TOKS];
85 sec_send_recv *send_recv;
87 const struct opal_step *steps;
88 struct mutex dev_lock;
96 u8 cmd[IO_BUFFER_LENGTH];
97 u8 resp[IO_BUFFER_LENGTH];
99 struct parsed_resp parsed;
103 struct list_head unlk_lst;
107 static const u8 opaluid[][OPAL_UID_LENGTH] = {
110 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
112 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
114 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x01 },
115 [OPAL_LOCKINGSP_UID] =
116 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x02 },
117 [OPAL_ENTERPRISE_LOCKINGSP_UID] =
118 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x01, 0x00, 0x01 },
120 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01 },
122 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06 },
124 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x01 },
126 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x01 },
128 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x02 },
130 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0xff, 0x01 },
131 [OPAL_ENTERPRISE_BANDMASTER0_UID] =
132 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x80, 0x01 },
133 [OPAL_ENTERPRISE_ERASEMASTER_UID] =
134 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x84, 0x01 },
138 [OPAL_LOCKINGRANGE_GLOBAL] =
139 { 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 },
140 [OPAL_LOCKINGRANGE_ACE_RDLOCKED] =
141 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE0, 0x01 },
142 [OPAL_LOCKINGRANGE_ACE_WRLOCKED] =
143 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE8, 0x01 },
145 { 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x01 },
147 { 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00 },
148 [OPAL_AUTHORITY_TABLE] =
149 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00},
151 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00},
152 [OPAL_LOCKING_INFO_TABLE] =
153 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01 },
154 [OPAL_ENTERPRISE_LOCKING_INFO_TABLE] =
155 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00 },
157 /* C_PIN_TABLE object ID's */
160 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x84, 0x02},
162 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01},
163 [OPAL_C_PIN_ADMIN1] =
164 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x01},
166 /* half UID's (only first 4 bytes used) */
168 [OPAL_HALF_UID_AUTHORITY_OBJ_REF] =
169 { 0x00, 0x00, 0x0C, 0x05, 0xff, 0xff, 0xff, 0xff },
170 [OPAL_HALF_UID_BOOLEAN_ACE] =
171 { 0x00, 0x00, 0x04, 0x0E, 0xff, 0xff, 0xff, 0xff },
173 /* special value for omitted optional parameter */
175 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
179 * TCG Storage SSC Methods.
180 * Derived from: TCG_Storage_Architecture_Core_Spec_v2.01_r1.00
181 * Section: 6.3 Assigned UIDs
183 static const u8 opalmethod[][OPAL_UID_LENGTH] = {
185 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01 },
186 [OPAL_STARTSESSION] =
187 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x02 },
189 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x02 },
191 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x03 },
193 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06 },
195 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07 },
197 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08 },
198 [OPAL_EAUTHENTICATE] =
199 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c },
201 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d },
203 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10 },
205 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11 },
207 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16 },
209 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17 },
210 [OPAL_AUTHENTICATE] =
211 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1c },
213 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x01 },
215 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x08, 0x03 },
218 static int end_opal_session_error(struct opal_dev *dev);
220 struct opal_suspend_data {
221 struct opal_lock_unlock unlk;
223 struct list_head node;
228 * TCG_Storage_Architecture_Core_Spec_v2.01_r1.00
229 * Section: 5.1.5 Method Status Codes
231 static const char * const opal_errors[] = {
239 "No Sessions Available",
240 "Uniqueness Conflict",
241 "Insufficient Space",
248 "Transaction Failure",
250 "Authority Locked Out",
253 static const char *opal_error_to_human(int error)
258 if (error >= ARRAY_SIZE(opal_errors) || error < 0)
259 return "Unknown Error";
261 return opal_errors[error];
264 static void print_buffer(const u8 *ptr, u32 length)
267 print_hex_dump_bytes("OPAL: ", DUMP_PREFIX_OFFSET, ptr, length);
272 static bool check_tper(const void *data)
274 const struct d0_tper_features *tper = data;
275 u8 flags = tper->supported_features;
277 if (!(flags & TPER_SYNC_SUPPORTED)) {
278 pr_err("TPer sync not supported. flags = %d\n",
279 tper->supported_features);
286 static bool check_sum(const void *data)
288 const struct d0_single_user_mode *sum = data;
289 u32 nlo = be32_to_cpu(sum->num_locking_objects);
292 pr_err("Need at least one locking object.\n");
296 pr_debug("Number of locking objects: %d\n", nlo);
301 static u16 get_comid_v100(const void *data)
303 const struct d0_opal_v100 *v100 = data;
305 return be16_to_cpu(v100->baseComID);
308 static u16 get_comid_v200(const void *data)
310 const struct d0_opal_v200 *v200 = data;
312 return be16_to_cpu(v200->baseComID);
315 static int opal_send_cmd(struct opal_dev *dev)
317 return dev->send_recv(dev->data, dev->comid, TCG_SECP_01,
318 dev->cmd, IO_BUFFER_LENGTH,
322 static int opal_recv_cmd(struct opal_dev *dev)
324 return dev->send_recv(dev->data, dev->comid, TCG_SECP_01,
325 dev->resp, IO_BUFFER_LENGTH,
329 static int opal_recv_check(struct opal_dev *dev)
331 size_t buflen = IO_BUFFER_LENGTH;
332 void *buffer = dev->resp;
333 struct opal_header *hdr = buffer;
337 pr_debug("Sent OPAL command: outstanding=%d, minTransfer=%d\n",
338 hdr->cp.outstandingData,
339 hdr->cp.minTransfer);
341 if (hdr->cp.outstandingData == 0 ||
342 hdr->cp.minTransfer != 0)
345 memset(buffer, 0, buflen);
346 ret = opal_recv_cmd(dev);
352 static int opal_send_recv(struct opal_dev *dev, cont_fn *cont)
356 ret = opal_send_cmd(dev);
359 ret = opal_recv_cmd(dev);
362 ret = opal_recv_check(dev);
368 static void check_geometry(struct opal_dev *dev, const void *data)
370 const struct d0_geometry_features *geo = data;
372 dev->align = geo->alignment_granularity;
373 dev->lowest_lba = geo->lowest_aligned_lba;
376 static int next(struct opal_dev *dev)
378 const struct opal_step *step;
379 int state = 0, error = 0;
382 step = &dev->steps[state];
386 error = step->fn(dev, step->data);
388 pr_err("Error on step function: %d with error %d: %s\n",
390 opal_error_to_human(error));
392 /* For each OPAL command we do a discovery0 then we
393 * start some sort of session.
394 * If we haven't passed state 1 then there was an error
395 * on discovery0 or during the attempt to start a
396 * session. Therefore we shouldn't attempt to terminate
397 * a session, as one has not yet been created.
400 end_opal_session_error(dev);
411 static int opal_discovery0_end(struct opal_dev *dev)
413 bool found_com_id = false, supported = true, single_user = false;
414 const struct d0_header *hdr = (struct d0_header *)dev->resp;
415 const u8 *epos = dev->resp, *cpos = dev->resp;
417 u32 hlen = be32_to_cpu(hdr->length);
419 print_buffer(dev->resp, hlen);
421 if (hlen > IO_BUFFER_LENGTH - sizeof(*hdr)) {
422 pr_warn("Discovery length overflows buffer (%zu+%u)/%u\n",
423 sizeof(*hdr), hlen, IO_BUFFER_LENGTH);
427 epos += hlen; /* end of buffer */
428 cpos += sizeof(*hdr); /* current position on buffer */
430 while (cpos < epos && supported) {
431 const struct d0_features *body =
432 (const struct d0_features *)cpos;
434 switch (be16_to_cpu(body->code)) {
436 supported = check_tper(body->features);
439 single_user = check_sum(body->features);
442 check_geometry(dev, body);
447 /* some ignored properties */
448 pr_debug("Found OPAL feature description: %d\n",
449 be16_to_cpu(body->code));
452 comid = get_comid_v100(body->features);
456 comid = get_comid_v200(body->features);
459 case 0xbfff ... 0xffff:
460 /* vendor specific, just ignore */
463 pr_debug("OPAL Unknown feature: %d\n",
464 be16_to_cpu(body->code));
467 cpos += body->length + 4;
471 pr_debug("This device is not Opal enabled. Not Supported!\n");
476 pr_debug("Device doesn't support single user mode\n");
480 pr_debug("Could not find OPAL comid for device. Returning early\n");
489 static int opal_discovery0(struct opal_dev *dev, void *data)
493 memset(dev->resp, 0, IO_BUFFER_LENGTH);
494 dev->comid = OPAL_DISCOVERY_COMID;
495 ret = opal_recv_cmd(dev);
498 return opal_discovery0_end(dev);
501 static void add_token_u8(int *err, struct opal_dev *cmd, u8 tok)
505 if (cmd->pos >= IO_BUFFER_LENGTH - 1) {
506 pr_err("Error adding u8: end of buffer.\n");
510 cmd->cmd[cmd->pos++] = tok;
513 static void add_short_atom_header(struct opal_dev *cmd, bool bytestring,
514 bool has_sign, int len)
519 atom = SHORT_ATOM_ID;
520 atom |= bytestring ? SHORT_ATOM_BYTESTRING : 0;
521 atom |= has_sign ? SHORT_ATOM_SIGNED : 0;
522 atom |= len & SHORT_ATOM_LEN_MASK;
524 add_token_u8(&err, cmd, atom);
527 static void add_medium_atom_header(struct opal_dev *cmd, bool bytestring,
528 bool has_sign, int len)
532 header0 = MEDIUM_ATOM_ID;
533 header0 |= bytestring ? MEDIUM_ATOM_BYTESTRING : 0;
534 header0 |= has_sign ? MEDIUM_ATOM_SIGNED : 0;
535 header0 |= (len >> 8) & MEDIUM_ATOM_LEN_MASK;
536 cmd->cmd[cmd->pos++] = header0;
537 cmd->cmd[cmd->pos++] = len;
540 static void add_token_u64(int *err, struct opal_dev *cmd, u64 number)
547 if (!(number & ~TINY_ATOM_DATA_MASK)) {
548 add_token_u8(err, cmd, number);
553 len = DIV_ROUND_UP(msb, 4);
555 if (cmd->pos >= IO_BUFFER_LENGTH - len - 1) {
556 pr_err("Error adding u64: end of buffer.\n");
560 add_short_atom_header(cmd, false, false, len);
562 n = number >> (len * 8);
563 add_token_u8(err, cmd, n);
567 static void add_token_bytestring(int *err, struct opal_dev *cmd,
568 const u8 *bytestring, size_t len)
570 size_t header_len = 1;
571 bool is_short_atom = true;
576 if (len & ~SHORT_ATOM_LEN_MASK) {
578 is_short_atom = false;
581 if (len >= IO_BUFFER_LENGTH - cmd->pos - header_len) {
582 pr_err("Error adding bytestring: end of buffer.\n");
588 add_short_atom_header(cmd, true, false, len);
590 add_medium_atom_header(cmd, true, false, len);
592 memcpy(&cmd->cmd[cmd->pos], bytestring, len);
597 static int build_locking_range(u8 *buffer, size_t length, u8 lr)
599 if (length > OPAL_UID_LENGTH) {
600 pr_err("Can't build locking range. Length OOB\n");
604 memcpy(buffer, opaluid[OPAL_LOCKINGRANGE_GLOBAL], OPAL_UID_LENGTH);
608 buffer[5] = LOCKING_RANGE_NON_GLOBAL;
614 static int build_locking_user(u8 *buffer, size_t length, u8 lr)
616 if (length > OPAL_UID_LENGTH) {
617 pr_err("Can't build locking range user, Length OOB\n");
621 memcpy(buffer, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH);
628 static void set_comid(struct opal_dev *cmd, u16 comid)
630 struct opal_header *hdr = (struct opal_header *)cmd->cmd;
632 hdr->cp.extendedComID[0] = comid >> 8;
633 hdr->cp.extendedComID[1] = comid;
634 hdr->cp.extendedComID[2] = 0;
635 hdr->cp.extendedComID[3] = 0;
638 static int cmd_finalize(struct opal_dev *cmd, u32 hsn, u32 tsn)
640 struct opal_header *hdr;
643 add_token_u8(&err, cmd, OPAL_ENDOFDATA);
644 add_token_u8(&err, cmd, OPAL_STARTLIST);
645 add_token_u8(&err, cmd, 0);
646 add_token_u8(&err, cmd, 0);
647 add_token_u8(&err, cmd, 0);
648 add_token_u8(&err, cmd, OPAL_ENDLIST);
651 pr_err("Error finalizing command.\n");
655 hdr = (struct opal_header *) cmd->cmd;
657 hdr->pkt.tsn = cpu_to_be32(tsn);
658 hdr->pkt.hsn = cpu_to_be32(hsn);
660 hdr->subpkt.length = cpu_to_be32(cmd->pos - sizeof(*hdr));
661 while (cmd->pos % 4) {
662 if (cmd->pos >= IO_BUFFER_LENGTH) {
663 pr_err("Error: Buffer overrun\n");
666 cmd->cmd[cmd->pos++] = 0;
668 hdr->pkt.length = cpu_to_be32(cmd->pos - sizeof(hdr->cp) -
670 hdr->cp.length = cpu_to_be32(cmd->pos - sizeof(hdr->cp));
675 static const struct opal_resp_tok *response_get_token(
676 const struct parsed_resp *resp,
679 const struct opal_resp_tok *tok;
681 if (n >= resp->num) {
682 pr_err("Token number doesn't exist: %d, resp: %d\n",
684 return ERR_PTR(-EINVAL);
687 tok = &resp->toks[n];
689 pr_err("Token length must be non-zero\n");
690 return ERR_PTR(-EINVAL);
696 static ssize_t response_parse_tiny(struct opal_resp_tok *tok,
701 tok->width = OPAL_WIDTH_TINY;
703 if (pos[0] & TINY_ATOM_SIGNED) {
704 tok->type = OPAL_DTA_TOKENID_SINT;
706 tok->type = OPAL_DTA_TOKENID_UINT;
707 tok->stored.u = pos[0] & 0x3f;
713 static ssize_t response_parse_short(struct opal_resp_tok *tok,
717 tok->len = (pos[0] & SHORT_ATOM_LEN_MASK) + 1;
718 tok->width = OPAL_WIDTH_SHORT;
720 if (pos[0] & SHORT_ATOM_BYTESTRING) {
721 tok->type = OPAL_DTA_TOKENID_BYTESTRING;
722 } else if (pos[0] & SHORT_ATOM_SIGNED) {
723 tok->type = OPAL_DTA_TOKENID_SINT;
728 tok->type = OPAL_DTA_TOKENID_UINT;
730 pr_warn("uint64 with more than 8 bytes\n");
733 for (i = tok->len - 1; i > 0; i--) {
734 u_integer |= ((u64)pos[i] << (8 * b));
737 tok->stored.u = u_integer;
743 static ssize_t response_parse_medium(struct opal_resp_tok *tok,
747 tok->len = (((pos[0] & MEDIUM_ATOM_LEN_MASK) << 8) | pos[1]) + 2;
748 tok->width = OPAL_WIDTH_MEDIUM;
750 if (pos[0] & MEDIUM_ATOM_BYTESTRING)
751 tok->type = OPAL_DTA_TOKENID_BYTESTRING;
752 else if (pos[0] & MEDIUM_ATOM_SIGNED)
753 tok->type = OPAL_DTA_TOKENID_SINT;
755 tok->type = OPAL_DTA_TOKENID_UINT;
760 static ssize_t response_parse_long(struct opal_resp_tok *tok,
764 tok->len = ((pos[1] << 16) | (pos[2] << 8) | pos[3]) + 4;
765 tok->width = OPAL_WIDTH_LONG;
767 if (pos[0] & LONG_ATOM_BYTESTRING)
768 tok->type = OPAL_DTA_TOKENID_BYTESTRING;
769 else if (pos[0] & LONG_ATOM_SIGNED)
770 tok->type = OPAL_DTA_TOKENID_SINT;
772 tok->type = OPAL_DTA_TOKENID_UINT;
777 static ssize_t response_parse_token(struct opal_resp_tok *tok,
782 tok->type = OPAL_DTA_TOKENID_TOKEN;
783 tok->width = OPAL_WIDTH_TOKEN;
788 static int response_parse(const u8 *buf, size_t length,
789 struct parsed_resp *resp)
791 const struct opal_header *hdr;
792 struct opal_resp_tok *iter;
795 ssize_t token_length;
797 u32 clen, plen, slen;
805 hdr = (struct opal_header *)buf;
809 clen = be32_to_cpu(hdr->cp.length);
810 plen = be32_to_cpu(hdr->pkt.length);
811 slen = be32_to_cpu(hdr->subpkt.length);
812 pr_debug("Response size: cp: %u, pkt: %u, subpkt: %u\n",
815 if (clen == 0 || plen == 0 || slen == 0 ||
816 slen > IO_BUFFER_LENGTH - sizeof(*hdr)) {
817 pr_err("Bad header length. cp: %u, pkt: %u, subpkt: %u\n",
819 print_buffer(pos, sizeof(*hdr));
823 if (pos > buf + length)
828 print_buffer(pos, total);
830 if (pos[0] <= TINY_ATOM_BYTE) /* tiny atom */
831 token_length = response_parse_tiny(iter, pos);
832 else if (pos[0] <= SHORT_ATOM_BYTE) /* short atom */
833 token_length = response_parse_short(iter, pos);
834 else if (pos[0] <= MEDIUM_ATOM_BYTE) /* medium atom */
835 token_length = response_parse_medium(iter, pos);
836 else if (pos[0] <= LONG_ATOM_BYTE) /* long atom */
837 token_length = response_parse_long(iter, pos);
839 token_length = response_parse_token(iter, pos);
841 if (token_length < 0)
845 total -= token_length;
850 if (num_entries == 0) {
851 pr_err("Couldn't parse response.\n");
854 resp->num = num_entries;
859 static size_t response_get_string(const struct parsed_resp *resp, int n,
864 pr_err("Response is NULL\n");
869 pr_err("Response has %d tokens. Can't access %d\n",
874 if (resp->toks[n].type != OPAL_DTA_TOKENID_BYTESTRING) {
875 pr_err("Token is not a byte string!\n");
879 *store = resp->toks[n].pos + 1;
880 return resp->toks[n].len - 1;
883 static u64 response_get_u64(const struct parsed_resp *resp, int n)
886 pr_err("Response is NULL\n");
891 pr_err("Response has %d tokens. Can't access %d\n",
896 if (resp->toks[n].type != OPAL_DTA_TOKENID_UINT) {
897 pr_err("Token is not unsigned it: %d\n",
902 if (!(resp->toks[n].width == OPAL_WIDTH_TINY ||
903 resp->toks[n].width == OPAL_WIDTH_SHORT)) {
904 pr_err("Atom is not short or tiny: %d\n",
905 resp->toks[n].width);
909 return resp->toks[n].stored.u;
912 static bool response_token_matches(const struct opal_resp_tok *token, u8 match)
915 token->type != OPAL_DTA_TOKENID_TOKEN ||
916 token->pos[0] != match)
921 static u8 response_status(const struct parsed_resp *resp)
923 const struct opal_resp_tok *tok;
925 tok = response_get_token(resp, 0);
926 if (response_token_matches(tok, OPAL_ENDOFSESSION))
930 return DTAERROR_NO_METHOD_STATUS;
932 tok = response_get_token(resp, resp->num - 5);
933 if (!response_token_matches(tok, OPAL_STARTLIST))
934 return DTAERROR_NO_METHOD_STATUS;
936 tok = response_get_token(resp, resp->num - 1);
937 if (!response_token_matches(tok, OPAL_ENDLIST))
938 return DTAERROR_NO_METHOD_STATUS;
940 return response_get_u64(resp, resp->num - 4);
943 /* Parses and checks for errors */
944 static int parse_and_check_status(struct opal_dev *dev)
948 print_buffer(dev->cmd, dev->pos);
950 error = response_parse(dev->resp, IO_BUFFER_LENGTH, &dev->parsed);
952 pr_err("Couldn't parse response.\n");
956 return response_status(&dev->parsed);
959 static void clear_opal_cmd(struct opal_dev *dev)
961 dev->pos = sizeof(struct opal_header);
962 memset(dev->cmd, 0, IO_BUFFER_LENGTH);
965 static int start_opal_session_cont(struct opal_dev *dev)
970 error = parse_and_check_status(dev);
974 hsn = response_get_u64(&dev->parsed, 4);
975 tsn = response_get_u64(&dev->parsed, 5);
977 if (hsn == 0 && tsn == 0) {
978 pr_err("Couldn't authenticate session\n");
987 static void add_suspend_info(struct opal_dev *dev,
988 struct opal_suspend_data *sus)
990 struct opal_suspend_data *iter;
992 list_for_each_entry(iter, &dev->unlk_lst, node) {
993 if (iter->lr == sus->lr) {
994 list_del(&iter->node);
999 list_add_tail(&sus->node, &dev->unlk_lst);
1002 static int end_session_cont(struct opal_dev *dev)
1006 return parse_and_check_status(dev);
1009 static int finalize_and_send(struct opal_dev *dev, cont_fn cont)
1013 ret = cmd_finalize(dev, dev->hsn, dev->tsn);
1015 pr_err("Error finalizing command buffer: %d\n", ret);
1019 print_buffer(dev->cmd, dev->pos);
1021 return opal_send_recv(dev, cont);
1024 static int gen_key(struct opal_dev *dev, void *data)
1027 u8 uid[OPAL_UID_LENGTH];
1030 clear_opal_cmd(dev);
1031 set_comid(dev, dev->comid);
1033 memcpy(uid, dev->prev_data, min(sizeof(uid), dev->prev_d_len));
1034 method = opalmethod[OPAL_GENKEY];
1035 kfree(dev->prev_data);
1036 dev->prev_data = NULL;
1038 add_token_u8(&err, dev, OPAL_CALL);
1039 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1040 add_token_bytestring(&err, dev, opalmethod[OPAL_GENKEY],
1042 add_token_u8(&err, dev, OPAL_STARTLIST);
1043 add_token_u8(&err, dev, OPAL_ENDLIST);
1046 pr_err("Error building gen key command\n");
1050 return finalize_and_send(dev, parse_and_check_status);
1053 static int get_active_key_cont(struct opal_dev *dev)
1055 const char *activekey;
1059 error = parse_and_check_status(dev);
1062 keylen = response_get_string(&dev->parsed, 4, &activekey);
1064 pr_err("%s: Couldn't extract the Activekey from the response\n",
1066 return OPAL_INVAL_PARAM;
1068 dev->prev_data = kmemdup(activekey, keylen, GFP_KERNEL);
1070 if (!dev->prev_data)
1073 dev->prev_d_len = keylen;
1078 static int get_active_key(struct opal_dev *dev, void *data)
1080 u8 uid[OPAL_UID_LENGTH];
1084 clear_opal_cmd(dev);
1085 set_comid(dev, dev->comid);
1087 err = build_locking_range(uid, sizeof(uid), *lr);
1092 add_token_u8(&err, dev, OPAL_CALL);
1093 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1094 add_token_bytestring(&err, dev, opalmethod[OPAL_GET], OPAL_UID_LENGTH);
1095 add_token_u8(&err, dev, OPAL_STARTLIST);
1096 add_token_u8(&err, dev, OPAL_STARTLIST);
1097 add_token_u8(&err, dev, OPAL_STARTNAME);
1098 add_token_u8(&err, dev, 3); /* startCloumn */
1099 add_token_u8(&err, dev, 10); /* ActiveKey */
1100 add_token_u8(&err, dev, OPAL_ENDNAME);
1101 add_token_u8(&err, dev, OPAL_STARTNAME);
1102 add_token_u8(&err, dev, 4); /* endColumn */
1103 add_token_u8(&err, dev, 10); /* ActiveKey */
1104 add_token_u8(&err, dev, OPAL_ENDNAME);
1105 add_token_u8(&err, dev, OPAL_ENDLIST);
1106 add_token_u8(&err, dev, OPAL_ENDLIST);
1108 pr_err("Error building get active key command\n");
1112 return finalize_and_send(dev, get_active_key_cont);
1115 static int generic_lr_enable_disable(struct opal_dev *dev,
1116 u8 *uid, bool rle, bool wle,
1121 add_token_u8(&err, dev, OPAL_CALL);
1122 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1123 add_token_bytestring(&err, dev, opalmethod[OPAL_SET], OPAL_UID_LENGTH);
1125 add_token_u8(&err, dev, OPAL_STARTLIST);
1126 add_token_u8(&err, dev, OPAL_STARTNAME);
1127 add_token_u8(&err, dev, OPAL_VALUES);
1128 add_token_u8(&err, dev, OPAL_STARTLIST);
1130 add_token_u8(&err, dev, OPAL_STARTNAME);
1131 add_token_u8(&err, dev, 5); /* ReadLockEnabled */
1132 add_token_u8(&err, dev, rle);
1133 add_token_u8(&err, dev, OPAL_ENDNAME);
1135 add_token_u8(&err, dev, OPAL_STARTNAME);
1136 add_token_u8(&err, dev, 6); /* WriteLockEnabled */
1137 add_token_u8(&err, dev, wle);
1138 add_token_u8(&err, dev, OPAL_ENDNAME);
1140 add_token_u8(&err, dev, OPAL_STARTNAME);
1141 add_token_u8(&err, dev, OPAL_READLOCKED);
1142 add_token_u8(&err, dev, rl);
1143 add_token_u8(&err, dev, OPAL_ENDNAME);
1145 add_token_u8(&err, dev, OPAL_STARTNAME);
1146 add_token_u8(&err, dev, OPAL_WRITELOCKED);
1147 add_token_u8(&err, dev, wl);
1148 add_token_u8(&err, dev, OPAL_ENDNAME);
1150 add_token_u8(&err, dev, OPAL_ENDLIST);
1151 add_token_u8(&err, dev, OPAL_ENDNAME);
1152 add_token_u8(&err, dev, OPAL_ENDLIST);
1156 static inline int enable_global_lr(struct opal_dev *dev, u8 *uid,
1157 struct opal_user_lr_setup *setup)
1161 err = generic_lr_enable_disable(dev, uid, !!setup->RLE, !!setup->WLE,
1164 pr_err("Failed to create enable global lr command\n");
1168 static int setup_locking_range(struct opal_dev *dev, void *data)
1170 u8 uid[OPAL_UID_LENGTH];
1171 struct opal_user_lr_setup *setup = data;
1175 clear_opal_cmd(dev);
1176 set_comid(dev, dev->comid);
1178 lr = setup->session.opal_key.lr;
1179 err = build_locking_range(uid, sizeof(uid), lr);
1184 err = enable_global_lr(dev, uid, setup);
1186 add_token_u8(&err, dev, OPAL_CALL);
1187 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1188 add_token_bytestring(&err, dev, opalmethod[OPAL_SET],
1191 add_token_u8(&err, dev, OPAL_STARTLIST);
1192 add_token_u8(&err, dev, OPAL_STARTNAME);
1193 add_token_u8(&err, dev, OPAL_VALUES);
1194 add_token_u8(&err, dev, OPAL_STARTLIST);
1196 add_token_u8(&err, dev, OPAL_STARTNAME);
1197 add_token_u8(&err, dev, 3); /* Ranges Start */
1198 add_token_u64(&err, dev, setup->range_start);
1199 add_token_u8(&err, dev, OPAL_ENDNAME);
1201 add_token_u8(&err, dev, OPAL_STARTNAME);
1202 add_token_u8(&err, dev, 4); /* Ranges length */
1203 add_token_u64(&err, dev, setup->range_length);
1204 add_token_u8(&err, dev, OPAL_ENDNAME);
1206 add_token_u8(&err, dev, OPAL_STARTNAME);
1207 add_token_u8(&err, dev, 5); /*ReadLockEnabled */
1208 add_token_u64(&err, dev, !!setup->RLE);
1209 add_token_u8(&err, dev, OPAL_ENDNAME);
1211 add_token_u8(&err, dev, OPAL_STARTNAME);
1212 add_token_u8(&err, dev, 6); /*WriteLockEnabled*/
1213 add_token_u64(&err, dev, !!setup->WLE);
1214 add_token_u8(&err, dev, OPAL_ENDNAME);
1216 add_token_u8(&err, dev, OPAL_ENDLIST);
1217 add_token_u8(&err, dev, OPAL_ENDNAME);
1218 add_token_u8(&err, dev, OPAL_ENDLIST);
1222 pr_err("Error building Setup Locking range command.\n");
1227 return finalize_and_send(dev, parse_and_check_status);
1230 static int start_generic_opal_session(struct opal_dev *dev,
1232 enum opal_uid sp_type,
1239 if (key == NULL && auth != OPAL_ANYBODY_UID) {
1240 pr_err("%s: Attempted to open ADMIN_SP Session without a Host" \
1241 "Challenge, and not as the Anybody UID\n", __func__);
1242 return OPAL_INVAL_PARAM;
1245 clear_opal_cmd(dev);
1247 set_comid(dev, dev->comid);
1248 hsn = GENERIC_HOST_SESSION_NUM;
1250 add_token_u8(&err, dev, OPAL_CALL);
1251 add_token_bytestring(&err, dev, opaluid[OPAL_SMUID_UID],
1253 add_token_bytestring(&err, dev, opalmethod[OPAL_STARTSESSION],
1255 add_token_u8(&err, dev, OPAL_STARTLIST);
1256 add_token_u64(&err, dev, hsn);
1257 add_token_bytestring(&err, dev, opaluid[sp_type], OPAL_UID_LENGTH);
1258 add_token_u8(&err, dev, 1);
1261 case OPAL_ANYBODY_UID:
1262 add_token_u8(&err, dev, OPAL_ENDLIST);
1264 case OPAL_ADMIN1_UID:
1266 add_token_u8(&err, dev, OPAL_STARTNAME);
1267 add_token_u8(&err, dev, 0); /* HostChallenge */
1268 add_token_bytestring(&err, dev, key, key_len);
1269 add_token_u8(&err, dev, OPAL_ENDNAME);
1270 add_token_u8(&err, dev, OPAL_STARTNAME);
1271 add_token_u8(&err, dev, 3); /* HostSignAuth */
1272 add_token_bytestring(&err, dev, opaluid[auth],
1274 add_token_u8(&err, dev, OPAL_ENDNAME);
1275 add_token_u8(&err, dev, OPAL_ENDLIST);
1278 pr_err("Cannot start Admin SP session with auth %d\n", auth);
1279 return OPAL_INVAL_PARAM;
1283 pr_err("Error building start adminsp session command.\n");
1287 return finalize_and_send(dev, start_opal_session_cont);
1290 static int start_anybodyASP_opal_session(struct opal_dev *dev, void *data)
1292 return start_generic_opal_session(dev, OPAL_ANYBODY_UID,
1293 OPAL_ADMINSP_UID, NULL, 0);
1296 static int start_SIDASP_opal_session(struct opal_dev *dev, void *data)
1299 const u8 *key = dev->prev_data;
1302 const struct opal_key *okey = data;
1303 ret = start_generic_opal_session(dev, OPAL_SID_UID,
1308 ret = start_generic_opal_session(dev, OPAL_SID_UID,
1310 key, dev->prev_d_len);
1312 dev->prev_data = NULL;
1317 static int start_admin1LSP_opal_session(struct opal_dev *dev, void *data)
1319 struct opal_key *key = data;
1320 return start_generic_opal_session(dev, OPAL_ADMIN1_UID,
1322 key->key, key->key_len);
1325 static int start_auth_opal_session(struct opal_dev *dev, void *data)
1327 struct opal_session_info *session = data;
1328 u8 lk_ul_user[OPAL_UID_LENGTH];
1329 size_t keylen = session->opal_key.key_len;
1332 u8 *key = session->opal_key.key;
1333 u32 hsn = GENERIC_HOST_SESSION_NUM;
1335 clear_opal_cmd(dev);
1336 set_comid(dev, dev->comid);
1339 err = build_locking_user(lk_ul_user, sizeof(lk_ul_user),
1340 session->opal_key.lr);
1344 } else if (session->who != OPAL_ADMIN1 && !session->sum) {
1345 err = build_locking_user(lk_ul_user, sizeof(lk_ul_user),
1350 memcpy(lk_ul_user, opaluid[OPAL_ADMIN1_UID], OPAL_UID_LENGTH);
1352 add_token_u8(&err, dev, OPAL_CALL);
1353 add_token_bytestring(&err, dev, opaluid[OPAL_SMUID_UID],
1355 add_token_bytestring(&err, dev, opalmethod[OPAL_STARTSESSION],
1358 add_token_u8(&err, dev, OPAL_STARTLIST);
1359 add_token_u64(&err, dev, hsn);
1360 add_token_bytestring(&err, dev, opaluid[OPAL_LOCKINGSP_UID],
1362 add_token_u8(&err, dev, 1);
1363 add_token_u8(&err, dev, OPAL_STARTNAME);
1364 add_token_u8(&err, dev, 0);
1365 add_token_bytestring(&err, dev, key, keylen);
1366 add_token_u8(&err, dev, OPAL_ENDNAME);
1367 add_token_u8(&err, dev, OPAL_STARTNAME);
1368 add_token_u8(&err, dev, 3);
1369 add_token_bytestring(&err, dev, lk_ul_user, OPAL_UID_LENGTH);
1370 add_token_u8(&err, dev, OPAL_ENDNAME);
1371 add_token_u8(&err, dev, OPAL_ENDLIST);
1374 pr_err("Error building STARTSESSION command.\n");
1378 return finalize_and_send(dev, start_opal_session_cont);
1381 static int revert_tper(struct opal_dev *dev, void *data)
1385 clear_opal_cmd(dev);
1386 set_comid(dev, dev->comid);
1388 add_token_u8(&err, dev, OPAL_CALL);
1389 add_token_bytestring(&err, dev, opaluid[OPAL_ADMINSP_UID],
1391 add_token_bytestring(&err, dev, opalmethod[OPAL_REVERT],
1393 add_token_u8(&err, dev, OPAL_STARTLIST);
1394 add_token_u8(&err, dev, OPAL_ENDLIST);
1396 pr_err("Error building REVERT TPER command.\n");
1400 return finalize_and_send(dev, parse_and_check_status);
1403 static int internal_activate_user(struct opal_dev *dev, void *data)
1405 struct opal_session_info *session = data;
1406 u8 uid[OPAL_UID_LENGTH];
1409 clear_opal_cmd(dev);
1410 set_comid(dev, dev->comid);
1412 memcpy(uid, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH);
1413 uid[7] = session->who;
1415 add_token_u8(&err, dev, OPAL_CALL);
1416 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1417 add_token_bytestring(&err, dev, opalmethod[OPAL_SET], OPAL_UID_LENGTH);
1418 add_token_u8(&err, dev, OPAL_STARTLIST);
1419 add_token_u8(&err, dev, OPAL_STARTNAME);
1420 add_token_u8(&err, dev, OPAL_VALUES);
1421 add_token_u8(&err, dev, OPAL_STARTLIST);
1422 add_token_u8(&err, dev, OPAL_STARTNAME);
1423 add_token_u8(&err, dev, 5); /* Enabled */
1424 add_token_u8(&err, dev, OPAL_TRUE);
1425 add_token_u8(&err, dev, OPAL_ENDNAME);
1426 add_token_u8(&err, dev, OPAL_ENDLIST);
1427 add_token_u8(&err, dev, OPAL_ENDNAME);
1428 add_token_u8(&err, dev, OPAL_ENDLIST);
1431 pr_err("Error building Activate UserN command.\n");
1435 return finalize_and_send(dev, parse_and_check_status);
1438 static int erase_locking_range(struct opal_dev *dev, void *data)
1440 struct opal_session_info *session = data;
1441 u8 uid[OPAL_UID_LENGTH];
1444 clear_opal_cmd(dev);
1445 set_comid(dev, dev->comid);
1447 if (build_locking_range(uid, sizeof(uid), session->opal_key.lr) < 0)
1450 add_token_u8(&err, dev, OPAL_CALL);
1451 add_token_bytestring(&err, dev, uid, OPAL_UID_LENGTH);
1452 add_token_bytestring(&err, dev, opalmethod[OPAL_ERASE],
1454 add_token_u8(&err, dev, OPAL_STARTLIST);
1455 add_token_u8(&err, dev, OPAL_ENDLIST);
1458 pr_err("Error building Erase Locking Range Command.\n");
1461 return finalize_and_send(dev, parse_and_check_status);
1464 static int set_mbr_done(struct opal_dev *dev, void *data)
1466 u8 *mbr_done_tf = data;
1469 clear_opal_cmd(dev);
1470 set_comid(dev, dev->comid);
1472 add_token_u8(&err, dev, OPAL_CALL);
1473 add_token_bytestring(&err, dev, opaluid[OPAL_MBRCONTROL],
1475 add_token_bytestring(&err, dev, opalmethod[OPAL_SET], OPAL_UID_LENGTH);
1476 add_token_u8(&err, dev, OPAL_STARTLIST);
1477 add_token_u8(&err, dev, OPAL_STARTNAME);
1478 add_token_u8(&err, dev, OPAL_VALUES);
1479 add_token_u8(&err, dev, OPAL_STARTLIST);
1480 add_token_u8(&err, dev, OPAL_STARTNAME);
1481 add_token_u8(&err, dev, 2); /* Done */
1482 add_token_u8(&err, dev, *mbr_done_tf); /* Done T or F */
1483 add_token_u8(&err, dev, OPAL_ENDNAME);
1484 add_token_u8(&err, dev, OPAL_ENDLIST);
1485 add_token_u8(&err, dev, OPAL_ENDNAME);
1486 add_token_u8(&err, dev, OPAL_ENDLIST);
1489 pr_err("Error Building set MBR Done command\n");
1493 return finalize_and_send(dev, parse_and_check_status);
1496 static int set_mbr_enable_disable(struct opal_dev *dev, void *data)
1498 u8 *mbr_en_dis = data;
1501 clear_opal_cmd(dev);
1502 set_comid(dev, dev->comid);
1504 add_token_u8(&err, dev, OPAL_CALL);
1505 add_token_bytestring(&err, dev, opaluid[OPAL_MBRCONTROL],
1507 add_token_bytestring(&err, dev, opalmethod[OPAL_SET], OPAL_UID_LENGTH);
1508 add_token_u8(&err, dev, OPAL_STARTLIST);
1509 add_token_u8(&err, dev, OPAL_STARTNAME);
1510 add_token_u8(&err, dev, OPAL_VALUES);
1511 add_token_u8(&err, dev, OPAL_STARTLIST);
1512 add_token_u8(&err, dev, OPAL_STARTNAME);
1513 add_token_u8(&err, dev, 1);
1514 add_token_u8(&err, dev, *mbr_en_dis);
1515 add_token_u8(&err, dev, OPAL_ENDNAME);
1516 add_token_u8(&err, dev, OPAL_ENDLIST);
1517 add_token_u8(&err, dev, OPAL_ENDNAME);
1518 add_token_u8(&err, dev, OPAL_ENDLIST);
1521 pr_err("Error Building set MBR done command\n");
1525 return finalize_and_send(dev, parse_and_check_status);
1528 static int generic_pw_cmd(u8 *key, size_t key_len, u8 *cpin_uid,
1529 struct opal_dev *dev)
1533 clear_opal_cmd(dev);
1534 set_comid(dev, dev->comid);
1536 add_token_u8(&err, dev, OPAL_CALL);
1537 add_token_bytestring(&err, dev, cpin_uid, OPAL_UID_LENGTH);
1538 add_token_bytestring(&err, dev, opalmethod[OPAL_SET],
1540 add_token_u8(&err, dev, OPAL_STARTLIST);
1541 add_token_u8(&err, dev, OPAL_STARTNAME);
1542 add_token_u8(&err, dev, OPAL_VALUES);
1543 add_token_u8(&err, dev, OPAL_STARTLIST);
1544 add_token_u8(&err, dev, OPAL_STARTNAME);
1545 add_token_u8(&err, dev, 3); /* PIN */
1546 add_token_bytestring(&err, dev, key, key_len);
1547 add_token_u8(&err, dev, OPAL_ENDNAME);
1548 add_token_u8(&err, dev, OPAL_ENDLIST);
1549 add_token_u8(&err, dev, OPAL_ENDNAME);
1550 add_token_u8(&err, dev, OPAL_ENDLIST);
1555 static int set_new_pw(struct opal_dev *dev, void *data)
1557 u8 cpin_uid[OPAL_UID_LENGTH];
1558 struct opal_session_info *usr = data;
1560 memcpy(cpin_uid, opaluid[OPAL_C_PIN_ADMIN1], OPAL_UID_LENGTH);
1562 if (usr->who != OPAL_ADMIN1) {
1565 cpin_uid[7] = usr->opal_key.lr + 1;
1567 cpin_uid[7] = usr->who;
1570 if (generic_pw_cmd(usr->opal_key.key, usr->opal_key.key_len,
1572 pr_err("Error building set password command.\n");
1576 return finalize_and_send(dev, parse_and_check_status);
1579 static int set_sid_cpin_pin(struct opal_dev *dev, void *data)
1581 u8 cpin_uid[OPAL_UID_LENGTH];
1582 struct opal_key *key = data;
1584 memcpy(cpin_uid, opaluid[OPAL_C_PIN_SID], OPAL_UID_LENGTH);
1586 if (generic_pw_cmd(key->key, key->key_len, cpin_uid, dev)) {
1587 pr_err("Error building Set SID cpin\n");
1590 return finalize_and_send(dev, parse_and_check_status);
1593 static int add_user_to_lr(struct opal_dev *dev, void *data)
1595 u8 lr_buffer[OPAL_UID_LENGTH];
1596 u8 user_uid[OPAL_UID_LENGTH];
1597 struct opal_lock_unlock *lkul = data;
1600 clear_opal_cmd(dev);
1601 set_comid(dev, dev->comid);
1603 memcpy(lr_buffer, opaluid[OPAL_LOCKINGRANGE_ACE_RDLOCKED],
1606 if (lkul->l_state == OPAL_RW)
1607 memcpy(lr_buffer, opaluid[OPAL_LOCKINGRANGE_ACE_WRLOCKED],
1610 lr_buffer[7] = lkul->session.opal_key.lr;
1612 memcpy(user_uid, opaluid[OPAL_USER1_UID], OPAL_UID_LENGTH);
1614 user_uid[7] = lkul->session.who;
1616 add_token_u8(&err, dev, OPAL_CALL);
1617 add_token_bytestring(&err, dev, lr_buffer, OPAL_UID_LENGTH);
1618 add_token_bytestring(&err, dev, opalmethod[OPAL_SET],
1621 add_token_u8(&err, dev, OPAL_STARTLIST);
1622 add_token_u8(&err, dev, OPAL_STARTNAME);
1623 add_token_u8(&err, dev, OPAL_VALUES);
1625 add_token_u8(&err, dev, OPAL_STARTLIST);
1626 add_token_u8(&err, dev, OPAL_STARTNAME);
1627 add_token_u8(&err, dev, 3);
1629 add_token_u8(&err, dev, OPAL_STARTLIST);
1632 add_token_u8(&err, dev, OPAL_STARTNAME);
1633 add_token_bytestring(&err, dev,
1634 opaluid[OPAL_HALF_UID_AUTHORITY_OBJ_REF],
1636 add_token_bytestring(&err, dev, user_uid, OPAL_UID_LENGTH);
1637 add_token_u8(&err, dev, OPAL_ENDNAME);
1640 add_token_u8(&err, dev, OPAL_STARTNAME);
1641 add_token_bytestring(&err, dev,
1642 opaluid[OPAL_HALF_UID_AUTHORITY_OBJ_REF],
1644 add_token_bytestring(&err, dev, user_uid, OPAL_UID_LENGTH);
1645 add_token_u8(&err, dev, OPAL_ENDNAME);
1648 add_token_u8(&err, dev, OPAL_STARTNAME);
1649 add_token_bytestring(&err, dev, opaluid[OPAL_HALF_UID_BOOLEAN_ACE],
1651 add_token_u8(&err, dev, 1);
1652 add_token_u8(&err, dev, OPAL_ENDNAME);
1655 add_token_u8(&err, dev, OPAL_ENDLIST);
1656 add_token_u8(&err, dev, OPAL_ENDNAME);
1657 add_token_u8(&err, dev, OPAL_ENDLIST);
1658 add_token_u8(&err, dev, OPAL_ENDNAME);
1659 add_token_u8(&err, dev, OPAL_ENDLIST);
1662 pr_err("Error building add user to locking range command.\n");
1666 return finalize_and_send(dev, parse_and_check_status);
1669 static int lock_unlock_locking_range(struct opal_dev *dev, void *data)
1671 u8 lr_buffer[OPAL_UID_LENGTH];
1673 struct opal_lock_unlock *lkul = data;
1674 u8 read_locked = 1, write_locked = 1;
1677 clear_opal_cmd(dev);
1678 set_comid(dev, dev->comid);
1680 method = opalmethod[OPAL_SET];
1681 if (build_locking_range(lr_buffer, sizeof(lr_buffer),
1682 lkul->session.opal_key.lr) < 0)
1685 switch (lkul->l_state) {
1695 /* vars are initalized to locked */
1698 pr_err("Tried to set an invalid locking state... returning to uland\n");
1699 return OPAL_INVAL_PARAM;
1702 add_token_u8(&err, dev, OPAL_CALL);
1703 add_token_bytestring(&err, dev, lr_buffer, OPAL_UID_LENGTH);
1704 add_token_bytestring(&err, dev, opalmethod[OPAL_SET], OPAL_UID_LENGTH);
1705 add_token_u8(&err, dev, OPAL_STARTLIST);
1706 add_token_u8(&err, dev, OPAL_STARTNAME);
1707 add_token_u8(&err, dev, OPAL_VALUES);
1708 add_token_u8(&err, dev, OPAL_STARTLIST);
1710 add_token_u8(&err, dev, OPAL_STARTNAME);
1711 add_token_u8(&err, dev, OPAL_READLOCKED);
1712 add_token_u8(&err, dev, read_locked);
1713 add_token_u8(&err, dev, OPAL_ENDNAME);
1715 add_token_u8(&err, dev, OPAL_STARTNAME);
1716 add_token_u8(&err, dev, OPAL_WRITELOCKED);
1717 add_token_u8(&err, dev, write_locked);
1718 add_token_u8(&err, dev, OPAL_ENDNAME);
1720 add_token_u8(&err, dev, OPAL_ENDLIST);
1721 add_token_u8(&err, dev, OPAL_ENDNAME);
1722 add_token_u8(&err, dev, OPAL_ENDLIST);
1725 pr_err("Error building SET command.\n");
1728 return finalize_and_send(dev, parse_and_check_status);
1732 static int lock_unlock_locking_range_sum(struct opal_dev *dev, void *data)
1734 u8 lr_buffer[OPAL_UID_LENGTH];
1735 u8 read_locked = 1, write_locked = 1;
1737 struct opal_lock_unlock *lkul = data;
1740 clear_opal_cmd(dev);
1741 set_comid(dev, dev->comid);
1743 method = opalmethod[OPAL_SET];
1744 if (build_locking_range(lr_buffer, sizeof(lr_buffer),
1745 lkul->session.opal_key.lr) < 0)
1748 switch (lkul->l_state) {
1758 /* vars are initalized to locked */
1761 pr_err("Tried to set an invalid locking state.\n");
1762 return OPAL_INVAL_PARAM;
1764 ret = generic_lr_enable_disable(dev, lr_buffer, 1, 1,
1765 read_locked, write_locked);
1768 pr_err("Error building SET command.\n");
1771 return finalize_and_send(dev, parse_and_check_status);
1774 static int activate_lsp(struct opal_dev *dev, void *data)
1776 struct opal_lr_act *opal_act = data;
1777 u8 user_lr[OPAL_UID_LENGTH];
1781 clear_opal_cmd(dev);
1782 set_comid(dev, dev->comid);
1784 add_token_u8(&err, dev, OPAL_CALL);
1785 add_token_bytestring(&err, dev, opaluid[OPAL_LOCKINGSP_UID],
1787 add_token_bytestring(&err, dev, opalmethod[OPAL_ACTIVATE],
1791 if (opal_act->sum) {
1792 err = build_locking_range(user_lr, sizeof(user_lr),
1797 add_token_u8(&err, dev, OPAL_STARTLIST);
1798 add_token_u8(&err, dev, OPAL_STARTNAME);
1799 add_token_u8(&err, dev, uint_3);
1800 add_token_u8(&err, dev, 6);
1801 add_token_u8(&err, dev, 0);
1802 add_token_u8(&err, dev, 0);
1804 add_token_u8(&err, dev, OPAL_STARTLIST);
1805 add_token_bytestring(&err, dev, user_lr, OPAL_UID_LENGTH);
1806 for (i = 1; i < opal_act->num_lrs; i++) {
1807 user_lr[7] = opal_act->lr[i];
1808 add_token_bytestring(&err, dev, user_lr, OPAL_UID_LENGTH);
1810 add_token_u8(&err, dev, OPAL_ENDLIST);
1811 add_token_u8(&err, dev, OPAL_ENDNAME);
1812 add_token_u8(&err, dev, OPAL_ENDLIST);
1815 add_token_u8(&err, dev, OPAL_STARTLIST);
1816 add_token_u8(&err, dev, OPAL_ENDLIST);
1820 pr_err("Error building Activate LockingSP command.\n");
1824 return finalize_and_send(dev, parse_and_check_status);
1827 static int get_lsp_lifecycle_cont(struct opal_dev *dev)
1832 error = parse_and_check_status(dev);
1836 lc_status = response_get_u64(&dev->parsed, 4);
1837 /* 0x08 is Manufacured Inactive */
1838 /* 0x09 is Manufactured */
1839 if (lc_status != OPAL_MANUFACTURED_INACTIVE) {
1840 pr_err("Couldn't determine the status of the Lifcycle state\n");
1847 /* Determine if we're in the Manufactured Inactive or Active state */
1848 static int get_lsp_lifecycle(struct opal_dev *dev, void *data)
1852 clear_opal_cmd(dev);
1853 set_comid(dev, dev->comid);
1855 add_token_u8(&err, dev, OPAL_CALL);
1856 add_token_bytestring(&err, dev, opaluid[OPAL_LOCKINGSP_UID],
1858 add_token_bytestring(&err, dev, opalmethod[OPAL_GET], OPAL_UID_LENGTH);
1860 add_token_u8(&err, dev, OPAL_STARTLIST);
1861 add_token_u8(&err, dev, OPAL_STARTLIST);
1863 add_token_u8(&err, dev, OPAL_STARTNAME);
1864 add_token_u8(&err, dev, 3); /* Start Column */
1865 add_token_u8(&err, dev, 6); /* Lifecycle Column */
1866 add_token_u8(&err, dev, OPAL_ENDNAME);
1868 add_token_u8(&err, dev, OPAL_STARTNAME);
1869 add_token_u8(&err, dev, 4); /* End Column */
1870 add_token_u8(&err, dev, 6); /* Lifecycle Column */
1871 add_token_u8(&err, dev, OPAL_ENDNAME);
1873 add_token_u8(&err, dev, OPAL_ENDLIST);
1874 add_token_u8(&err, dev, OPAL_ENDLIST);
1877 pr_err("Error Building GET Lifecycle Status command\n");
1881 return finalize_and_send(dev, get_lsp_lifecycle_cont);
1884 static int get_msid_cpin_pin_cont(struct opal_dev *dev)
1886 const char *msid_pin;
1890 error = parse_and_check_status(dev);
1894 strlen = response_get_string(&dev->parsed, 4, &msid_pin);
1896 pr_err("%s: Couldn't extract PIN from response\n", __func__);
1897 return OPAL_INVAL_PARAM;
1900 dev->prev_data = kmemdup(msid_pin, strlen, GFP_KERNEL);
1901 if (!dev->prev_data)
1904 dev->prev_d_len = strlen;
1909 static int get_msid_cpin_pin(struct opal_dev *dev, void *data)
1913 clear_opal_cmd(dev);
1914 set_comid(dev, dev->comid);
1916 add_token_u8(&err, dev, OPAL_CALL);
1917 add_token_bytestring(&err, dev, opaluid[OPAL_C_PIN_MSID],
1919 add_token_bytestring(&err, dev, opalmethod[OPAL_GET], OPAL_UID_LENGTH);
1921 add_token_u8(&err, dev, OPAL_STARTLIST);
1922 add_token_u8(&err, dev, OPAL_STARTLIST);
1924 add_token_u8(&err, dev, OPAL_STARTNAME);
1925 add_token_u8(&err, dev, 3); /* Start Column */
1926 add_token_u8(&err, dev, 3); /* PIN */
1927 add_token_u8(&err, dev, OPAL_ENDNAME);
1929 add_token_u8(&err, dev, OPAL_STARTNAME);
1930 add_token_u8(&err, dev, 4); /* End Column */
1931 add_token_u8(&err, dev, 3); /* Lifecycle Column */
1932 add_token_u8(&err, dev, OPAL_ENDNAME);
1934 add_token_u8(&err, dev, OPAL_ENDLIST);
1935 add_token_u8(&err, dev, OPAL_ENDLIST);
1938 pr_err("Error building Get MSID CPIN PIN command.\n");
1942 return finalize_and_send(dev, get_msid_cpin_pin_cont);
1945 static int end_opal_session(struct opal_dev *dev, void *data)
1949 clear_opal_cmd(dev);
1950 set_comid(dev, dev->comid);
1951 add_token_u8(&err, dev, OPAL_ENDOFSESSION);
1955 return finalize_and_send(dev, end_session_cont);
1958 static int end_opal_session_error(struct opal_dev *dev)
1960 const struct opal_step error_end_session[] = {
1961 { end_opal_session, },
1964 dev->steps = error_end_session;
1968 static inline void setup_opal_dev(struct opal_dev *dev,
1969 const struct opal_step *steps)
1974 dev->prev_data = NULL;
1977 static int check_opal_support(struct opal_dev *dev)
1979 const struct opal_step steps[] = {
1980 { opal_discovery0, },
1985 mutex_lock(&dev->dev_lock);
1986 setup_opal_dev(dev, steps);
1988 dev->supported = !ret;
1989 mutex_unlock(&dev->dev_lock);
1993 static void clean_opal_dev(struct opal_dev *dev)
1996 struct opal_suspend_data *suspend, *next;
1998 mutex_lock(&dev->dev_lock);
1999 list_for_each_entry_safe(suspend, next, &dev->unlk_lst, node) {
2000 list_del(&suspend->node);
2003 mutex_unlock(&dev->dev_lock);
2006 void free_opal_dev(struct opal_dev *dev)
2010 clean_opal_dev(dev);
2013 EXPORT_SYMBOL(free_opal_dev);
2015 struct opal_dev *init_opal_dev(void *data, sec_send_recv *send_recv)
2017 struct opal_dev *dev;
2019 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
2023 INIT_LIST_HEAD(&dev->unlk_lst);
2024 mutex_init(&dev->dev_lock);
2026 dev->send_recv = send_recv;
2027 if (check_opal_support(dev) != 0) {
2028 pr_debug("Opal is not supported on this device\n");
2034 EXPORT_SYMBOL(init_opal_dev);
2036 static int opal_secure_erase_locking_range(struct opal_dev *dev,
2037 struct opal_session_info *opal_session)
2039 const struct opal_step erase_steps[] = {
2040 { opal_discovery0, },
2041 { start_auth_opal_session, opal_session },
2042 { get_active_key, &opal_session->opal_key.lr },
2044 { end_opal_session, },
2049 mutex_lock(&dev->dev_lock);
2050 setup_opal_dev(dev, erase_steps);
2052 mutex_unlock(&dev->dev_lock);
2056 static int opal_erase_locking_range(struct opal_dev *dev,
2057 struct opal_session_info *opal_session)
2059 const struct opal_step erase_steps[] = {
2060 { opal_discovery0, },
2061 { start_auth_opal_session, opal_session },
2062 { erase_locking_range, opal_session },
2063 { end_opal_session, },
2068 mutex_lock(&dev->dev_lock);
2069 setup_opal_dev(dev, erase_steps);
2071 mutex_unlock(&dev->dev_lock);
2075 static int opal_enable_disable_shadow_mbr(struct opal_dev *dev,
2076 struct opal_mbr_data *opal_mbr)
2078 const struct opal_step mbr_steps[] = {
2079 { opal_discovery0, },
2080 { start_admin1LSP_opal_session, &opal_mbr->key },
2081 { set_mbr_done, &opal_mbr->enable_disable },
2082 { end_opal_session, },
2083 { start_admin1LSP_opal_session, &opal_mbr->key },
2084 { set_mbr_enable_disable, &opal_mbr->enable_disable },
2085 { end_opal_session, },
2090 if (opal_mbr->enable_disable != OPAL_MBR_ENABLE &&
2091 opal_mbr->enable_disable != OPAL_MBR_DISABLE)
2094 mutex_lock(&dev->dev_lock);
2095 setup_opal_dev(dev, mbr_steps);
2097 mutex_unlock(&dev->dev_lock);
2101 static int opal_save(struct opal_dev *dev, struct opal_lock_unlock *lk_unlk)
2103 struct opal_suspend_data *suspend;
2105 suspend = kzalloc(sizeof(*suspend), GFP_KERNEL);
2109 suspend->unlk = *lk_unlk;
2110 suspend->lr = lk_unlk->session.opal_key.lr;
2112 mutex_lock(&dev->dev_lock);
2113 setup_opal_dev(dev, NULL);
2114 add_suspend_info(dev, suspend);
2115 mutex_unlock(&dev->dev_lock);
2119 static int opal_add_user_to_lr(struct opal_dev *dev,
2120 struct opal_lock_unlock *lk_unlk)
2122 const struct opal_step steps[] = {
2123 { opal_discovery0, },
2124 { start_admin1LSP_opal_session, &lk_unlk->session.opal_key },
2125 { add_user_to_lr, lk_unlk },
2126 { end_opal_session, },
2131 if (lk_unlk->l_state != OPAL_RO &&
2132 lk_unlk->l_state != OPAL_RW) {
2133 pr_err("Locking state was not RO or RW\n");
2136 if (lk_unlk->session.who < OPAL_USER1 &&
2137 lk_unlk->session.who > OPAL_USER9) {
2138 pr_err("Authority was not within the range of users: %d\n",
2139 lk_unlk->session.who);
2142 if (lk_unlk->session.sum) {
2143 pr_err("%s not supported in sum. Use setup locking range\n",
2148 mutex_lock(&dev->dev_lock);
2149 setup_opal_dev(dev, steps);
2151 mutex_unlock(&dev->dev_lock);
2155 static int opal_reverttper(struct opal_dev *dev, struct opal_key *opal)
2157 const struct opal_step revert_steps[] = {
2158 { opal_discovery0, },
2159 { start_SIDASP_opal_session, opal },
2160 { revert_tper, }, /* controller will terminate session */
2165 mutex_lock(&dev->dev_lock);
2166 setup_opal_dev(dev, revert_steps);
2168 mutex_unlock(&dev->dev_lock);
2171 * If we successfully reverted lets clean
2172 * any saved locking ranges.
2175 clean_opal_dev(dev);
2180 static int __opal_lock_unlock(struct opal_dev *dev,
2181 struct opal_lock_unlock *lk_unlk)
2183 const struct opal_step unlock_steps[] = {
2184 { opal_discovery0, },
2185 { start_auth_opal_session, &lk_unlk->session },
2186 { lock_unlock_locking_range, lk_unlk },
2187 { end_opal_session, },
2190 const struct opal_step unlock_sum_steps[] = {
2191 { opal_discovery0, },
2192 { start_auth_opal_session, &lk_unlk->session },
2193 { lock_unlock_locking_range_sum, lk_unlk },
2194 { end_opal_session, },
2198 dev->steps = lk_unlk->session.sum ? unlock_sum_steps : unlock_steps;
2202 static int opal_lock_unlock(struct opal_dev *dev,
2203 struct opal_lock_unlock *lk_unlk)
2207 if (lk_unlk->session.who < OPAL_ADMIN1 ||
2208 lk_unlk->session.who > OPAL_USER9)
2211 mutex_lock(&dev->dev_lock);
2212 ret = __opal_lock_unlock(dev, lk_unlk);
2213 mutex_unlock(&dev->dev_lock);
2217 static int opal_take_ownership(struct opal_dev *dev, struct opal_key *opal)
2219 const struct opal_step owner_steps[] = {
2220 { opal_discovery0, },
2221 { start_anybodyASP_opal_session, },
2222 { get_msid_cpin_pin, },
2223 { end_opal_session, },
2224 { start_SIDASP_opal_session, opal },
2225 { set_sid_cpin_pin, opal },
2226 { end_opal_session, },
2234 mutex_lock(&dev->dev_lock);
2235 setup_opal_dev(dev, owner_steps);
2237 mutex_unlock(&dev->dev_lock);
2241 static int opal_activate_lsp(struct opal_dev *dev, struct opal_lr_act *opal_lr_act)
2243 const struct opal_step active_steps[] = {
2244 { opal_discovery0, },
2245 { start_SIDASP_opal_session, &opal_lr_act->key },
2246 { get_lsp_lifecycle, },
2247 { activate_lsp, opal_lr_act },
2248 { end_opal_session, },
2253 if (!opal_lr_act->num_lrs || opal_lr_act->num_lrs > OPAL_MAX_LRS)
2256 mutex_lock(&dev->dev_lock);
2257 setup_opal_dev(dev, active_steps);
2259 mutex_unlock(&dev->dev_lock);
2263 static int opal_setup_locking_range(struct opal_dev *dev,
2264 struct opal_user_lr_setup *opal_lrs)
2266 const struct opal_step lr_steps[] = {
2267 { opal_discovery0, },
2268 { start_auth_opal_session, &opal_lrs->session },
2269 { setup_locking_range, opal_lrs },
2270 { end_opal_session, },
2275 mutex_lock(&dev->dev_lock);
2276 setup_opal_dev(dev, lr_steps);
2278 mutex_unlock(&dev->dev_lock);
2282 static int opal_set_new_pw(struct opal_dev *dev, struct opal_new_pw *opal_pw)
2284 const struct opal_step pw_steps[] = {
2285 { opal_discovery0, },
2286 { start_auth_opal_session, &opal_pw->session },
2287 { set_new_pw, &opal_pw->new_user_pw },
2288 { end_opal_session, },
2293 if (opal_pw->session.who < OPAL_ADMIN1 ||
2294 opal_pw->session.who > OPAL_USER9 ||
2295 opal_pw->new_user_pw.who < OPAL_ADMIN1 ||
2296 opal_pw->new_user_pw.who > OPAL_USER9)
2299 mutex_lock(&dev->dev_lock);
2300 setup_opal_dev(dev, pw_steps);
2302 mutex_unlock(&dev->dev_lock);
2306 static int opal_activate_user(struct opal_dev *dev,
2307 struct opal_session_info *opal_session)
2309 const struct opal_step act_steps[] = {
2310 { opal_discovery0, },
2311 { start_admin1LSP_opal_session, &opal_session->opal_key },
2312 { internal_activate_user, opal_session },
2313 { end_opal_session, },
2318 /* We can't activate Admin1 it's active as manufactured */
2319 if (opal_session->who < OPAL_USER1 &&
2320 opal_session->who > OPAL_USER9) {
2321 pr_err("Who was not a valid user: %d\n", opal_session->who);
2325 mutex_lock(&dev->dev_lock);
2326 setup_opal_dev(dev, act_steps);
2328 mutex_unlock(&dev->dev_lock);
2332 bool opal_unlock_from_suspend(struct opal_dev *dev)
2334 struct opal_suspend_data *suspend;
2335 bool was_failure = false;
2340 if (!dev->supported)
2343 mutex_lock(&dev->dev_lock);
2344 setup_opal_dev(dev, NULL);
2346 list_for_each_entry(suspend, &dev->unlk_lst, node) {
2350 ret = __opal_lock_unlock(dev, &suspend->unlk);
2352 pr_warn("Failed to unlock LR %hhu with sum %d\n",
2353 suspend->unlk.session.opal_key.lr,
2354 suspend->unlk.session.sum);
2358 mutex_unlock(&dev->dev_lock);
2361 EXPORT_SYMBOL(opal_unlock_from_suspend);
2363 int sed_ioctl(struct opal_dev *dev, unsigned int cmd, void __user *arg)
2368 if (!capable(CAP_SYS_ADMIN))
2372 if (!dev->supported) {
2373 pr_err("Not supported\n");
2377 p = memdup_user(arg, _IOC_SIZE(cmd));
2383 ret = opal_save(dev, p);
2385 case IOC_OPAL_LOCK_UNLOCK:
2386 ret = opal_lock_unlock(dev, p);
2388 case IOC_OPAL_TAKE_OWNERSHIP:
2389 ret = opal_take_ownership(dev, p);
2391 case IOC_OPAL_ACTIVATE_LSP:
2392 ret = opal_activate_lsp(dev, p);
2394 case IOC_OPAL_SET_PW:
2395 ret = opal_set_new_pw(dev, p);
2397 case IOC_OPAL_ACTIVATE_USR:
2398 ret = opal_activate_user(dev, p);
2400 case IOC_OPAL_REVERT_TPR:
2401 ret = opal_reverttper(dev, p);
2403 case IOC_OPAL_LR_SETUP:
2404 ret = opal_setup_locking_range(dev, p);
2406 case IOC_OPAL_ADD_USR_TO_LR:
2407 ret = opal_add_user_to_lr(dev, p);
2409 case IOC_OPAL_ENABLE_DISABLE_MBR:
2410 ret = opal_enable_disable_shadow_mbr(dev, p);
2412 case IOC_OPAL_ERASE_LR:
2413 ret = opal_erase_locking_range(dev, p);
2415 case IOC_OPAL_SECURE_ERASE_LR:
2416 ret = opal_secure_erase_locking_range(dev, p);
2419 pr_warn("No such Opal Ioctl %u\n", cmd);
2425 EXPORT_SYMBOL_GPL(sed_ioctl);