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