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