qemu

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.1 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/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

39
typedef union PackValue {
40
    uint64_t ll;
41
    char *str;
42
} PackValue;
43

44
static 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

114
static 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);
125
        va_end(ap2);
126
    }
127
    return vfill(data, size, fmt, ap1);
128
}
129

130
static 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

150
static 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) {
160
        assert(ret / 4 < 256 && (ret % 4) == 0);
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

170
static 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

188
static
189
size_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

200
static
201
size_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,
205
                              "*s256");
206
}
207

208
static
209
size_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

217
static
218
size_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

226
static
227
size_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

235
static
236
size_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

242
static
243
size_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

249
static
250
size_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

256
static
257
size_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

263
static
264
size_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

270
static
271
size_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

279
static
280
size_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

290
static
291
size_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

297
static
298
size_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

307
static
308
size_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

314
static
315
size_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

322
static
323
size_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,
330
                              pcic->class_id, pcic->subsystem_vendor_id,
331
                              pcic->subsystem_id);
332
}
333

334
static
335
size_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

341
static
342
size_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

348
static
349
size_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

355
static
356
size_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

362
static
363
size_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

369
static
370
size_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

397
static 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

411
static
412
size_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

447
static
448
size_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

475
static
476
size_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

482
static
483
size_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

491
static 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

509
static
510
size_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

535
static
536
size_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

556
static 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

592
static
593
size_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

616
static
617
size_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

634
static
635
size_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

651
typedef 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

657
static 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

757
static 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

772
void 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

892
done:
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

900
out:
901
    mptsas_fix_config_reply_endianness(&reply);
902
    mptsas_reply(s, (MPIDefaultReply *)&reply);
903
    g_free(data);
904
}
905