1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright © 2016 Intel Corporation
6 * Scott Bauer <scott.bauer@intel.com>
7 * Rafael Antognolli <rafael.antognolli@intel.com>
10 #define pr_fmt(fmt) KBUILD_MODNAME ":OPAL: " fmt
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/sed-opal-key.h>
22 #include <linux/string.h>
23 #include <linux/kdev_t.h>
24 #include <linux/key.h>
25 #include <linux/key-type.h>
26 #include <keys/user-type.h>
28 #include "opal_proto.h"
30 #define IO_BUFFER_LENGTH 2048
33 /* Number of bytes needed by cmd_finalize. */
34 #define CMD_FINALIZE_BYTES_NEEDED 7
36 static struct key
*sed_opal_keyring
;
39 int (*fn
)(struct opal_dev
*dev
, void *data
);
42 typedef int (cont_fn
)(struct opal_dev
*dev
);
44 enum opal_atom_width
{
53 * On the parsed response, we don't store again the toks that are already
54 * stored in the response buffer. Instead, for each token, we just store a
55 * pointer to the position in the buffer where the token starts, and the size
56 * of the token in bytes.
58 struct opal_resp_tok
{
61 enum opal_response_token type
;
62 enum opal_atom_width width
;
70 * From the response header it's not possible to know how many tokens there are
71 * on the payload. So we hardcode that the maximum will be MAX_TOKS, and later
72 * if we start dealing with messages that have more than that, we can increase
73 * this number. This is done to avoid having to make two passes through the
74 * response, the first one counting how many tokens we have and the second one
75 * actually storing the positions.
79 struct opal_resp_tok toks
[MAX_TOKS
];
86 sec_send_recv
*send_recv
;
88 struct mutex dev_lock
;
92 u64 align
; /* alignment granularity */
94 u32 logical_block_size
;
95 u8 align_required
; /* ALIGN: 0 or 1 */
101 struct parsed_resp parsed
;
105 struct list_head unlk_lst
;
109 static const u8 opaluid
[][OPAL_UID_LENGTH
] = {
112 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
114 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
116 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x01 },
117 [OPAL_LOCKINGSP_UID
] =
118 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x02 },
119 [OPAL_ENTERPRISE_LOCKINGSP_UID
] =
120 { 0x00, 0x00, 0x02, 0x05, 0x00, 0x01, 0x00, 0x01 },
122 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01 },
124 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06 },
126 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x01 },
128 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x01 },
130 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x02 },
132 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0xff, 0x01 },
133 [OPAL_ENTERPRISE_BANDMASTER0_UID
] =
134 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x80, 0x01 },
135 [OPAL_ENTERPRISE_ERASEMASTER_UID
] =
136 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x84, 0x01 },
140 { 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01 },
141 [OPAL_LOCKINGRANGE_GLOBAL
] =
142 { 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x01 },
143 [OPAL_LOCKINGRANGE_ACE_START_TO_KEY
] =
144 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xD0, 0x01 },
145 [OPAL_LOCKINGRANGE_ACE_RDLOCKED
] =
146 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE0, 0x01 },
147 [OPAL_LOCKINGRANGE_ACE_WRLOCKED
] =
148 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0xE8, 0x01 },
150 { 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x01 },
152 { 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00 },
153 [OPAL_AUTHORITY_TABLE
] =
154 { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00},
156 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00},
157 [OPAL_LOCKING_INFO_TABLE
] =
158 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01 },
159 [OPAL_ENTERPRISE_LOCKING_INFO_TABLE
] =
160 { 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00 },
162 { 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00 },
164 /* C_PIN_TABLE object ID's */
166 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x84, 0x02},
168 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01},
169 [OPAL_C_PIN_ADMIN1
] =
170 { 0x00, 0x00, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x01},
172 /* half UID's (only first 4 bytes used) */
173 [OPAL_HALF_UID_AUTHORITY_OBJ_REF
] =
174 { 0x00, 0x00, 0x0C, 0x05, 0xff, 0xff, 0xff, 0xff },
175 [OPAL_HALF_UID_BOOLEAN_ACE
] =
176 { 0x00, 0x00, 0x04, 0x0E, 0xff, 0xff, 0xff, 0xff },
178 /* special value for omitted optional parameter */
180 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
184 * TCG Storage SSC Methods.
185 * Derived from: TCG_Storage_Architecture_Core_Spec_v2.01_r1.00
186 * Section: 6.3 Assigned UIDs
188 static const u8 opalmethod
[][OPAL_METHOD_LENGTH
] = {
190 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01 },
191 [OPAL_STARTSESSION
] =
192 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x02 },
194 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x02 },
196 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x03 },
198 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06 },
200 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07 },
202 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08 },
203 [OPAL_EAUTHENTICATE
] =
204 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c },
206 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d },
208 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10 },
210 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11 },
212 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16 },
214 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x17 },
215 [OPAL_AUTHENTICATE
] =
216 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1c },
218 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x01 },
220 { 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x08, 0x03 },
223 static int end_opal_session_error(struct opal_dev
*dev
);
224 static int opal_discovery0_step(struct opal_dev
*dev
);
226 struct opal_suspend_data
{
227 struct opal_lock_unlock unlk
;
229 struct list_head node
;
234 * TCG_Storage_Architecture_Core_Spec_v2.01_r1.00
235 * Section: 5.1.5 Method Status Codes
237 static const char * const opal_errors
[] = {
245 "No Sessions Available",
246 "Uniqueness Conflict",
247 "Insufficient Space",
254 "Transaction Failure",
256 "Authority Locked Out",
259 static const char *opal_error_to_human(int error
)
264 if (error
>= ARRAY_SIZE(opal_errors
) || error
< 0)
265 return "Unknown Error";
267 return opal_errors
[error
];
270 static void print_buffer(const u8
*ptr
, u32 length
)
273 print_hex_dump_bytes("OPAL: ", DUMP_PREFIX_OFFSET
, ptr
, length
);
279 * Allocate/update a SED Opal key and add it to the SED Opal keyring.
281 static int update_sed_opal_key(const char *desc
, u_char
*key_data
, int keylen
)
285 if (!sed_opal_keyring
)
288 kr
= key_create_or_update(make_key_ref(sed_opal_keyring
, true), "user",
289 desc
, (const void *)key_data
, keylen
,
290 KEY_USR_VIEW
| KEY_USR_SEARCH
| KEY_USR_WRITE
,
291 KEY_ALLOC_NOT_IN_QUOTA
| KEY_ALLOC_BUILT_IN
|
292 KEY_ALLOC_BYPASS_RESTRICTION
);
294 pr_err("Error adding SED key (%ld)\n", PTR_ERR(kr
));
302 * Read a SED Opal key from the SED Opal keyring.
304 static int read_sed_opal_key(const char *key_name
, u_char
*buffer
, int buflen
)
310 if (!sed_opal_keyring
)
313 kref
= keyring_search(make_key_ref(sed_opal_keyring
, true),
314 &key_type_user
, key_name
, true);
319 key
= key_ref_to_ptr(kref
);
320 down_read(&key
->sem
);
321 ret
= key_validate(key
);
323 if (buflen
> key
->datalen
)
324 buflen
= key
->datalen
;
326 ret
= key
->type
->read(key
, (char *)buffer
, buflen
);
335 static int opal_get_key(struct opal_dev
*dev
, struct opal_key
*key
)
339 switch (key
->key_type
) {
341 /* the key is ready to use */
344 /* the key is in the keyring */
345 ret
= read_sed_opal_key(OPAL_AUTH_KEY
, key
->key
, OPAL_KEY_MAX
);
352 key
->key_type
= OPAL_INCLUDED
;
362 /* must have a PEK by now or it's an error */
363 if (key
->key_type
!= OPAL_INCLUDED
|| key
->key_len
== 0) {
369 pr_debug("Error getting password: %d\n", ret
);
373 static bool check_tper(const void *data
)
375 const struct d0_tper_features
*tper
= data
;
376 u8 flags
= tper
->supported_features
;
378 if (!(flags
& TPER_SYNC_SUPPORTED
)) {
379 pr_debug("TPer sync not supported. flags = %d\n",
380 tper
->supported_features
);
387 static bool check_lcksuppt(const void *data
)
389 const struct d0_locking_features
*lfeat
= data
;
390 u8 sup_feat
= lfeat
->supported_features
;
392 return !!(sup_feat
& LOCKING_SUPPORTED_MASK
);
395 static bool check_lckenabled(const void *data
)
397 const struct d0_locking_features
*lfeat
= data
;
398 u8 sup_feat
= lfeat
->supported_features
;
400 return !!(sup_feat
& LOCKING_ENABLED_MASK
);
403 static bool check_locked(const void *data
)
405 const struct d0_locking_features
*lfeat
= data
;
406 u8 sup_feat
= lfeat
->supported_features
;
408 return !!(sup_feat
& LOCKED_MASK
);
411 static bool check_mbrenabled(const void *data
)
413 const struct d0_locking_features
*lfeat
= data
;
414 u8 sup_feat
= lfeat
->supported_features
;
416 return !!(sup_feat
& MBR_ENABLED_MASK
);
419 static bool check_mbrdone(const void *data
)
421 const struct d0_locking_features
*lfeat
= data
;
422 u8 sup_feat
= lfeat
->supported_features
;
424 return !!(sup_feat
& MBR_DONE_MASK
);
427 static bool check_sum(const void *data
)
429 const struct d0_single_user_mode
*sum
= data
;
430 u32 nlo
= be32_to_cpu(sum
->num_locking_objects
);
433 pr_debug("Need at least one locking object.\n");
437 pr_debug("Number of locking objects: %d\n", nlo
);
442 static u16
get_comid_v100(const void *data
)
444 const struct d0_opal_v100
*v100
= data
;
446 return be16_to_cpu(v100
->baseComID
);
449 static u16
get_comid_v200(const void *data
)
451 const struct d0_opal_v200
*v200
= data
;
453 return be16_to_cpu(v200
->baseComID
);
456 static int opal_send_cmd(struct opal_dev
*dev
)
458 return dev
->send_recv(dev
->data
, dev
->comid
, TCG_SECP_01
,
459 dev
->cmd
, IO_BUFFER_LENGTH
,
463 static int opal_recv_cmd(struct opal_dev
*dev
)
465 return dev
->send_recv(dev
->data
, dev
->comid
, TCG_SECP_01
,
466 dev
->resp
, IO_BUFFER_LENGTH
,
470 static int opal_recv_check(struct opal_dev
*dev
)
472 size_t buflen
= IO_BUFFER_LENGTH
;
473 void *buffer
= dev
->resp
;
474 struct opal_header
*hdr
= buffer
;
478 pr_debug("Sent OPAL command: outstanding=%d, minTransfer=%d\n",
479 hdr
->cp
.outstandingData
,
480 hdr
->cp
.minTransfer
);
482 if (hdr
->cp
.outstandingData
== 0 ||
483 hdr
->cp
.minTransfer
!= 0)
486 memset(buffer
, 0, buflen
);
487 ret
= opal_recv_cmd(dev
);
493 static int opal_send_recv(struct opal_dev
*dev
, cont_fn
*cont
)
497 ret
= opal_send_cmd(dev
);
500 ret
= opal_recv_cmd(dev
);
503 ret
= opal_recv_check(dev
);
509 static void check_geometry(struct opal_dev
*dev
, const void *data
)
511 const struct d0_geometry_features
*geo
= data
;
513 dev
->align
= be64_to_cpu(geo
->alignment_granularity
);
514 dev
->lowest_lba
= be64_to_cpu(geo
->lowest_aligned_lba
);
515 dev
->logical_block_size
= be32_to_cpu(geo
->logical_block_size
);
516 dev
->align_required
= geo
->reserved01
& 1;
519 static int execute_step(struct opal_dev
*dev
,
520 const struct opal_step
*step
, size_t stepIndex
)
522 int error
= step
->fn(dev
, step
->data
);
525 pr_debug("Step %zu (%pS) failed with error %d: %s\n",
526 stepIndex
, step
->fn
, error
,
527 opal_error_to_human(error
));
533 static int execute_steps(struct opal_dev
*dev
,
534 const struct opal_step
*steps
, size_t n_steps
)
539 /* first do a discovery0 */
540 error
= opal_discovery0_step(dev
);
544 for (state
= 0; state
< n_steps
; state
++) {
545 error
= execute_step(dev
, &steps
[state
], state
);
554 * For each OPAL command the first step in steps starts some sort of
555 * session. If an error occurred in the initial discovery0 or if an
556 * error occurred in the first step (and thus stopping the loop with
557 * state == 0) then there was an error before or during the attempt to
558 * start a session. Therefore we shouldn't attempt to terminate a
559 * session, as one has not yet been created.
562 end_opal_session_error(dev
);
567 static int opal_discovery0_end(struct opal_dev
*dev
, void *data
)
569 struct opal_discovery
*discv_out
= data
; /* may be NULL */
572 bool found_com_id
= false, supported
= true, single_user
= false;
573 const struct d0_header
*hdr
= (struct d0_header
*)dev
->resp
;
574 const u8
*epos
= dev
->resp
, *cpos
= dev
->resp
;
576 u32 hlen
= be32_to_cpu(hdr
->length
);
578 print_buffer(dev
->resp
, hlen
);
579 dev
->flags
&= OPAL_FL_SUPPORTED
;
581 if (hlen
> IO_BUFFER_LENGTH
- sizeof(*hdr
)) {
582 pr_debug("Discovery length overflows buffer (%zu+%u)/%u\n",
583 sizeof(*hdr
), hlen
, IO_BUFFER_LENGTH
);
588 buf_out
= (u8 __user
*)(uintptr_t)discv_out
->data
;
589 len_out
= min_t(u64
, discv_out
->size
, hlen
);
590 if (buf_out
&& copy_to_user(buf_out
, dev
->resp
, len_out
))
593 discv_out
->size
= hlen
; /* actual size of data */
596 epos
+= hlen
; /* end of buffer */
597 cpos
+= sizeof(*hdr
); /* current position on buffer */
599 while (cpos
< epos
&& supported
) {
600 const struct d0_features
*body
=
601 (const struct d0_features
*)cpos
;
603 switch (be16_to_cpu(body
->code
)) {
605 supported
= check_tper(body
->features
);
608 single_user
= check_sum(body
->features
);
610 dev
->flags
|= OPAL_FL_SUM_SUPPORTED
;
613 check_geometry(dev
, body
);
616 if (check_lcksuppt(body
->features
))
617 dev
->flags
|= OPAL_FL_LOCKING_SUPPORTED
;
618 if (check_lckenabled(body
->features
))
619 dev
->flags
|= OPAL_FL_LOCKING_ENABLED
;
620 if (check_locked(body
->features
))
621 dev
->flags
|= OPAL_FL_LOCKED
;
622 if (check_mbrenabled(body
->features
))
623 dev
->flags
|= OPAL_FL_MBR_ENABLED
;
624 if (check_mbrdone(body
->features
))
625 dev
->flags
|= OPAL_FL_MBR_DONE
;
629 /* some ignored properties */
630 pr_debug("Found OPAL feature description: %d\n",
631 be16_to_cpu(body
->code
));
634 comid
= get_comid_v100(body
->features
);
638 comid
= get_comid_v200(body
->features
);
641 case 0xbfff ... 0xffff:
642 /* vendor specific, just ignore */
645 pr_debug("OPAL Unknown feature: %d\n",
646 be16_to_cpu(body
->code
));
649 cpos
+= body
->length
+ 4;
653 pr_debug("This device is not Opal enabled. Not Supported!\n");
658 pr_debug("Device doesn't support single user mode\n");
662 pr_debug("Could not find OPAL comid for device. Returning early\n");
671 static int opal_discovery0(struct opal_dev
*dev
, void *data
)
675 memset(dev
->resp
, 0, IO_BUFFER_LENGTH
);
676 dev
->comid
= OPAL_DISCOVERY_COMID
;
677 ret
= opal_recv_cmd(dev
);
681 return opal_discovery0_end(dev
, data
);
684 static int opal_discovery0_step(struct opal_dev
*dev
)
686 const struct opal_step discovery0_step
= {
687 opal_discovery0
, NULL
690 return execute_step(dev
, &discovery0_step
, 0);
693 static size_t remaining_size(struct opal_dev
*cmd
)
695 return IO_BUFFER_LENGTH
- cmd
->pos
;
698 static bool can_add(int *err
, struct opal_dev
*cmd
, size_t len
)
703 if (remaining_size(cmd
) < len
) {
704 pr_debug("Error adding %zu bytes: end of buffer.\n", len
);
712 static void add_token_u8(int *err
, struct opal_dev
*cmd
, u8 tok
)
714 if (!can_add(err
, cmd
, 1))
717 cmd
->cmd
[cmd
->pos
++] = tok
;
720 static void add_short_atom_header(struct opal_dev
*cmd
, bool bytestring
,
721 bool has_sign
, int len
)
726 atom
= SHORT_ATOM_ID
;
727 atom
|= bytestring
? SHORT_ATOM_BYTESTRING
: 0;
728 atom
|= has_sign
? SHORT_ATOM_SIGNED
: 0;
729 atom
|= len
& SHORT_ATOM_LEN_MASK
;
731 add_token_u8(&err
, cmd
, atom
);
734 static void add_medium_atom_header(struct opal_dev
*cmd
, bool bytestring
,
735 bool has_sign
, int len
)
739 header0
= MEDIUM_ATOM_ID
;
740 header0
|= bytestring
? MEDIUM_ATOM_BYTESTRING
: 0;
741 header0
|= has_sign
? MEDIUM_ATOM_SIGNED
: 0;
742 header0
|= (len
>> 8) & MEDIUM_ATOM_LEN_MASK
;
744 cmd
->cmd
[cmd
->pos
++] = header0
;
745 cmd
->cmd
[cmd
->pos
++] = len
;
748 static void add_token_u64(int *err
, struct opal_dev
*cmd
, u64 number
)
753 if (!(number
& ~TINY_ATOM_DATA_MASK
)) {
754 add_token_u8(err
, cmd
, number
);
759 len
= DIV_ROUND_UP(msb
, 8);
761 if (!can_add(err
, cmd
, len
+ 1)) {
762 pr_debug("Error adding u64: end of buffer.\n");
765 add_short_atom_header(cmd
, false, false, len
);
767 add_token_u8(err
, cmd
, number
>> (len
* 8));
770 static u8
*add_bytestring_header(int *err
, struct opal_dev
*cmd
, size_t len
)
772 size_t header_len
= 1;
773 bool is_short_atom
= true;
775 if (len
& ~SHORT_ATOM_LEN_MASK
) {
777 is_short_atom
= false;
780 if (!can_add(err
, cmd
, header_len
+ len
)) {
781 pr_debug("Error adding bytestring: end of buffer.\n");
786 add_short_atom_header(cmd
, true, false, len
);
788 add_medium_atom_header(cmd
, true, false, len
);
790 return &cmd
->cmd
[cmd
->pos
];
793 static void add_token_bytestring(int *err
, struct opal_dev
*cmd
,
794 const u8
*bytestring
, size_t len
)
798 start
= add_bytestring_header(err
, cmd
, len
);
801 memcpy(start
, bytestring
, len
);
805 static int build_locking_range(u8
*buffer
, size_t length
, u8 lr
)
807 if (length
> OPAL_UID_LENGTH
) {
808 pr_debug("Can't build locking range. Length OOB\n");
812 memcpy(buffer
, opaluid
[OPAL_LOCKINGRANGE_GLOBAL
], OPAL_UID_LENGTH
);
817 buffer
[5] = LOCKING_RANGE_NON_GLOBAL
;
823 static int build_locking_user(u8
*buffer
, size_t length
, u8 lr
)
825 if (length
> OPAL_UID_LENGTH
) {
826 pr_debug("Can't build locking range user. Length OOB\n");
830 memcpy(buffer
, opaluid
[OPAL_USER1_UID
], OPAL_UID_LENGTH
);
837 static void set_comid(struct opal_dev
*cmd
, u16 comid
)
839 struct opal_header
*hdr
= (struct opal_header
*)cmd
->cmd
;
841 hdr
->cp
.extendedComID
[0] = comid
>> 8;
842 hdr
->cp
.extendedComID
[1] = comid
;
843 hdr
->cp
.extendedComID
[2] = 0;
844 hdr
->cp
.extendedComID
[3] = 0;
847 static int cmd_finalize(struct opal_dev
*cmd
, u32 hsn
, u32 tsn
)
849 struct opal_header
*hdr
;
853 * Close the parameter list opened from cmd_start.
854 * The number of bytes added must be equal to
855 * CMD_FINALIZE_BYTES_NEEDED.
857 add_token_u8(&err
, cmd
, OPAL_ENDLIST
);
859 add_token_u8(&err
, cmd
, OPAL_ENDOFDATA
);
860 add_token_u8(&err
, cmd
, OPAL_STARTLIST
);
861 add_token_u8(&err
, cmd
, 0);
862 add_token_u8(&err
, cmd
, 0);
863 add_token_u8(&err
, cmd
, 0);
864 add_token_u8(&err
, cmd
, OPAL_ENDLIST
);
867 pr_debug("Error finalizing command.\n");
871 hdr
= (struct opal_header
*) cmd
->cmd
;
873 hdr
->pkt
.tsn
= cpu_to_be32(tsn
);
874 hdr
->pkt
.hsn
= cpu_to_be32(hsn
);
876 hdr
->subpkt
.length
= cpu_to_be32(cmd
->pos
- sizeof(*hdr
));
877 while (cmd
->pos
% 4) {
878 if (cmd
->pos
>= IO_BUFFER_LENGTH
) {
879 pr_debug("Error: Buffer overrun\n");
882 cmd
->cmd
[cmd
->pos
++] = 0;
884 hdr
->pkt
.length
= cpu_to_be32(cmd
->pos
- sizeof(hdr
->cp
) -
886 hdr
->cp
.length
= cpu_to_be32(cmd
->pos
- sizeof(hdr
->cp
));
891 static const struct opal_resp_tok
*response_get_token(
892 const struct parsed_resp
*resp
,
895 const struct opal_resp_tok
*tok
;
898 pr_debug("Response is NULL\n");
899 return ERR_PTR(-EINVAL
);
902 if (n
>= resp
->num
) {
903 pr_debug("Token number doesn't exist: %d, resp: %d\n",
905 return ERR_PTR(-EINVAL
);
908 tok
= &resp
->toks
[n
];
910 pr_debug("Token length must be non-zero\n");
911 return ERR_PTR(-EINVAL
);
917 static ssize_t
response_parse_tiny(struct opal_resp_tok
*tok
,
922 tok
->width
= OPAL_WIDTH_TINY
;
924 if (pos
[0] & TINY_ATOM_SIGNED
) {
925 tok
->type
= OPAL_DTA_TOKENID_SINT
;
927 tok
->type
= OPAL_DTA_TOKENID_UINT
;
928 tok
->stored
.u
= pos
[0] & 0x3f;
934 static ssize_t
response_parse_short(struct opal_resp_tok
*tok
,
938 tok
->len
= (pos
[0] & SHORT_ATOM_LEN_MASK
) + 1;
939 tok
->width
= OPAL_WIDTH_SHORT
;
941 if (pos
[0] & SHORT_ATOM_BYTESTRING
) {
942 tok
->type
= OPAL_DTA_TOKENID_BYTESTRING
;
943 } else if (pos
[0] & SHORT_ATOM_SIGNED
) {
944 tok
->type
= OPAL_DTA_TOKENID_SINT
;
949 tok
->type
= OPAL_DTA_TOKENID_UINT
;
951 pr_debug("uint64 with more than 8 bytes\n");
954 for (i
= tok
->len
- 1; i
> 0; i
--) {
955 u_integer
|= ((u64
)pos
[i
] << (8 * b
));
958 tok
->stored
.u
= u_integer
;
964 static ssize_t
response_parse_medium(struct opal_resp_tok
*tok
,
968 tok
->len
= (((pos
[0] & MEDIUM_ATOM_LEN_MASK
) << 8) | pos
[1]) + 2;
969 tok
->width
= OPAL_WIDTH_MEDIUM
;
971 if (pos
[0] & MEDIUM_ATOM_BYTESTRING
)
972 tok
->type
= OPAL_DTA_TOKENID_BYTESTRING
;
973 else if (pos
[0] & MEDIUM_ATOM_SIGNED
)
974 tok
->type
= OPAL_DTA_TOKENID_SINT
;
976 tok
->type
= OPAL_DTA_TOKENID_UINT
;
981 static ssize_t
response_parse_long(struct opal_resp_tok
*tok
,
985 tok
->len
= ((pos
[1] << 16) | (pos
[2] << 8) | pos
[3]) + 4;
986 tok
->width
= OPAL_WIDTH_LONG
;
988 if (pos
[0] & LONG_ATOM_BYTESTRING
)
989 tok
->type
= OPAL_DTA_TOKENID_BYTESTRING
;
990 else if (pos
[0] & LONG_ATOM_SIGNED
)
991 tok
->type
= OPAL_DTA_TOKENID_SINT
;
993 tok
->type
= OPAL_DTA_TOKENID_UINT
;
998 static ssize_t
response_parse_token(struct opal_resp_tok
*tok
,
1003 tok
->type
= OPAL_DTA_TOKENID_TOKEN
;
1004 tok
->width
= OPAL_WIDTH_TOKEN
;
1009 static int response_parse(const u8
*buf
, size_t length
,
1010 struct parsed_resp
*resp
)
1012 const struct opal_header
*hdr
;
1013 struct opal_resp_tok
*iter
;
1014 int num_entries
= 0;
1016 ssize_t token_length
;
1018 u32 clen
, plen
, slen
;
1026 hdr
= (struct opal_header
*)buf
;
1028 pos
+= sizeof(*hdr
);
1030 clen
= be32_to_cpu(hdr
->cp
.length
);
1031 plen
= be32_to_cpu(hdr
->pkt
.length
);
1032 slen
= be32_to_cpu(hdr
->subpkt
.length
);
1033 pr_debug("Response size: cp: %u, pkt: %u, subpkt: %u\n",
1036 if (clen
== 0 || plen
== 0 || slen
== 0 ||
1037 slen
> IO_BUFFER_LENGTH
- sizeof(*hdr
)) {
1038 pr_debug("Bad header length. cp: %u, pkt: %u, subpkt: %u\n",
1040 print_buffer(pos
, sizeof(*hdr
));
1044 if (pos
> buf
+ length
)
1049 print_buffer(pos
, total
);
1051 if (pos
[0] <= TINY_ATOM_BYTE
) /* tiny atom */
1052 token_length
= response_parse_tiny(iter
, pos
);
1053 else if (pos
[0] <= SHORT_ATOM_BYTE
) /* short atom */
1054 token_length
= response_parse_short(iter
, pos
);
1055 else if (pos
[0] <= MEDIUM_ATOM_BYTE
) /* medium atom */
1056 token_length
= response_parse_medium(iter
, pos
);
1057 else if (pos
[0] <= LONG_ATOM_BYTE
) /* long atom */
1058 token_length
= response_parse_long(iter
, pos
);
1060 token_length
= response_parse_token(iter
, pos
);
1062 if (token_length
< 0)
1063 return token_length
;
1065 pos
+= token_length
;
1066 total
-= token_length
;
1071 resp
->num
= num_entries
;
1076 static size_t response_get_string(const struct parsed_resp
*resp
, int n
,
1080 const struct opal_resp_tok
*tok
;
1083 tok
= response_get_token(resp
, n
);
1087 if (tok
->type
!= OPAL_DTA_TOKENID_BYTESTRING
) {
1088 pr_debug("Token is not a byte string!\n");
1092 switch (tok
->width
) {
1093 case OPAL_WIDTH_TINY
:
1094 case OPAL_WIDTH_SHORT
:
1097 case OPAL_WIDTH_MEDIUM
:
1100 case OPAL_WIDTH_LONG
:
1104 pr_debug("Token has invalid width!\n");
1108 *store
= tok
->pos
+ skip
;
1110 return tok
->len
- skip
;
1113 static u64
response_get_u64(const struct parsed_resp
*resp
, int n
)
1115 const struct opal_resp_tok
*tok
;
1117 tok
= response_get_token(resp
, n
);
1121 if (tok
->type
!= OPAL_DTA_TOKENID_UINT
) {
1122 pr_debug("Token is not unsigned int: %d\n", tok
->type
);
1126 if (tok
->width
!= OPAL_WIDTH_TINY
&& tok
->width
!= OPAL_WIDTH_SHORT
) {
1127 pr_debug("Atom is not short or tiny: %d\n", tok
->width
);
1131 return tok
->stored
.u
;
1134 static bool response_token_matches(const struct opal_resp_tok
*token
, u8 match
)
1136 if (IS_ERR(token
) ||
1137 token
->type
!= OPAL_DTA_TOKENID_TOKEN
||
1138 token
->pos
[0] != match
)
1143 static u8
response_status(const struct parsed_resp
*resp
)
1145 const struct opal_resp_tok
*tok
;
1147 tok
= response_get_token(resp
, 0);
1148 if (response_token_matches(tok
, OPAL_ENDOFSESSION
))
1152 return DTAERROR_NO_METHOD_STATUS
;
1154 tok
= response_get_token(resp
, resp
->num
- 5);
1155 if (!response_token_matches(tok
, OPAL_STARTLIST
))
1156 return DTAERROR_NO_METHOD_STATUS
;
1158 tok
= response_get_token(resp
, resp
->num
- 1);
1159 if (!response_token_matches(tok
, OPAL_ENDLIST
))
1160 return DTAERROR_NO_METHOD_STATUS
;
1162 return response_get_u64(resp
, resp
->num
- 4);
1165 /* Parses and checks for errors */
1166 static int parse_and_check_status(struct opal_dev
*dev
)
1170 print_buffer(dev
->cmd
, dev
->pos
);
1172 error
= response_parse(dev
->resp
, IO_BUFFER_LENGTH
, &dev
->parsed
);
1174 pr_debug("Couldn't parse response.\n");
1178 return response_status(&dev
->parsed
);
1181 static void clear_opal_cmd(struct opal_dev
*dev
)
1183 dev
->pos
= sizeof(struct opal_header
);
1184 memset(dev
->cmd
, 0, IO_BUFFER_LENGTH
);
1187 static int cmd_start(struct opal_dev
*dev
, const u8
*uid
, const u8
*method
)
1191 clear_opal_cmd(dev
);
1192 set_comid(dev
, dev
->comid
);
1194 add_token_u8(&err
, dev
, OPAL_CALL
);
1195 add_token_bytestring(&err
, dev
, uid
, OPAL_UID_LENGTH
);
1196 add_token_bytestring(&err
, dev
, method
, OPAL_METHOD_LENGTH
);
1199 * Every method call is followed by its parameters enclosed within
1200 * OPAL_STARTLIST and OPAL_ENDLIST tokens. We automatically open the
1201 * parameter list here and close it later in cmd_finalize.
1203 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1208 static int start_opal_session_cont(struct opal_dev
*dev
)
1213 error
= parse_and_check_status(dev
);
1217 hsn
= response_get_u64(&dev
->parsed
, 4);
1218 tsn
= response_get_u64(&dev
->parsed
, 5);
1220 if (hsn
!= GENERIC_HOST_SESSION_NUM
|| tsn
< FIRST_TPER_SESSION_NUM
) {
1221 pr_debug("Couldn't authenticate session\n");
1231 static void add_suspend_info(struct opal_dev
*dev
,
1232 struct opal_suspend_data
*sus
)
1234 struct opal_suspend_data
*iter
;
1236 list_for_each_entry(iter
, &dev
->unlk_lst
, node
) {
1237 if (iter
->lr
== sus
->lr
) {
1238 list_del(&iter
->node
);
1243 list_add_tail(&sus
->node
, &dev
->unlk_lst
);
1246 static int end_session_cont(struct opal_dev
*dev
)
1251 return parse_and_check_status(dev
);
1254 static int finalize_and_send(struct opal_dev
*dev
, cont_fn cont
)
1258 ret
= cmd_finalize(dev
, dev
->hsn
, dev
->tsn
);
1260 pr_debug("Error finalizing command buffer: %d\n", ret
);
1264 print_buffer(dev
->cmd
, dev
->pos
);
1266 return opal_send_recv(dev
, cont
);
1269 static int generic_get_columns(struct opal_dev
*dev
, const u8
*table
,
1270 u64 start_column
, u64 end_column
)
1274 err
= cmd_start(dev
, table
, opalmethod
[OPAL_GET
]);
1276 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1278 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1279 add_token_u8(&err
, dev
, OPAL_STARTCOLUMN
);
1280 add_token_u64(&err
, dev
, start_column
);
1281 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1283 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1284 add_token_u8(&err
, dev
, OPAL_ENDCOLUMN
);
1285 add_token_u64(&err
, dev
, end_column
);
1286 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1288 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1293 return finalize_and_send(dev
, parse_and_check_status
);
1297 * request @column from table @table on device @dev. On success, the column
1298 * data will be available in dev->resp->tok[4]
1300 static int generic_get_column(struct opal_dev
*dev
, const u8
*table
,
1303 return generic_get_columns(dev
, table
, column
, column
);
1307 * see TCG SAS 5.3.2.3 for a description of the available columns
1309 * the result is provided in dev->resp->tok[4]
1311 static int generic_get_table_info(struct opal_dev
*dev
, const u8
*table_uid
,
1314 u8 uid
[OPAL_UID_LENGTH
];
1315 const unsigned int half
= OPAL_UID_LENGTH_HALF
;
1317 /* sed-opal UIDs can be split in two halves:
1318 * first: actual table index
1319 * second: relative index in the table
1320 * so we have to get the first half of the OPAL_TABLE_TABLE and use the
1321 * first part of the target table as relative index into that table
1323 memcpy(uid
, opaluid
[OPAL_TABLE_TABLE
], half
);
1324 memcpy(uid
+ half
, table_uid
, half
);
1326 return generic_get_column(dev
, uid
, column
);
1329 static int gen_key(struct opal_dev
*dev
, void *data
)
1331 u8 uid
[OPAL_UID_LENGTH
];
1334 memcpy(uid
, dev
->prev_data
, min(sizeof(uid
), dev
->prev_d_len
));
1335 kfree(dev
->prev_data
);
1336 dev
->prev_data
= NULL
;
1338 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_GENKEY
]);
1341 pr_debug("Error building gen key command\n");
1346 return finalize_and_send(dev
, parse_and_check_status
);
1349 static int get_active_key_cont(struct opal_dev
*dev
)
1351 const char *activekey
;
1355 error
= parse_and_check_status(dev
);
1359 keylen
= response_get_string(&dev
->parsed
, 4, &activekey
);
1361 pr_debug("%s: Couldn't extract the Activekey from the response\n",
1363 return OPAL_INVAL_PARAM
;
1366 dev
->prev_data
= kmemdup(activekey
, keylen
, GFP_KERNEL
);
1368 if (!dev
->prev_data
)
1371 dev
->prev_d_len
= keylen
;
1376 static int get_active_key(struct opal_dev
*dev
, void *data
)
1378 u8 uid
[OPAL_UID_LENGTH
];
1382 err
= build_locking_range(uid
, sizeof(uid
), *lr
);
1386 err
= generic_get_column(dev
, uid
, OPAL_ACTIVEKEY
);
1390 return get_active_key_cont(dev
);
1393 static int generic_table_write_data(struct opal_dev
*dev
, const u64 data
,
1394 u64 offset
, u64 size
, const u8
*uid
)
1396 const u8 __user
*src
= (u8 __user
*)(uintptr_t)data
;
1402 /* do we fit in the available space? */
1403 err
= generic_get_table_info(dev
, uid
, OPAL_TABLE_ROWS
);
1405 pr_debug("Couldn't get the table size\n");
1409 len
= response_get_u64(&dev
->parsed
, 4);
1410 if (size
> len
|| offset
> len
- size
) {
1411 pr_debug("Does not fit in the table (%llu vs. %llu)\n",
1412 offset
+ size
, len
);
1416 /* do the actual transmission(s) */
1417 while (off
< size
) {
1418 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_SET
]);
1419 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1420 add_token_u8(&err
, dev
, OPAL_WHERE
);
1421 add_token_u64(&err
, dev
, offset
+ off
);
1422 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1424 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1425 add_token_u8(&err
, dev
, OPAL_VALUES
);
1428 * The bytestring header is either 1 or 2 bytes, so assume 2.
1429 * There also needs to be enough space to accommodate the
1430 * trailing OPAL_ENDNAME (1 byte) and tokens added by
1433 len
= min(remaining_size(dev
) - (2+1+CMD_FINALIZE_BYTES_NEEDED
),
1434 (size_t)(size
- off
));
1435 pr_debug("Write bytes %zu+%llu/%llu\n", off
, len
, size
);
1437 dst
= add_bytestring_header(&err
, dev
, len
);
1441 if (copy_from_user(dst
, src
+ off
, len
)) {
1448 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1452 err
= finalize_and_send(dev
, parse_and_check_status
);
1462 static int generic_lr_enable_disable(struct opal_dev
*dev
,
1463 u8
*uid
, bool rle
, bool wle
,
1468 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_SET
]);
1470 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1471 add_token_u8(&err
, dev
, OPAL_VALUES
);
1472 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1474 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1475 add_token_u8(&err
, dev
, OPAL_READLOCKENABLED
);
1476 add_token_u8(&err
, dev
, rle
);
1477 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1479 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1480 add_token_u8(&err
, dev
, OPAL_WRITELOCKENABLED
);
1481 add_token_u8(&err
, dev
, wle
);
1482 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1484 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1485 add_token_u8(&err
, dev
, OPAL_READLOCKED
);
1486 add_token_u8(&err
, dev
, rl
);
1487 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1489 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1490 add_token_u8(&err
, dev
, OPAL_WRITELOCKED
);
1491 add_token_u8(&err
, dev
, wl
);
1492 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1494 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1495 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1500 static inline int enable_global_lr(struct opal_dev
*dev
, u8
*uid
,
1501 struct opal_user_lr_setup
*setup
)
1505 err
= generic_lr_enable_disable(dev
, uid
, !!setup
->RLE
, !!setup
->WLE
,
1508 pr_debug("Failed to create enable global lr command\n");
1513 static int setup_locking_range(struct opal_dev
*dev
, void *data
)
1515 u8 uid
[OPAL_UID_LENGTH
];
1516 struct opal_user_lr_setup
*setup
= data
;
1520 lr
= setup
->session
.opal_key
.lr
;
1521 err
= build_locking_range(uid
, sizeof(uid
), lr
);
1526 err
= enable_global_lr(dev
, uid
, setup
);
1528 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_SET
]);
1530 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1531 add_token_u8(&err
, dev
, OPAL_VALUES
);
1532 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1534 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1535 add_token_u8(&err
, dev
, OPAL_RANGESTART
);
1536 add_token_u64(&err
, dev
, setup
->range_start
);
1537 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1539 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1540 add_token_u8(&err
, dev
, OPAL_RANGELENGTH
);
1541 add_token_u64(&err
, dev
, setup
->range_length
);
1542 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1544 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1545 add_token_u8(&err
, dev
, OPAL_READLOCKENABLED
);
1546 add_token_u64(&err
, dev
, !!setup
->RLE
);
1547 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1549 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1550 add_token_u8(&err
, dev
, OPAL_WRITELOCKENABLED
);
1551 add_token_u64(&err
, dev
, !!setup
->WLE
);
1552 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1554 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1555 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1558 pr_debug("Error building Setup Locking range command.\n");
1562 return finalize_and_send(dev
, parse_and_check_status
);
1565 static int response_get_column(const struct parsed_resp
*resp
,
1570 const struct opal_resp_tok
*tok
;
1574 tok
= response_get_token(resp
, n
);
1576 return PTR_ERR(tok
);
1578 if (!response_token_matches(tok
, OPAL_STARTNAME
)) {
1579 pr_debug("Unexpected response token type %d.\n", n
);
1580 return OPAL_INVAL_PARAM
;
1584 if (response_get_u64(resp
, n
) != column
) {
1585 pr_debug("Token %d does not match expected column %u.\n",
1587 return OPAL_INVAL_PARAM
;
1591 val
= response_get_u64(resp
, n
);
1594 tok
= response_get_token(resp
, n
);
1596 return PTR_ERR(tok
);
1598 if (!response_token_matches(tok
, OPAL_ENDNAME
)) {
1599 pr_debug("Unexpected response token type %d.\n", n
);
1600 return OPAL_INVAL_PARAM
;
1610 static int locking_range_status(struct opal_dev
*dev
, void *data
)
1612 u8 lr_buffer
[OPAL_UID_LENGTH
];
1614 bool rlocked
, wlocked
;
1616 struct opal_lr_status
*lrst
= data
;
1618 err
= build_locking_range(lr_buffer
, sizeof(lr_buffer
),
1619 lrst
->session
.opal_key
.lr
);
1623 err
= generic_get_columns(dev
, lr_buffer
, OPAL_RANGESTART
,
1626 pr_debug("Couldn't get lr %u table columns %d to %d.\n",
1627 lrst
->session
.opal_key
.lr
, OPAL_RANGESTART
,
1633 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_RANGESTART
,
1634 &lrst
->range_start
);
1639 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_RANGELENGTH
,
1640 &lrst
->range_length
);
1645 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_READLOCKENABLED
,
1653 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_WRITELOCKENABLED
,
1661 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_READLOCKED
, &resp
);
1668 err
= response_get_column(&dev
->parsed
, &tok_n
, OPAL_WRITELOCKED
, &resp
);
1674 /* opal_lock_state can not map 'read locked' only state. */
1675 lrst
->l_state
= OPAL_RW
;
1676 if (rlocked
&& wlocked
)
1677 lrst
->l_state
= OPAL_LK
;
1679 lrst
->l_state
= OPAL_RO
;
1681 pr_debug("Can not report read locked only state.\n");
1688 static int start_generic_opal_session(struct opal_dev
*dev
,
1690 enum opal_uid sp_type
,
1697 if (key
== NULL
&& auth
!= OPAL_ANYBODY_UID
)
1698 return OPAL_INVAL_PARAM
;
1700 hsn
= GENERIC_HOST_SESSION_NUM
;
1701 err
= cmd_start(dev
, opaluid
[OPAL_SMUID_UID
],
1702 opalmethod
[OPAL_STARTSESSION
]);
1704 add_token_u64(&err
, dev
, hsn
);
1705 add_token_bytestring(&err
, dev
, opaluid
[sp_type
], OPAL_UID_LENGTH
);
1706 add_token_u8(&err
, dev
, 1);
1709 case OPAL_ANYBODY_UID
:
1711 case OPAL_ADMIN1_UID
:
1714 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1715 add_token_u8(&err
, dev
, 0); /* HostChallenge */
1716 add_token_bytestring(&err
, dev
, key
, key_len
);
1717 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1718 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1719 add_token_u8(&err
, dev
, 3); /* HostSignAuth */
1720 add_token_bytestring(&err
, dev
, opaluid
[auth
],
1722 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1725 pr_debug("Cannot start Admin SP session with auth %d\n", auth
);
1726 return OPAL_INVAL_PARAM
;
1730 pr_debug("Error building start adminsp session command.\n");
1734 return finalize_and_send(dev
, start_opal_session_cont
);
1737 static int start_anybodyASP_opal_session(struct opal_dev
*dev
, void *data
)
1739 return start_generic_opal_session(dev
, OPAL_ANYBODY_UID
,
1740 OPAL_ADMINSP_UID
, NULL
, 0);
1743 static int start_SIDASP_opal_session(struct opal_dev
*dev
, void *data
)
1746 const u8
*key
= dev
->prev_data
;
1749 const struct opal_key
*okey
= data
;
1751 ret
= start_generic_opal_session(dev
, OPAL_SID_UID
,
1756 ret
= start_generic_opal_session(dev
, OPAL_SID_UID
,
1758 key
, dev
->prev_d_len
);
1760 dev
->prev_data
= NULL
;
1766 static int start_admin1LSP_opal_session(struct opal_dev
*dev
, void *data
)
1768 struct opal_key
*key
= data
;
1770 return start_generic_opal_session(dev
, OPAL_ADMIN1_UID
,
1772 key
->key
, key
->key_len
);
1775 static int start_PSID_opal_session(struct opal_dev
*dev
, void *data
)
1777 const struct opal_key
*okey
= data
;
1779 return start_generic_opal_session(dev
, OPAL_PSID_UID
,
1785 static int start_auth_opal_session(struct opal_dev
*dev
, void *data
)
1787 struct opal_session_info
*session
= data
;
1788 u8 lk_ul_user
[OPAL_UID_LENGTH
];
1789 size_t keylen
= session
->opal_key
.key_len
;
1792 u8
*key
= session
->opal_key
.key
;
1793 u32 hsn
= GENERIC_HOST_SESSION_NUM
;
1796 err
= build_locking_user(lk_ul_user
, sizeof(lk_ul_user
),
1797 session
->opal_key
.lr
);
1798 else if (session
->who
!= OPAL_ADMIN1
&& !session
->sum
)
1799 err
= build_locking_user(lk_ul_user
, sizeof(lk_ul_user
),
1802 memcpy(lk_ul_user
, opaluid
[OPAL_ADMIN1_UID
], OPAL_UID_LENGTH
);
1807 err
= cmd_start(dev
, opaluid
[OPAL_SMUID_UID
],
1808 opalmethod
[OPAL_STARTSESSION
]);
1810 add_token_u64(&err
, dev
, hsn
);
1811 add_token_bytestring(&err
, dev
, opaluid
[OPAL_LOCKINGSP_UID
],
1813 add_token_u8(&err
, dev
, 1);
1814 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1815 add_token_u8(&err
, dev
, 0);
1816 add_token_bytestring(&err
, dev
, key
, keylen
);
1817 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1818 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1819 add_token_u8(&err
, dev
, 3);
1820 add_token_bytestring(&err
, dev
, lk_ul_user
, OPAL_UID_LENGTH
);
1821 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1824 pr_debug("Error building STARTSESSION command.\n");
1828 return finalize_and_send(dev
, start_opal_session_cont
);
1831 static int revert_tper(struct opal_dev
*dev
, void *data
)
1835 err
= cmd_start(dev
, opaluid
[OPAL_ADMINSP_UID
],
1836 opalmethod
[OPAL_REVERT
]);
1838 pr_debug("Error building REVERT TPER command.\n");
1842 return finalize_and_send(dev
, parse_and_check_status
);
1845 static int internal_activate_user(struct opal_dev
*dev
, void *data
)
1847 struct opal_session_info
*session
= data
;
1848 u8 uid
[OPAL_UID_LENGTH
];
1851 memcpy(uid
, opaluid
[OPAL_USER1_UID
], OPAL_UID_LENGTH
);
1852 uid
[7] = session
->who
;
1854 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_SET
]);
1855 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1856 add_token_u8(&err
, dev
, OPAL_VALUES
);
1857 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1858 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1859 add_token_u8(&err
, dev
, 5); /* Enabled */
1860 add_token_u8(&err
, dev
, OPAL_TRUE
);
1861 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1862 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1863 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1866 pr_debug("Error building Activate UserN command.\n");
1870 return finalize_and_send(dev
, parse_and_check_status
);
1873 static int revert_lsp(struct opal_dev
*dev
, void *data
)
1875 struct opal_revert_lsp
*rev
= data
;
1878 err
= cmd_start(dev
, opaluid
[OPAL_THISSP_UID
],
1879 opalmethod
[OPAL_REVERTSP
]);
1880 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1881 add_token_u64(&err
, dev
, OPAL_KEEP_GLOBAL_RANGE_KEY
);
1882 add_token_u8(&err
, dev
, (rev
->options
& OPAL_PRESERVE
) ?
1883 OPAL_TRUE
: OPAL_FALSE
);
1884 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1886 pr_debug("Error building REVERT SP command.\n");
1890 return finalize_and_send(dev
, parse_and_check_status
);
1893 static int erase_locking_range(struct opal_dev
*dev
, void *data
)
1895 struct opal_session_info
*session
= data
;
1896 u8 uid
[OPAL_UID_LENGTH
];
1899 if (build_locking_range(uid
, sizeof(uid
), session
->opal_key
.lr
) < 0)
1902 err
= cmd_start(dev
, uid
, opalmethod
[OPAL_ERASE
]);
1905 pr_debug("Error building Erase Locking Range Command.\n");
1909 return finalize_and_send(dev
, parse_and_check_status
);
1912 static int set_mbr_done(struct opal_dev
*dev
, void *data
)
1914 u8
*mbr_done_tf
= data
;
1917 err
= cmd_start(dev
, opaluid
[OPAL_MBRCONTROL
],
1918 opalmethod
[OPAL_SET
]);
1920 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1921 add_token_u8(&err
, dev
, OPAL_VALUES
);
1922 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1923 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1924 add_token_u8(&err
, dev
, OPAL_MBRDONE
);
1925 add_token_u8(&err
, dev
, *mbr_done_tf
); /* Done T or F */
1926 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1927 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1928 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1931 pr_debug("Error Building set MBR Done command\n");
1935 return finalize_and_send(dev
, parse_and_check_status
);
1938 static int set_mbr_enable_disable(struct opal_dev
*dev
, void *data
)
1940 u8
*mbr_en_dis
= data
;
1943 err
= cmd_start(dev
, opaluid
[OPAL_MBRCONTROL
],
1944 opalmethod
[OPAL_SET
]);
1946 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1947 add_token_u8(&err
, dev
, OPAL_VALUES
);
1948 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1949 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1950 add_token_u8(&err
, dev
, OPAL_MBRENABLE
);
1951 add_token_u8(&err
, dev
, *mbr_en_dis
);
1952 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1953 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1954 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1957 pr_debug("Error Building set MBR done command\n");
1961 return finalize_and_send(dev
, parse_and_check_status
);
1964 static int write_shadow_mbr(struct opal_dev
*dev
, void *data
)
1966 struct opal_shadow_mbr
*shadow
= data
;
1968 return generic_table_write_data(dev
, shadow
->data
, shadow
->offset
,
1969 shadow
->size
, opaluid
[OPAL_MBR
]);
1972 static int generic_pw_cmd(u8
*key
, size_t key_len
, u8
*cpin_uid
,
1973 struct opal_dev
*dev
)
1977 err
= cmd_start(dev
, cpin_uid
, opalmethod
[OPAL_SET
]);
1979 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1980 add_token_u8(&err
, dev
, OPAL_VALUES
);
1981 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
1982 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
1983 add_token_u8(&err
, dev
, OPAL_PIN
);
1984 add_token_bytestring(&err
, dev
, key
, key_len
);
1985 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1986 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
1987 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
1992 static int set_new_pw(struct opal_dev
*dev
, void *data
)
1994 u8 cpin_uid
[OPAL_UID_LENGTH
];
1995 struct opal_session_info
*usr
= data
;
1997 memcpy(cpin_uid
, opaluid
[OPAL_C_PIN_ADMIN1
], OPAL_UID_LENGTH
);
1999 if (usr
->who
!= OPAL_ADMIN1
) {
2002 cpin_uid
[7] = usr
->opal_key
.lr
+ 1;
2004 cpin_uid
[7] = usr
->who
;
2007 if (generic_pw_cmd(usr
->opal_key
.key
, usr
->opal_key
.key_len
,
2009 pr_debug("Error building set password command.\n");
2013 return finalize_and_send(dev
, parse_and_check_status
);
2016 static int set_sid_cpin_pin(struct opal_dev
*dev
, void *data
)
2018 u8 cpin_uid
[OPAL_UID_LENGTH
];
2019 struct opal_key
*key
= data
;
2021 memcpy(cpin_uid
, opaluid
[OPAL_C_PIN_SID
], OPAL_UID_LENGTH
);
2023 if (generic_pw_cmd(key
->key
, key
->key_len
, cpin_uid
, dev
)) {
2024 pr_debug("Error building Set SID cpin\n");
2027 return finalize_and_send(dev
, parse_and_check_status
);
2030 static void add_authority_object_ref(int *err
,
2031 struct opal_dev
*dev
,
2035 add_token_u8(err
, dev
, OPAL_STARTNAME
);
2036 add_token_bytestring(err
, dev
,
2037 opaluid
[OPAL_HALF_UID_AUTHORITY_OBJ_REF
],
2039 add_token_bytestring(err
, dev
, uid
, uid_len
);
2040 add_token_u8(err
, dev
, OPAL_ENDNAME
);
2043 static void add_boolean_object_ref(int *err
,
2044 struct opal_dev
*dev
,
2047 add_token_u8(err
, dev
, OPAL_STARTNAME
);
2048 add_token_bytestring(err
, dev
, opaluid
[OPAL_HALF_UID_BOOLEAN_ACE
],
2050 add_token_u8(err
, dev
, boolean_op
);
2051 add_token_u8(err
, dev
, OPAL_ENDNAME
);
2054 static int set_lr_boolean_ace(struct opal_dev
*dev
,
2055 unsigned int opal_uid
,
2060 u8 lr_buffer
[OPAL_UID_LENGTH
];
2061 u8 user_uid
[OPAL_UID_LENGTH
];
2065 memcpy(lr_buffer
, opaluid
[opal_uid
], OPAL_UID_LENGTH
);
2068 err
= cmd_start(dev
, lr_buffer
, opalmethod
[OPAL_SET
]);
2070 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2071 add_token_u8(&err
, dev
, OPAL_VALUES
);
2073 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
2074 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2075 add_token_u8(&err
, dev
, 3);
2077 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
2079 for (u
= 0; u
< users_len
; u
++) {
2080 if (users
[u
] == OPAL_ADMIN1
)
2081 memcpy(user_uid
, opaluid
[OPAL_ADMIN1_UID
],
2084 memcpy(user_uid
, opaluid
[OPAL_USER1_UID
],
2086 user_uid
[7] = users
[u
];
2089 add_authority_object_ref(&err
, dev
, user_uid
, sizeof(user_uid
));
2092 * Add boolean operator in postfix only with
2093 * two or more authorities being added in ACE
2097 add_boolean_object_ref(&err
, dev
, OPAL_BOOLEAN_OR
);
2100 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
2101 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2102 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
2103 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2108 static int add_user_to_lr(struct opal_dev
*dev
, void *data
)
2111 struct opal_lock_unlock
*lkul
= data
;
2112 const u8 users
[] = {
2116 err
= set_lr_boolean_ace(dev
,
2117 lkul
->l_state
== OPAL_RW
?
2118 OPAL_LOCKINGRANGE_ACE_WRLOCKED
:
2119 OPAL_LOCKINGRANGE_ACE_RDLOCKED
,
2120 lkul
->session
.opal_key
.lr
, users
,
2123 pr_debug("Error building add user to locking range command.\n");
2127 return finalize_and_send(dev
, parse_and_check_status
);
2130 static int add_user_to_lr_ace(struct opal_dev
*dev
, void *data
)
2133 struct opal_lock_unlock
*lkul
= data
;
2134 const u8 users
[] = {
2139 err
= set_lr_boolean_ace(dev
, OPAL_LOCKINGRANGE_ACE_START_TO_KEY
,
2140 lkul
->session
.opal_key
.lr
, users
,
2144 pr_debug("Error building add user to locking ranges ACEs.\n");
2148 return finalize_and_send(dev
, parse_and_check_status
);
2151 static int lock_unlock_locking_range(struct opal_dev
*dev
, void *data
)
2153 u8 lr_buffer
[OPAL_UID_LENGTH
];
2154 struct opal_lock_unlock
*lkul
= data
;
2155 u8 read_locked
= 1, write_locked
= 1;
2158 if (build_locking_range(lr_buffer
, sizeof(lr_buffer
),
2159 lkul
->session
.opal_key
.lr
) < 0)
2162 switch (lkul
->l_state
) {
2172 /* vars are initialized to locked */
2175 pr_debug("Tried to set an invalid locking state... returning to uland\n");
2176 return OPAL_INVAL_PARAM
;
2179 err
= cmd_start(dev
, lr_buffer
, opalmethod
[OPAL_SET
]);
2181 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2182 add_token_u8(&err
, dev
, OPAL_VALUES
);
2183 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
2185 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2186 add_token_u8(&err
, dev
, OPAL_READLOCKED
);
2187 add_token_u8(&err
, dev
, read_locked
);
2188 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2190 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2191 add_token_u8(&err
, dev
, OPAL_WRITELOCKED
);
2192 add_token_u8(&err
, dev
, write_locked
);
2193 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2195 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
2196 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2199 pr_debug("Error building SET command.\n");
2203 return finalize_and_send(dev
, parse_and_check_status
);
2207 static int lock_unlock_locking_range_sum(struct opal_dev
*dev
, void *data
)
2209 u8 lr_buffer
[OPAL_UID_LENGTH
];
2210 u8 read_locked
= 1, write_locked
= 1;
2211 struct opal_lock_unlock
*lkul
= data
;
2214 clear_opal_cmd(dev
);
2215 set_comid(dev
, dev
->comid
);
2217 if (build_locking_range(lr_buffer
, sizeof(lr_buffer
),
2218 lkul
->session
.opal_key
.lr
) < 0)
2221 switch (lkul
->l_state
) {
2231 /* vars are initialized to locked */
2234 pr_debug("Tried to set an invalid locking state.\n");
2235 return OPAL_INVAL_PARAM
;
2237 ret
= generic_lr_enable_disable(dev
, lr_buffer
, 1, 1,
2238 read_locked
, write_locked
);
2241 pr_debug("Error building SET command.\n");
2245 return finalize_and_send(dev
, parse_and_check_status
);
2248 static int activate_lsp(struct opal_dev
*dev
, void *data
)
2250 struct opal_lr_act
*opal_act
= data
;
2251 u8 user_lr
[OPAL_UID_LENGTH
];
2254 err
= cmd_start(dev
, opaluid
[OPAL_LOCKINGSP_UID
],
2255 opalmethod
[OPAL_ACTIVATE
]);
2257 if (opal_act
->sum
) {
2258 err
= build_locking_range(user_lr
, sizeof(user_lr
),
2263 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2264 add_token_u64(&err
, dev
, OPAL_SUM_SET_LIST
);
2266 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
2267 add_token_bytestring(&err
, dev
, user_lr
, OPAL_UID_LENGTH
);
2268 for (i
= 1; i
< opal_act
->num_lrs
; i
++) {
2269 user_lr
[7] = opal_act
->lr
[i
];
2270 add_token_bytestring(&err
, dev
, user_lr
, OPAL_UID_LENGTH
);
2272 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
2273 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2277 pr_debug("Error building Activate LockingSP command.\n");
2281 return finalize_and_send(dev
, parse_and_check_status
);
2284 /* Determine if we're in the Manufactured Inactive or Active state */
2285 static int get_lsp_lifecycle(struct opal_dev
*dev
, void *data
)
2290 err
= generic_get_column(dev
, opaluid
[OPAL_LOCKINGSP_UID
],
2295 lc_status
= response_get_u64(&dev
->parsed
, 4);
2296 /* 0x08 is Manufactured Inactive */
2297 /* 0x09 is Manufactured */
2298 if (lc_status
!= OPAL_MANUFACTURED_INACTIVE
) {
2299 pr_debug("Couldn't determine the status of the Lifecycle state\n");
2306 static int get_msid_cpin_pin(struct opal_dev
*dev
, void *data
)
2308 const char *msid_pin
;
2312 err
= generic_get_column(dev
, opaluid
[OPAL_C_PIN_MSID
], OPAL_PIN
);
2316 strlen
= response_get_string(&dev
->parsed
, 4, &msid_pin
);
2318 pr_debug("Couldn't extract MSID_CPIN from response\n");
2319 return OPAL_INVAL_PARAM
;
2322 dev
->prev_data
= kmemdup(msid_pin
, strlen
, GFP_KERNEL
);
2323 if (!dev
->prev_data
)
2326 dev
->prev_d_len
= strlen
;
2331 static int write_table_data(struct opal_dev
*dev
, void *data
)
2333 struct opal_read_write_table
*write_tbl
= data
;
2335 return generic_table_write_data(dev
, write_tbl
->data
, write_tbl
->offset
,
2336 write_tbl
->size
, write_tbl
->table_uid
);
2339 static int read_table_data_cont(struct opal_dev
*dev
)
2342 const char *data_read
;
2344 err
= parse_and_check_status(dev
);
2348 dev
->prev_d_len
= response_get_string(&dev
->parsed
, 1, &data_read
);
2349 dev
->prev_data
= (void *)data_read
;
2350 if (!dev
->prev_data
) {
2351 pr_debug("%s: Couldn't read data from the table.\n", __func__
);
2352 return OPAL_INVAL_PARAM
;
2359 * IO_BUFFER_LENGTH = 2048
2360 * sizeof(header) = 56
2361 * No. of Token Bytes in the Response = 11
2362 * MAX size of data that can be carried in response buffer
2363 * at a time is : 2048 - (56 + 11) = 1981 = 0x7BD.
2365 #define OPAL_MAX_READ_TABLE (0x7BD)
2367 static int read_table_data(struct opal_dev
*dev
, void *data
)
2369 struct opal_read_write_table
*read_tbl
= data
;
2371 size_t off
= 0, max_read_size
= OPAL_MAX_READ_TABLE
;
2373 u64 offset
= read_tbl
->offset
, read_size
= read_tbl
->size
- 1;
2376 err
= generic_get_table_info(dev
, read_tbl
->table_uid
, OPAL_TABLE_ROWS
);
2378 pr_debug("Couldn't get the table size\n");
2382 table_len
= response_get_u64(&dev
->parsed
, 4);
2384 /* Check if the user is trying to read from the table limits */
2385 if (read_size
> table_len
|| offset
> table_len
- read_size
) {
2386 pr_debug("Read size exceeds the Table size limits (%llu vs. %llu)\n",
2387 offset
+ read_size
, table_len
);
2391 while (off
< read_size
) {
2392 err
= cmd_start(dev
, read_tbl
->table_uid
, opalmethod
[OPAL_GET
]);
2394 add_token_u8(&err
, dev
, OPAL_STARTLIST
);
2395 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2396 add_token_u8(&err
, dev
, OPAL_STARTROW
);
2397 add_token_u64(&err
, dev
, offset
+ off
); /* start row value */
2398 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2400 add_token_u8(&err
, dev
, OPAL_STARTNAME
);
2401 add_token_u8(&err
, dev
, OPAL_ENDROW
);
2403 len
= min(max_read_size
, (size_t)(read_size
- off
));
2404 add_token_u64(&err
, dev
, offset
+ off
+ len
); /* end row value
2406 add_token_u8(&err
, dev
, OPAL_ENDNAME
);
2407 add_token_u8(&err
, dev
, OPAL_ENDLIST
);
2410 pr_debug("Error building read table data command.\n");
2414 err
= finalize_and_send(dev
, read_table_data_cont
);
2418 /* len+1: This includes the NULL terminator at the end*/
2419 if (dev
->prev_d_len
> len
+ 1) {
2424 dst
= (u8 __user
*)(uintptr_t)read_tbl
->data
;
2425 if (copy_to_user(dst
+ off
, dev
->prev_data
, dev
->prev_d_len
)) {
2426 pr_debug("Error copying data to userspace\n");
2430 dev
->prev_data
= NULL
;
2438 static int end_opal_session(struct opal_dev
*dev
, void *data
)
2442 clear_opal_cmd(dev
);
2443 set_comid(dev
, dev
->comid
);
2444 add_token_u8(&err
, dev
, OPAL_ENDOFSESSION
);
2449 return finalize_and_send(dev
, end_session_cont
);
2452 static int end_opal_session_error(struct opal_dev
*dev
)
2454 const struct opal_step error_end_session
= {
2458 return execute_step(dev
, &error_end_session
, 0);
2461 static inline void setup_opal_dev(struct opal_dev
*dev
)
2465 dev
->prev_data
= NULL
;
2468 static int check_opal_support(struct opal_dev
*dev
)
2472 mutex_lock(&dev
->dev_lock
);
2473 setup_opal_dev(dev
);
2474 ret
= opal_discovery0_step(dev
);
2476 dev
->flags
|= OPAL_FL_SUPPORTED
;
2477 mutex_unlock(&dev
->dev_lock
);
2482 static void clean_opal_dev(struct opal_dev
*dev
)
2485 struct opal_suspend_data
*suspend
, *next
;
2487 mutex_lock(&dev
->dev_lock
);
2488 list_for_each_entry_safe(suspend
, next
, &dev
->unlk_lst
, node
) {
2489 list_del(&suspend
->node
);
2492 mutex_unlock(&dev
->dev_lock
);
2495 void free_opal_dev(struct opal_dev
*dev
)
2500 clean_opal_dev(dev
);
2505 EXPORT_SYMBOL(free_opal_dev
);
2507 struct opal_dev
*init_opal_dev(void *data
, sec_send_recv
*send_recv
)
2509 struct opal_dev
*dev
;
2511 dev
= kmalloc(sizeof(*dev
), GFP_KERNEL
);
2516 * Presumably DMA-able buffers must be cache-aligned. Kmalloc makes
2517 * sure the allocated buffer is DMA-safe in that regard.
2519 dev
->cmd
= kmalloc(IO_BUFFER_LENGTH
, GFP_KERNEL
);
2523 dev
->resp
= kmalloc(IO_BUFFER_LENGTH
, GFP_KERNEL
);
2527 INIT_LIST_HEAD(&dev
->unlk_lst
);
2528 mutex_init(&dev
->dev_lock
);
2531 dev
->send_recv
= send_recv
;
2532 if (check_opal_support(dev
) != 0) {
2533 pr_debug("Opal is not supported on this device\n");
2550 EXPORT_SYMBOL(init_opal_dev
);
2552 static int opal_secure_erase_locking_range(struct opal_dev
*dev
,
2553 struct opal_session_info
*opal_session
)
2555 const struct opal_step erase_steps
[] = {
2556 { start_auth_opal_session
, opal_session
},
2557 { get_active_key
, &opal_session
->opal_key
.lr
},
2559 { end_opal_session
, }
2563 ret
= opal_get_key(dev
, &opal_session
->opal_key
);
2566 mutex_lock(&dev
->dev_lock
);
2567 setup_opal_dev(dev
);
2568 ret
= execute_steps(dev
, erase_steps
, ARRAY_SIZE(erase_steps
));
2569 mutex_unlock(&dev
->dev_lock
);
2574 static int opal_get_discv(struct opal_dev
*dev
, struct opal_discovery
*discv
)
2576 const struct opal_step discovery0_step
= {
2577 opal_discovery0
, discv
2581 mutex_lock(&dev
->dev_lock
);
2582 setup_opal_dev(dev
);
2583 ret
= execute_step(dev
, &discovery0_step
, 0);
2584 mutex_unlock(&dev
->dev_lock
);
2587 return discv
->size
; /* modified to actual length of data */
2590 static int opal_revertlsp(struct opal_dev
*dev
, struct opal_revert_lsp
*rev
)
2592 /* controller will terminate session */
2593 const struct opal_step steps
[] = {
2594 { start_admin1LSP_opal_session
, &rev
->key
},
2599 ret
= opal_get_key(dev
, &rev
->key
);
2602 mutex_lock(&dev
->dev_lock
);
2603 setup_opal_dev(dev
);
2604 ret
= execute_steps(dev
, steps
, ARRAY_SIZE(steps
));
2605 mutex_unlock(&dev
->dev_lock
);
2610 static int opal_erase_locking_range(struct opal_dev
*dev
,
2611 struct opal_session_info
*opal_session
)
2613 const struct opal_step erase_steps
[] = {
2614 { start_auth_opal_session
, opal_session
},
2615 { erase_locking_range
, opal_session
},
2616 { end_opal_session
, }
2620 ret
= opal_get_key(dev
, &opal_session
->opal_key
);
2623 mutex_lock(&dev
->dev_lock
);
2624 setup_opal_dev(dev
);
2625 ret
= execute_steps(dev
, erase_steps
, ARRAY_SIZE(erase_steps
));
2626 mutex_unlock(&dev
->dev_lock
);
2631 static int opal_enable_disable_shadow_mbr(struct opal_dev
*dev
,
2632 struct opal_mbr_data
*opal_mbr
)
2634 u8 enable_disable
= opal_mbr
->enable_disable
== OPAL_MBR_ENABLE
?
2635 OPAL_TRUE
: OPAL_FALSE
;
2637 const struct opal_step mbr_steps
[] = {
2638 { start_admin1LSP_opal_session
, &opal_mbr
->key
},
2639 { set_mbr_done
, &enable_disable
},
2640 { end_opal_session
, },
2641 { start_admin1LSP_opal_session
, &opal_mbr
->key
},
2642 { set_mbr_enable_disable
, &enable_disable
},
2643 { end_opal_session
, }
2647 if (opal_mbr
->enable_disable
!= OPAL_MBR_ENABLE
&&
2648 opal_mbr
->enable_disable
!= OPAL_MBR_DISABLE
)
2651 ret
= opal_get_key(dev
, &opal_mbr
->key
);
2654 mutex_lock(&dev
->dev_lock
);
2655 setup_opal_dev(dev
);
2656 ret
= execute_steps(dev
, mbr_steps
, ARRAY_SIZE(mbr_steps
));
2657 mutex_unlock(&dev
->dev_lock
);
2662 static int opal_set_mbr_done(struct opal_dev
*dev
,
2663 struct opal_mbr_done
*mbr_done
)
2665 u8 mbr_done_tf
= mbr_done
->done_flag
== OPAL_MBR_DONE
?
2666 OPAL_TRUE
: OPAL_FALSE
;
2668 const struct opal_step mbr_steps
[] = {
2669 { start_admin1LSP_opal_session
, &mbr_done
->key
},
2670 { set_mbr_done
, &mbr_done_tf
},
2671 { end_opal_session
, }
2675 if (mbr_done
->done_flag
!= OPAL_MBR_DONE
&&
2676 mbr_done
->done_flag
!= OPAL_MBR_NOT_DONE
)
2679 ret
= opal_get_key(dev
, &mbr_done
->key
);
2682 mutex_lock(&dev
->dev_lock
);
2683 setup_opal_dev(dev
);
2684 ret
= execute_steps(dev
, mbr_steps
, ARRAY_SIZE(mbr_steps
));
2685 mutex_unlock(&dev
->dev_lock
);
2690 static int opal_write_shadow_mbr(struct opal_dev
*dev
,
2691 struct opal_shadow_mbr
*info
)
2693 const struct opal_step mbr_steps
[] = {
2694 { start_admin1LSP_opal_session
, &info
->key
},
2695 { write_shadow_mbr
, info
},
2696 { end_opal_session
, }
2700 if (info
->size
== 0)
2703 ret
= opal_get_key(dev
, &info
->key
);
2706 mutex_lock(&dev
->dev_lock
);
2707 setup_opal_dev(dev
);
2708 ret
= execute_steps(dev
, mbr_steps
, ARRAY_SIZE(mbr_steps
));
2709 mutex_unlock(&dev
->dev_lock
);
2714 static int opal_save(struct opal_dev
*dev
, struct opal_lock_unlock
*lk_unlk
)
2716 struct opal_suspend_data
*suspend
;
2718 suspend
= kzalloc(sizeof(*suspend
), GFP_KERNEL
);
2722 suspend
->unlk
= *lk_unlk
;
2723 suspend
->lr
= lk_unlk
->session
.opal_key
.lr
;
2725 mutex_lock(&dev
->dev_lock
);
2726 setup_opal_dev(dev
);
2727 add_suspend_info(dev
, suspend
);
2728 mutex_unlock(&dev
->dev_lock
);
2733 static int opal_add_user_to_lr(struct opal_dev
*dev
,
2734 struct opal_lock_unlock
*lk_unlk
)
2736 const struct opal_step steps
[] = {
2737 { start_admin1LSP_opal_session
, &lk_unlk
->session
.opal_key
},
2738 { add_user_to_lr
, lk_unlk
},
2739 { add_user_to_lr_ace
, lk_unlk
},
2740 { end_opal_session
, }
2744 if (lk_unlk
->l_state
!= OPAL_RO
&&
2745 lk_unlk
->l_state
!= OPAL_RW
) {
2746 pr_debug("Locking state was not RO or RW\n");
2750 if (lk_unlk
->session
.who
< OPAL_USER1
||
2751 lk_unlk
->session
.who
> OPAL_USER9
) {
2752 pr_debug("Authority was not within the range of users: %d\n",
2753 lk_unlk
->session
.who
);
2757 if (lk_unlk
->session
.sum
) {
2758 pr_debug("%s not supported in sum. Use setup locking range\n",
2763 ret
= opal_get_key(dev
, &lk_unlk
->session
.opal_key
);
2766 mutex_lock(&dev
->dev_lock
);
2767 setup_opal_dev(dev
);
2768 ret
= execute_steps(dev
, steps
, ARRAY_SIZE(steps
));
2769 mutex_unlock(&dev
->dev_lock
);
2774 static int opal_reverttper(struct opal_dev
*dev
, struct opal_key
*opal
, bool psid
)
2776 /* controller will terminate session */
2777 const struct opal_step revert_steps
[] = {
2778 { start_SIDASP_opal_session
, opal
},
2781 const struct opal_step psid_revert_steps
[] = {
2782 { start_PSID_opal_session
, opal
},
2788 ret
= opal_get_key(dev
, opal
);
2792 mutex_lock(&dev
->dev_lock
);
2793 setup_opal_dev(dev
);
2795 ret
= execute_steps(dev
, psid_revert_steps
,
2796 ARRAY_SIZE(psid_revert_steps
));
2798 ret
= execute_steps(dev
, revert_steps
,
2799 ARRAY_SIZE(revert_steps
));
2800 mutex_unlock(&dev
->dev_lock
);
2803 * If we successfully reverted lets clean
2804 * any saved locking ranges.
2807 clean_opal_dev(dev
);
2812 static int __opal_lock_unlock(struct opal_dev
*dev
,
2813 struct opal_lock_unlock
*lk_unlk
)
2815 const struct opal_step unlock_steps
[] = {
2816 { start_auth_opal_session
, &lk_unlk
->session
},
2817 { lock_unlock_locking_range
, lk_unlk
},
2818 { end_opal_session
, }
2820 const struct opal_step unlock_sum_steps
[] = {
2821 { start_auth_opal_session
, &lk_unlk
->session
},
2822 { lock_unlock_locking_range_sum
, lk_unlk
},
2823 { end_opal_session
, }
2826 if (lk_unlk
->session
.sum
)
2827 return execute_steps(dev
, unlock_sum_steps
,
2828 ARRAY_SIZE(unlock_sum_steps
));
2830 return execute_steps(dev
, unlock_steps
,
2831 ARRAY_SIZE(unlock_steps
));
2834 static int __opal_set_mbr_done(struct opal_dev
*dev
, struct opal_key
*key
)
2836 u8 mbr_done_tf
= OPAL_TRUE
;
2837 const struct opal_step mbrdone_step
[] = {
2838 { start_admin1LSP_opal_session
, key
},
2839 { set_mbr_done
, &mbr_done_tf
},
2840 { end_opal_session
, }
2843 return execute_steps(dev
, mbrdone_step
, ARRAY_SIZE(mbrdone_step
));
2846 static void opal_lock_check_for_saved_key(struct opal_dev
*dev
,
2847 struct opal_lock_unlock
*lk_unlk
)
2849 struct opal_suspend_data
*iter
;
2851 if (lk_unlk
->l_state
!= OPAL_LK
||
2852 lk_unlk
->session
.opal_key
.key_len
> 0)
2856 * Usually when closing a crypto device (eg: dm-crypt with LUKS) the
2857 * volume key is not required, as it requires root privileges anyway,
2858 * and root can deny access to a disk in many ways regardless.
2859 * Requiring the volume key to lock the device is a peculiarity of the
2860 * OPAL specification. Given we might already have saved the key if
2861 * the user requested it via the 'IOC_OPAL_SAVE' ioctl, we can use
2862 * that key to lock the device if no key was provided here, the
2863 * locking range matches and the appropriate flag was passed with
2865 * This allows integrating OPAL with tools and libraries that are used
2866 * to the common behaviour and do not ask for the volume key when
2869 setup_opal_dev(dev
);
2870 list_for_each_entry(iter
, &dev
->unlk_lst
, node
) {
2871 if ((iter
->unlk
.flags
& OPAL_SAVE_FOR_LOCK
) &&
2872 iter
->lr
== lk_unlk
->session
.opal_key
.lr
&&
2873 iter
->unlk
.session
.opal_key
.key_len
> 0) {
2874 lk_unlk
->session
.opal_key
.key_len
=
2875 iter
->unlk
.session
.opal_key
.key_len
;
2876 memcpy(lk_unlk
->session
.opal_key
.key
,
2877 iter
->unlk
.session
.opal_key
.key
,
2878 iter
->unlk
.session
.opal_key
.key_len
);
2884 static int opal_lock_unlock(struct opal_dev
*dev
,
2885 struct opal_lock_unlock
*lk_unlk
)
2889 if (lk_unlk
->session
.who
> OPAL_USER9
)
2892 mutex_lock(&dev
->dev_lock
);
2893 opal_lock_check_for_saved_key(dev
, lk_unlk
);
2894 ret
= opal_get_key(dev
, &lk_unlk
->session
.opal_key
);
2896 ret
= __opal_lock_unlock(dev
, lk_unlk
);
2897 mutex_unlock(&dev
->dev_lock
);
2902 static int opal_take_ownership(struct opal_dev
*dev
, struct opal_key
*opal
)
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
, }
2917 ret
= opal_get_key(dev
, opal
);
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
);
2928 static int opal_activate_lsp(struct opal_dev
*dev
,
2929 struct opal_lr_act
*opal_lr_act
)
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
, }
2939 if (!opal_lr_act
->num_lrs
|| opal_lr_act
->num_lrs
> OPAL_MAX_LRS
)
2942 ret
= opal_get_key(dev
, &opal_lr_act
->key
);
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
);
2953 static int opal_setup_locking_range(struct opal_dev
*dev
,
2954 struct opal_user_lr_setup
*opal_lrs
)
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
, }
2963 ret
= opal_get_key(dev
, &opal_lrs
->session
.opal_key
);
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
);
2974 static int opal_locking_range_status(struct opal_dev
*dev
,
2975 struct opal_lr_status
*opal_lrst
,
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
, }
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
);
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");
3001 static int opal_set_new_pw(struct opal_dev
*dev
, struct opal_new_pw
*opal_pw
)
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
, }
3010 if (opal_pw
->session
.who
> OPAL_USER9
||
3011 opal_pw
->new_user_pw
.who
> OPAL_USER9
)
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
);
3022 /* update keyring and key store with new password */
3023 ret
= sed_write_key(OPAL_AUTH_KEY
,
3024 opal_pw
->new_user_pw
.opal_key
.key
,
3025 opal_pw
->new_user_pw
.opal_key
.key_len
);
3026 if (ret
!= -EOPNOTSUPP
)
3027 pr_warn("error updating SED key: %d\n", ret
);
3029 ret
= update_sed_opal_key(OPAL_AUTH_KEY
,
3030 opal_pw
->new_user_pw
.opal_key
.key
,
3031 opal_pw
->new_user_pw
.opal_key
.key_len
);
3036 static int opal_activate_user(struct opal_dev
*dev
,
3037 struct opal_session_info
*opal_session
)
3039 const struct opal_step act_steps
[] = {
3040 { start_admin1LSP_opal_session
, &opal_session
->opal_key
},
3041 { internal_activate_user
, opal_session
},
3042 { end_opal_session
, }
3046 /* We can't activate Admin1 it's active as manufactured */
3047 if (opal_session
->who
< OPAL_USER1
||
3048 opal_session
->who
> OPAL_USER9
) {
3049 pr_debug("Who was not a valid user: %d\n", opal_session
->who
);
3053 ret
= opal_get_key(dev
, &opal_session
->opal_key
);
3056 mutex_lock(&dev
->dev_lock
);
3057 setup_opal_dev(dev
);
3058 ret
= execute_steps(dev
, act_steps
, ARRAY_SIZE(act_steps
));
3059 mutex_unlock(&dev
->dev_lock
);
3064 bool opal_unlock_from_suspend(struct opal_dev
*dev
)
3066 struct opal_suspend_data
*suspend
;
3067 bool was_failure
= false;
3073 if (!(dev
->flags
& OPAL_FL_SUPPORTED
))
3076 mutex_lock(&dev
->dev_lock
);
3077 setup_opal_dev(dev
);
3079 list_for_each_entry(suspend
, &dev
->unlk_lst
, node
) {
3083 ret
= __opal_lock_unlock(dev
, &suspend
->unlk
);
3085 pr_debug("Failed to unlock LR %hhu with sum %d\n",
3086 suspend
->unlk
.session
.opal_key
.lr
,
3087 suspend
->unlk
.session
.sum
);
3091 if (dev
->flags
& OPAL_FL_MBR_ENABLED
) {
3092 ret
= __opal_set_mbr_done(dev
, &suspend
->unlk
.session
.opal_key
);
3094 pr_debug("Failed to set MBR Done in S3 resume\n");
3097 mutex_unlock(&dev
->dev_lock
);
3101 EXPORT_SYMBOL(opal_unlock_from_suspend
);
3103 static int opal_read_table(struct opal_dev
*dev
,
3104 struct opal_read_write_table
*rw_tbl
)
3106 const struct opal_step read_table_steps
[] = {
3107 { start_admin1LSP_opal_session
, &rw_tbl
->key
},
3108 { read_table_data
, rw_tbl
},
3109 { end_opal_session
, }
3116 return execute_steps(dev
, read_table_steps
,
3117 ARRAY_SIZE(read_table_steps
));
3120 static int opal_write_table(struct opal_dev
*dev
,
3121 struct opal_read_write_table
*rw_tbl
)
3123 const struct opal_step write_table_steps
[] = {
3124 { start_admin1LSP_opal_session
, &rw_tbl
->key
},
3125 { write_table_data
, rw_tbl
},
3126 { end_opal_session
, }
3133 return execute_steps(dev
, write_table_steps
,
3134 ARRAY_SIZE(write_table_steps
));
3137 static int opal_generic_read_write_table(struct opal_dev
*dev
,
3138 struct opal_read_write_table
*rw_tbl
)
3142 ret
= opal_get_key(dev
, &rw_tbl
->key
);
3145 mutex_lock(&dev
->dev_lock
);
3146 setup_opal_dev(dev
);
3148 bit_set
= fls64(rw_tbl
->flags
) - 1;
3150 case OPAL_READ_TABLE
:
3151 ret
= opal_read_table(dev
, rw_tbl
);
3153 case OPAL_WRITE_TABLE
:
3154 ret
= opal_write_table(dev
, rw_tbl
);
3157 pr_debug("Invalid bit set in the flag (%016llx).\n",
3163 mutex_unlock(&dev
->dev_lock
);
3168 static int opal_get_status(struct opal_dev
*dev
, void __user
*data
)
3170 struct opal_status sts
= {0};
3173 * check_opal_support() error is not fatal,
3174 * !dev->supported is a valid condition
3176 if (!check_opal_support(dev
))
3177 sts
.flags
= dev
->flags
;
3178 if (copy_to_user(data
, &sts
, sizeof(sts
))) {
3179 pr_debug("Error copying status to userspace\n");
3185 static int opal_get_geometry(struct opal_dev
*dev
, void __user
*data
)
3187 struct opal_geometry geo
= {0};
3189 if (check_opal_support(dev
))
3192 geo
.align
= dev
->align_required
;
3193 geo
.logical_block_size
= dev
->logical_block_size
;
3194 geo
.alignment_granularity
= dev
->align
;
3195 geo
.lowest_aligned_lba
= dev
->lowest_lba
;
3197 if (copy_to_user(data
, &geo
, sizeof(geo
))) {
3198 pr_debug("Error copying geometry data to userspace\n");
3205 int sed_ioctl(struct opal_dev
*dev
, unsigned int cmd
, void __user
*arg
)
3210 if (!capable(CAP_SYS_ADMIN
))
3214 if (!(dev
->flags
& OPAL_FL_SUPPORTED
))
3218 p
= memdup_user(arg
, _IOC_SIZE(cmd
));
3225 ret
= opal_save(dev
, p
);
3227 case IOC_OPAL_LOCK_UNLOCK
:
3228 ret
= opal_lock_unlock(dev
, p
);
3230 case IOC_OPAL_TAKE_OWNERSHIP
:
3231 ret
= opal_take_ownership(dev
, p
);
3233 case IOC_OPAL_ACTIVATE_LSP
:
3234 ret
= opal_activate_lsp(dev
, p
);
3236 case IOC_OPAL_SET_PW
:
3237 ret
= opal_set_new_pw(dev
, p
);
3239 case IOC_OPAL_ACTIVATE_USR
:
3240 ret
= opal_activate_user(dev
, p
);
3242 case IOC_OPAL_REVERT_TPR
:
3243 ret
= opal_reverttper(dev
, p
, false);
3245 case IOC_OPAL_LR_SETUP
:
3246 ret
= opal_setup_locking_range(dev
, p
);
3248 case IOC_OPAL_ADD_USR_TO_LR
:
3249 ret
= opal_add_user_to_lr(dev
, p
);
3251 case IOC_OPAL_ENABLE_DISABLE_MBR
:
3252 ret
= opal_enable_disable_shadow_mbr(dev
, p
);
3254 case IOC_OPAL_MBR_DONE
:
3255 ret
= opal_set_mbr_done(dev
, p
);
3257 case IOC_OPAL_WRITE_SHADOW_MBR
:
3258 ret
= opal_write_shadow_mbr(dev
, p
);
3260 case IOC_OPAL_ERASE_LR
:
3261 ret
= opal_erase_locking_range(dev
, p
);
3263 case IOC_OPAL_SECURE_ERASE_LR
:
3264 ret
= opal_secure_erase_locking_range(dev
, p
);
3266 case IOC_OPAL_PSID_REVERT_TPR
:
3267 ret
= opal_reverttper(dev
, p
, true);
3269 case IOC_OPAL_GENERIC_TABLE_RW
:
3270 ret
= opal_generic_read_write_table(dev
, p
);
3272 case IOC_OPAL_GET_STATUS
:
3273 ret
= opal_get_status(dev
, arg
);
3275 case IOC_OPAL_GET_LR_STATUS
:
3276 ret
= opal_locking_range_status(dev
, p
, arg
);
3278 case IOC_OPAL_GET_GEOMETRY
:
3279 ret
= opal_get_geometry(dev
, arg
);
3281 case IOC_OPAL_REVERT_LSP
:
3282 ret
= opal_revertlsp(dev
, p
);
3284 case IOC_OPAL_DISCOVERY
:
3285 ret
= opal_get_discv(dev
, p
);
3296 EXPORT_SYMBOL_GPL(sed_ioctl
);
3298 static int __init
sed_opal_init(void)
3301 char init_sed_key
[OPAL_KEY_MAX
];
3302 int keylen
= OPAL_KEY_MAX
- 1;
3304 kr
= keyring_alloc(".sed_opal",
3305 GLOBAL_ROOT_UID
, GLOBAL_ROOT_GID
, current_cred(),
3306 (KEY_POS_ALL
& ~KEY_POS_SETATTR
) | KEY_USR_VIEW
|
3307 KEY_USR_READ
| KEY_USR_SEARCH
| KEY_USR_WRITE
,
3308 KEY_ALLOC_NOT_IN_QUOTA
,
3313 sed_opal_keyring
= kr
;
3315 if (sed_read_key(OPAL_AUTH_KEY
, init_sed_key
, &keylen
) < 0) {
3316 memset(init_sed_key
, '\0', sizeof(init_sed_key
));
3317 keylen
= OPAL_KEY_MAX
- 1;
3320 return update_sed_opal_key(OPAL_AUTH_KEY
, init_sed_key
, keylen
);
3322 late_initcall(sed_opal_init
);