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