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