xref: /openbmc/qemu/hw/scsi/mptconfig.c (revision 4a09d0bb)
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 }
906