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