sm501: Add missing arbitration control register
[qemu.git] / hw / scsi / mptconfig.c
1 /*
2 * QEMU LSI SAS1068 Host Bus Adapter emulation - configuration pages
3 *
4 * Copyright (c) 2016 Red Hat, Inc.
5 *
6 * Author: Paolo Bonzini
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 */
18 #include "qemu/osdep.h"
19 #include "hw/hw.h"
20 #include "hw/pci/pci.h"
21 #include "hw/scsi/scsi.h"
22
23 #include "mptsas.h"
24 #include "mpi.h"
25 #include "trace.h"
26
27 /* Generic functions for marshaling and unmarshaling. */
28
29 #define repl1(x) x
30 #define repl2(x) x x
31 #define repl3(x) x x x
32 #define repl4(x) x x x x
33 #define repl5(x) x x x x x
34 #define repl6(x) x x x x x x
35 #define repl7(x) x x x x x x x
36 #define repl8(x) x x x x x x x x
37
38 #define repl(n, x) glue(repl, n)(x)
39
40 typedef union PackValue {
41 uint64_t ll;
42 char *str;
43 } PackValue;
44
45 static size_t vfill(uint8_t *data, size_t size, const char *fmt, va_list ap)
46 {
47 size_t ofs;
48 PackValue val;
49 const char *p;
50
51 ofs = 0;
52 p = fmt;
53 while (*p) {
54 memset(&val, 0, sizeof(val));
55 switch (*p) {
56 case '*':
57 p++;
58 break;
59 case 'b':
60 case 'w':
61 case 'l':
62 val.ll = va_arg(ap, int);
63 break;
64 case 'q':
65 val.ll = va_arg(ap, int64_t);
66 break;
67 case 's':
68 val.str = va_arg(ap, void *);
69 break;
70 }
71 switch (*p++) {
72 case 'b':
73 if (data) {
74 stb_p(data + ofs, val.ll);
75 }
76 ofs++;
77 break;
78 case 'w':
79 if (data) {
80 stw_le_p(data + ofs, val.ll);
81 }
82 ofs += 2;
83 break;
84 case 'l':
85 if (data) {
86 stl_le_p(data + ofs, val.ll);
87 }
88 ofs += 4;
89 break;
90 case 'q':
91 if (data) {
92 stq_le_p(data + ofs, val.ll);
93 }
94 ofs += 8;
95 break;
96 case 's':
97 {
98 int cnt = atoi(p);
99 if (data) {
100 if (val.str) {
101 strncpy((void *)data + ofs, val.str, cnt);
102 } else {
103 memset((void *)data + ofs, 0, cnt);
104 }
105 }
106 ofs += cnt;
107 break;
108 }
109 }
110 }
111
112 return ofs;
113 }
114
115 static size_t vpack(uint8_t **p_data, const char *fmt, va_list ap1)
116 {
117 size_t size = 0;
118 uint8_t *data = NULL;
119
120 if (p_data) {
121 va_list ap2;
122
123 va_copy(ap2, ap1);
124 size = vfill(NULL, 0, fmt, ap2);
125 *p_data = data = g_malloc(size);
126 va_end(ap2);
127 }
128 return vfill(data, size, fmt, ap1);
129 }
130
131 static size_t fill(uint8_t *data, size_t size, const char *fmt, ...)
132 {
133 va_list ap;
134 size_t ret;
135
136 va_start(ap, fmt);
137 ret = vfill(data, size, fmt, ap);
138 va_end(ap);
139
140 return ret;
141 }
142
143 /* Functions to build the page header and fill in the length, always used
144 * through the macros.
145 */
146
147 #define MPTSAS_CONFIG_PACK(number, type, version, fmt, ...) \
148 mptsas_config_pack(data, "b*bbb" fmt, version, number, type, \
149 ## __VA_ARGS__)
150
151 static size_t mptsas_config_pack(uint8_t **data, const char *fmt, ...)
152 {
153 va_list ap;
154 size_t ret;
155
156 va_start(ap, fmt);
157 ret = vpack(data, fmt, ap);
158 va_end(ap);
159
160 if (data) {
161 assert(ret / 4 < 256 && (ret % 4) == 0);
162 stb_p(*data + 1, ret / 4);
163 }
164 return ret;
165 }
166
167 #define MPTSAS_CONFIG_PACK_EXT(number, type, version, fmt, ...) \
168 mptsas_config_pack_ext(data, "b*bbb*wb*b" fmt, version, number, \
169 MPI_CONFIG_PAGETYPE_EXTENDED, type, ## __VA_ARGS__)
170
171 static size_t mptsas_config_pack_ext(uint8_t **data, const char *fmt, ...)
172 {
173 va_list ap;
174 size_t ret;
175
176 va_start(ap, fmt);
177 ret = vpack(data, fmt, ap);
178 va_end(ap);
179
180 if (data) {
181 assert(ret < 65536 && (ret % 4) == 0);
182 stw_le_p(*data + 4, ret / 4);
183 }
184 return ret;
185 }
186
187 /* Manufacturing pages */
188
189 static
190 size_t mptsas_config_manufacturing_0(MPTSASState *s, uint8_t **data, int address)
191 {
192 return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
193 "s16s8s16s16s16",
194 "QEMU MPT Fusion",
195 "2.5",
196 "QEMU MPT Fusion",
197 "QEMU",
198 "0000111122223333");
199 }
200
201 static
202 size_t mptsas_config_manufacturing_1(MPTSASState *s, uint8_t **data, int address)
203 {
204 /* VPD - all zeros */
205 return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
206 "*s256");
207 }
208
209 static
210 size_t mptsas_config_manufacturing_2(MPTSASState *s, uint8_t **data, int address)
211 {
212 PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
213 return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
214 "wb*b*l",
215 pcic->device_id, pcic->revision);
216 }
217
218 static
219 size_t mptsas_config_manufacturing_3(MPTSASState *s, uint8_t **data, int address)
220 {
221 PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
222 return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
223 "wb*b*l",
224 pcic->device_id, pcic->revision);
225 }
226
227 static
228 size_t mptsas_config_manufacturing_4(MPTSASState *s, uint8_t **data, int address)
229 {
230 /* All zeros */
231 return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x05,
232 "*l*b*b*b*b*b*b*w*s56*l*l*l*l*l*l"
233 "*b*b*w*b*b*w*l*l");
234 }
235
236 static
237 size_t mptsas_config_manufacturing_5(MPTSASState *s, uint8_t **data, int address)
238 {
239 return MPTSAS_CONFIG_PACK(5, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x02,
240 "q*b*b*w*l*l", s->sas_addr);
241 }
242
243 static
244 size_t mptsas_config_manufacturing_6(MPTSASState *s, uint8_t **data, int address)
245 {
246 return MPTSAS_CONFIG_PACK(6, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
247 "*l");
248 }
249
250 static
251 size_t mptsas_config_manufacturing_7(MPTSASState *s, uint8_t **data, int address)
252 {
253 return MPTSAS_CONFIG_PACK(7, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
254 "*l*l*l*s16*b*b*w", MPTSAS_NUM_PORTS);
255 }
256
257 static
258 size_t mptsas_config_manufacturing_8(MPTSASState *s, uint8_t **data, int address)
259 {
260 return MPTSAS_CONFIG_PACK(8, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
261 "*l");
262 }
263
264 static
265 size_t mptsas_config_manufacturing_9(MPTSASState *s, uint8_t **data, int address)
266 {
267 return MPTSAS_CONFIG_PACK(9, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
268 "*l");
269 }
270
271 static
272 size_t mptsas_config_manufacturing_10(MPTSASState *s, uint8_t **data, int address)
273 {
274 return MPTSAS_CONFIG_PACK(10, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
275 "*l");
276 }
277
278 /* I/O unit pages */
279
280 static
281 size_t mptsas_config_io_unit_0(MPTSASState *s, uint8_t **data, int address)
282 {
283 PCIDevice *pci = PCI_DEVICE(s);
284 uint64_t unique_value = 0x53504D554D4551LL; /* "QEMUMPTx" */
285
286 unique_value |= (uint64_t)pci->devfn << 56;
287 return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x00,
288 "q", unique_value);
289 }
290
291 static
292 size_t mptsas_config_io_unit_1(MPTSASState *s, uint8_t **data, int address)
293 {
294 return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x02, "l",
295 0x41 /* single function, RAID disabled */ );
296 }
297
298 static
299 size_t mptsas_config_io_unit_2(MPTSASState *s, uint8_t **data, int address)
300 {
301 PCIDevice *pci = PCI_DEVICE(s);
302 uint8_t devfn = pci->devfn;
303 return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x02,
304 "llbbw*b*b*w*b*b*w*b*b*w*l",
305 0, 0x100, 0 /* pci bus? */, devfn, 0);
306 }
307
308 static
309 size_t mptsas_config_io_unit_3(MPTSASState *s, uint8_t **data, int address)
310 {
311 return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x01,
312 "*b*b*w*l");
313 }
314
315 static
316 size_t mptsas_config_io_unit_4(MPTSASState *s, uint8_t **data, int address)
317 {
318 return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x00, "*l*l*q");
319 }
320
321 /* I/O controller pages */
322
323 static
324 size_t mptsas_config_ioc_0(MPTSASState *s, uint8_t **data, int address)
325 {
326 PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
327
328 return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_IOC, 0x01,
329 "*l*lwwb*b*b*blww",
330 pcic->vendor_id, pcic->device_id, pcic->revision,
331 pcic->class_id, pcic->subsystem_vendor_id,
332 pcic->subsystem_id);
333 }
334
335 static
336 size_t mptsas_config_ioc_1(MPTSASState *s, uint8_t **data, int address)
337 {
338 return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_IOC, 0x03,
339 "*l*l*b*b*b*b");
340 }
341
342 static
343 size_t mptsas_config_ioc_2(MPTSASState *s, uint8_t **data, int address)
344 {
345 return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_IOC, 0x04,
346 "*l*b*b*b*b");
347 }
348
349 static
350 size_t mptsas_config_ioc_3(MPTSASState *s, uint8_t **data, int address)
351 {
352 return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_IOC, 0x00,
353 "*b*b*w");
354 }
355
356 static
357 size_t mptsas_config_ioc_4(MPTSASState *s, uint8_t **data, int address)
358 {
359 return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_IOC, 0x00,
360 "*b*b*w");
361 }
362
363 static
364 size_t mptsas_config_ioc_5(MPTSASState *s, uint8_t **data, int address)
365 {
366 return MPTSAS_CONFIG_PACK(5, MPI_CONFIG_PAGETYPE_IOC, 0x00,
367 "*l*b*b*w");
368 }
369
370 static
371 size_t mptsas_config_ioc_6(MPTSASState *s, uint8_t **data, int address)
372 {
373 return MPTSAS_CONFIG_PACK(6, MPI_CONFIG_PAGETYPE_IOC, 0x01,
374 "*l*b*b*b*b*b*b*b*b*b*b*w*l*l*l*l*b*b*w"
375 "*w*w*w*w*l*l*l");
376 }
377
378 /* SAS I/O unit pages (extended) */
379
380 #define MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE 16
381
382 #define MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION 0x02
383 #define MPI_SAS_IOUNIT0_RATE_1_5 0x08
384 #define MPI_SAS_IOUNIT0_RATE_3_0 0x09
385
386 #define MPI_SAS_DEVICE_INFO_NO_DEVICE 0x00000000
387 #define MPI_SAS_DEVICE_INFO_END_DEVICE 0x00000001
388 #define MPI_SAS_DEVICE_INFO_SSP_TARGET 0x00000400
389
390 #define MPI_SAS_DEVICE0_ASTATUS_NO_ERRORS 0x00
391
392 #define MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT 0x0001
393 #define MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED 0x0002
394 #define MPI_SAS_DEVICE0_FLAGS_MAPPING_PERSISTENT 0x0004
395
396
397
398 static SCSIDevice *mptsas_phy_get_device(MPTSASState *s, int i,
399 int *phy_handle, int *dev_handle)
400 {
401 SCSIDevice *d = scsi_device_find(&s->bus, 0, i, 0);
402
403 if (phy_handle) {
404 *phy_handle = i + 1;
405 }
406 if (dev_handle) {
407 *dev_handle = d ? i + 1 + MPTSAS_NUM_PORTS : 0;
408 }
409 return d;
410 }
411
412 static
413 size_t mptsas_config_sas_io_unit_0(MPTSASState *s, uint8_t **data, int address)
414 {
415 size_t size = MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x04,
416 "*w*wb*b*w"
417 repl(MPTSAS_NUM_PORTS, "*s16"),
418 MPTSAS_NUM_PORTS);
419
420 if (data) {
421 size_t ofs = size - MPTSAS_NUM_PORTS * MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE;
422 int i;
423
424 for (i = 0; i < MPTSAS_NUM_PORTS; i++) {
425 int phy_handle, dev_handle;
426 SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
427
428 fill(*data + ofs, MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE,
429 "bbbblwwl", i, 0, 0,
430 (dev
431 ? MPI_SAS_IOUNIT0_RATE_3_0
432 : MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION),
433 (dev
434 ? MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET
435 : MPI_SAS_DEVICE_INFO_NO_DEVICE),
436 dev_handle,
437 dev_handle,
438 0);
439 ofs += MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE;
440 }
441 assert(ofs == size);
442 }
443 return size;
444 }
445
446 #define MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE 12
447
448 static
449 size_t mptsas_config_sas_io_unit_1(MPTSASState *s, uint8_t **data, int address)
450 {
451 size_t size = MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x07,
452 "*w*w*w*wb*b*b*b"
453 repl(MPTSAS_NUM_PORTS, "*s12"),
454 MPTSAS_NUM_PORTS);
455
456 if (data) {
457 size_t ofs = size - MPTSAS_NUM_PORTS * MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE;
458 int i;
459
460 for (i = 0; i < MPTSAS_NUM_PORTS; i++) {
461 SCSIDevice *dev = mptsas_phy_get_device(s, i, NULL, NULL);
462 fill(*data + ofs, MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE,
463 "bbbblww", i, 0, 0,
464 (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5,
465 (dev
466 ? MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET
467 : MPI_SAS_DEVICE_INFO_NO_DEVICE),
468 0, 0);
469 ofs += MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE;
470 }
471 assert(ofs == size);
472 }
473 return size;
474 }
475
476 static
477 size_t mptsas_config_sas_io_unit_2(MPTSASState *s, uint8_t **data, int address)
478 {
479 return MPTSAS_CONFIG_PACK_EXT(2, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x06,
480 "*b*b*w*w*w*b*b*w");
481 }
482
483 static
484 size_t mptsas_config_sas_io_unit_3(MPTSASState *s, uint8_t **data, int address)
485 {
486 return MPTSAS_CONFIG_PACK_EXT(3, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x06,
487 "*l*l*l*l*l*l*l*l*l");
488 }
489
490 /* SAS PHY pages (extended) */
491
492 static int mptsas_phy_addr_get(MPTSASState *s, int address)
493 {
494 int i;
495 if ((address >> MPI_SAS_PHY_PGAD_FORM_SHIFT) == 0) {
496 i = address & 255;
497 } else if ((address >> MPI_SAS_PHY_PGAD_FORM_SHIFT) == 1) {
498 i = address & 65535;
499 } else {
500 return -EINVAL;
501 }
502
503 if (i >= MPTSAS_NUM_PORTS) {
504 return -EINVAL;
505 }
506
507 return i;
508 }
509
510 static
511 size_t mptsas_config_phy_0(MPTSASState *s, uint8_t **data, int address)
512 {
513 int phy_handle = -1;
514 int dev_handle = -1;
515 int i = mptsas_phy_addr_get(s, address);
516 SCSIDevice *dev;
517
518 if (i < 0) {
519 trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 0);
520 return i;
521 }
522
523 dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
524 trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 0);
525
526 return MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_PHY, 0x01,
527 "w*wqwb*blbb*b*b*l",
528 dev_handle, s->sas_addr, dev_handle, i,
529 (dev
530 ? MPI_SAS_DEVICE_INFO_END_DEVICE /* | MPI_SAS_DEVICE_INFO_SSP_TARGET?? */
531 : MPI_SAS_DEVICE_INFO_NO_DEVICE),
532 (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5,
533 (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5);
534 }
535
536 static
537 size_t mptsas_config_phy_1(MPTSASState *s, uint8_t **data, int address)
538 {
539 int phy_handle = -1;
540 int dev_handle = -1;
541 int i = mptsas_phy_addr_get(s, address);
542
543 if (i < 0) {
544 trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 1);
545 return i;
546 }
547
548 (void) mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
549 trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 1);
550
551 return MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_PHY, 0x01,
552 "*l*l*l*l*l");
553 }
554
555 /* SAS device pages (extended) */
556
557 static int mptsas_device_addr_get(MPTSASState *s, int address)
558 {
559 uint32_t handle, i;
560 uint32_t form = address >> MPI_SAS_PHY_PGAD_FORM_SHIFT;
561 if (form == MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE) {
562 handle = address & MPI_SAS_DEVICE_PGAD_GNH_HANDLE_MASK;
563 do {
564 if (handle == 65535) {
565 handle = MPTSAS_NUM_PORTS + 1;
566 } else {
567 ++handle;
568 }
569 i = handle - 1 - MPTSAS_NUM_PORTS;
570 } while (i < MPTSAS_NUM_PORTS && !scsi_device_find(&s->bus, 0, i, 0));
571
572 } else if (form == MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID) {
573 if (address & MPI_SAS_DEVICE_PGAD_BT_BUS_MASK) {
574 return -EINVAL;
575 }
576 i = address & MPI_SAS_DEVICE_PGAD_BT_TID_MASK;
577
578 } else if (form == MPI_SAS_DEVICE_PGAD_FORM_HANDLE) {
579 handle = address & MPI_SAS_DEVICE_PGAD_H_HANDLE_MASK;
580 i = handle - 1 - MPTSAS_NUM_PORTS;
581
582 } else {
583 return -EINVAL;
584 }
585
586 if (i >= MPTSAS_NUM_PORTS) {
587 return -EINVAL;
588 }
589
590 return i;
591 }
592
593 static
594 size_t mptsas_config_sas_device_0(MPTSASState *s, uint8_t **data, int address)
595 {
596 int phy_handle = -1;
597 int dev_handle = -1;
598 int i = mptsas_device_addr_get(s, address);
599 SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
600
601 trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 0);
602 if (!dev) {
603 return -ENOENT;
604 }
605
606 return MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x05,
607 "*w*wqwbbwbblwb*b",
608 dev->wwn, phy_handle, i,
609 MPI_SAS_DEVICE0_ASTATUS_NO_ERRORS,
610 dev_handle, i, 0,
611 MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET,
612 (MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT |
613 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED |
614 MPI_SAS_DEVICE0_FLAGS_MAPPING_PERSISTENT), i);
615 }
616
617 static
618 size_t mptsas_config_sas_device_1(MPTSASState *s, uint8_t **data, int address)
619 {
620 int phy_handle = -1;
621 int dev_handle = -1;
622 int i = mptsas_device_addr_get(s, address);
623 SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
624
625 trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 1);
626 if (!dev) {
627 return -ENOENT;
628 }
629
630 return MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x00,
631 "*lq*lwbb*s20",
632 dev->wwn, dev_handle, i, 0);
633 }
634
635 static
636 size_t mptsas_config_sas_device_2(MPTSASState *s, uint8_t **data, int address)
637 {
638 int phy_handle = -1;
639 int dev_handle = -1;
640 int i = mptsas_device_addr_get(s, address);
641 SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
642
643 trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 2);
644 if (!dev) {
645 return -ENOENT;
646 }
647
648 return MPTSAS_CONFIG_PACK_EXT(2, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x01,
649 "ql", dev->wwn, 0);
650 }
651
652 typedef struct MPTSASConfigPage {
653 uint8_t number;
654 uint8_t type;
655 size_t (*mpt_config_build)(MPTSASState *s, uint8_t **data, int address);
656 } MPTSASConfigPage;
657
658 static const MPTSASConfigPage mptsas_config_pages[] = {
659 {
660 0, MPI_CONFIG_PAGETYPE_MANUFACTURING,
661 mptsas_config_manufacturing_0,
662 }, {
663 1, MPI_CONFIG_PAGETYPE_MANUFACTURING,
664 mptsas_config_manufacturing_1,
665 }, {
666 2, MPI_CONFIG_PAGETYPE_MANUFACTURING,
667 mptsas_config_manufacturing_2,
668 }, {
669 3, MPI_CONFIG_PAGETYPE_MANUFACTURING,
670 mptsas_config_manufacturing_3,
671 }, {
672 4, MPI_CONFIG_PAGETYPE_MANUFACTURING,
673 mptsas_config_manufacturing_4,
674 }, {
675 5, MPI_CONFIG_PAGETYPE_MANUFACTURING,
676 mptsas_config_manufacturing_5,
677 }, {
678 6, MPI_CONFIG_PAGETYPE_MANUFACTURING,
679 mptsas_config_manufacturing_6,
680 }, {
681 7, MPI_CONFIG_PAGETYPE_MANUFACTURING,
682 mptsas_config_manufacturing_7,
683 }, {
684 8, MPI_CONFIG_PAGETYPE_MANUFACTURING,
685 mptsas_config_manufacturing_8,
686 }, {
687 9, MPI_CONFIG_PAGETYPE_MANUFACTURING,
688 mptsas_config_manufacturing_9,
689 }, {
690 10, MPI_CONFIG_PAGETYPE_MANUFACTURING,
691 mptsas_config_manufacturing_10,
692 }, {
693 0, MPI_CONFIG_PAGETYPE_IO_UNIT,
694 mptsas_config_io_unit_0,
695 }, {
696 1, MPI_CONFIG_PAGETYPE_IO_UNIT,
697 mptsas_config_io_unit_1,
698 }, {
699 2, MPI_CONFIG_PAGETYPE_IO_UNIT,
700 mptsas_config_io_unit_2,
701 }, {
702 3, MPI_CONFIG_PAGETYPE_IO_UNIT,
703 mptsas_config_io_unit_3,
704 }, {
705 4, MPI_CONFIG_PAGETYPE_IO_UNIT,
706 mptsas_config_io_unit_4,
707 }, {
708 0, MPI_CONFIG_PAGETYPE_IOC,
709 mptsas_config_ioc_0,
710 }, {
711 1, MPI_CONFIG_PAGETYPE_IOC,
712 mptsas_config_ioc_1,
713 }, {
714 2, MPI_CONFIG_PAGETYPE_IOC,
715 mptsas_config_ioc_2,
716 }, {
717 3, MPI_CONFIG_PAGETYPE_IOC,
718 mptsas_config_ioc_3,
719 }, {
720 4, MPI_CONFIG_PAGETYPE_IOC,
721 mptsas_config_ioc_4,
722 }, {
723 5, MPI_CONFIG_PAGETYPE_IOC,
724 mptsas_config_ioc_5,
725 }, {
726 6, MPI_CONFIG_PAGETYPE_IOC,
727 mptsas_config_ioc_6,
728 }, {
729 0, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
730 mptsas_config_sas_io_unit_0,
731 }, {
732 1, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
733 mptsas_config_sas_io_unit_1,
734 }, {
735 2, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
736 mptsas_config_sas_io_unit_2,
737 }, {
738 3, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
739 mptsas_config_sas_io_unit_3,
740 }, {
741 0, MPI_CONFIG_EXTPAGETYPE_SAS_PHY,
742 mptsas_config_phy_0,
743 }, {
744 1, MPI_CONFIG_EXTPAGETYPE_SAS_PHY,
745 mptsas_config_phy_1,
746 }, {
747 0, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
748 mptsas_config_sas_device_0,
749 }, {
750 1, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
751 mptsas_config_sas_device_1,
752 }, {
753 2, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
754 mptsas_config_sas_device_2,
755 }
756 };
757
758 static const MPTSASConfigPage *mptsas_find_config_page(int type, int number)
759 {
760 const MPTSASConfigPage *page;
761 int i;
762
763 for (i = 0; i < ARRAY_SIZE(mptsas_config_pages); i++) {
764 page = &mptsas_config_pages[i];
765 if (page->type == type && page->number == number) {
766 return page;
767 }
768 }
769
770 return NULL;
771 }
772
773 void mptsas_process_config(MPTSASState *s, MPIMsgConfig *req)
774 {
775 PCIDevice *pci = PCI_DEVICE(s);
776
777 MPIMsgConfigReply reply;
778 const MPTSASConfigPage *page;
779 size_t length;
780 uint8_t type;
781 uint8_t *data = NULL;
782 uint32_t flags_and_length;
783 uint32_t dmalen;
784 uint64_t pa;
785
786 mptsas_fix_config_endianness(req);
787
788 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
789 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
790
791 /* Copy common bits from the request into the reply. */
792 memset(&reply, 0, sizeof(reply));
793 reply.Action = req->Action;
794 reply.Function = req->Function;
795 reply.MsgContext = req->MsgContext;
796 reply.MsgLength = sizeof(reply) / 4;
797 reply.PageType = req->PageType;
798 reply.PageNumber = req->PageNumber;
799 reply.PageLength = req->PageLength;
800 reply.PageVersion = req->PageVersion;
801
802 type = req->PageType & MPI_CONFIG_PAGETYPE_MASK;
803 if (type == MPI_CONFIG_PAGETYPE_EXTENDED) {
804 type = req->ExtPageType;
805 if (type <= MPI_CONFIG_PAGETYPE_MASK) {
806 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_TYPE;
807 goto out;
808 }
809
810 reply.ExtPageType = req->ExtPageType;
811 }
812
813 page = mptsas_find_config_page(type, req->PageNumber);
814
815 switch(req->Action) {
816 case MPI_CONFIG_ACTION_PAGE_DEFAULT:
817 case MPI_CONFIG_ACTION_PAGE_HEADER:
818 case MPI_CONFIG_ACTION_PAGE_READ_NVRAM:
819 case MPI_CONFIG_ACTION_PAGE_READ_CURRENT:
820 case MPI_CONFIG_ACTION_PAGE_READ_DEFAULT:
821 case MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT:
822 case MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM:
823 break;
824
825 default:
826 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_ACTION;
827 goto out;
828 }
829
830 if (!page) {
831 page = mptsas_find_config_page(type, 1);
832 if (page) {
833 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
834 } else {
835 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_TYPE;
836 }
837 goto out;
838 }
839
840 if (req->Action == MPI_CONFIG_ACTION_PAGE_DEFAULT ||
841 req->Action == MPI_CONFIG_ACTION_PAGE_HEADER) {
842 length = page->mpt_config_build(s, NULL, req->PageAddress);
843 if ((ssize_t)length < 0) {
844 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
845 goto out;
846 } else {
847 goto done;
848 }
849 }
850
851 if (req->Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
852 req->Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
853 length = page->mpt_config_build(s, NULL, req->PageAddress);
854 if ((ssize_t)length < 0) {
855 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
856 } else {
857 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_CANT_COMMIT;
858 }
859 goto out;
860 }
861
862 flags_and_length = req->PageBufferSGE.FlagsLength;
863 dmalen = flags_and_length & MPI_SGE_LENGTH_MASK;
864 if (dmalen == 0) {
865 length = page->mpt_config_build(s, NULL, req->PageAddress);
866 if ((ssize_t)length < 0) {
867 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
868 goto out;
869 } else {
870 goto done;
871 }
872 }
873
874 if (flags_and_length & MPI_SGE_FLAGS_64_BIT_ADDRESSING) {
875 pa = req->PageBufferSGE.u.Address64;
876 } else {
877 pa = req->PageBufferSGE.u.Address32;
878 }
879
880 /* Only read actions left. */
881 length = page->mpt_config_build(s, &data, req->PageAddress);
882 if ((ssize_t)length < 0) {
883 reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
884 goto out;
885 } else {
886 assert(data[2] == page->number);
887 pci_dma_write(pci, pa, data, MIN(length, dmalen));
888 goto done;
889 }
890
891 abort();
892
893 done:
894 if (type > MPI_CONFIG_PAGETYPE_MASK) {
895 reply.ExtPageLength = length / 4;
896 reply.ExtPageType = req->ExtPageType;
897 } else {
898 reply.PageLength = length / 4;
899 }
900
901 out:
902 mptsas_fix_config_reply_endianness(&reply);
903 mptsas_reply(s, (MPIDefaultReply *)&reply);
904 g_free(data);
905 }