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