Statistics
| Branch: | Revision:

root / hw / msi.c @ 531a0b82

History | View | Annotate | Download (11.1 kB)

1
/*
2
 * msi.c
3
 *
4
 * Copyright (c) 2010 Isaku Yamahata <yamahata at valinux co jp>
5
 *                    VA Linux Systems Japan K.K.
6
 *
7
 * This program is free software; you can redistribute it and/or modify
8
 * it under the terms of the GNU General Public License as published by
9
 * the Free Software Foundation; either version 2 of the License, or
10
 * (at your option) any later version.
11

12
 * This program is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 * GNU General Public License for more details.
16

17
 * You should have received a copy of the GNU General Public License along
18
 * with this program; if not, see <http://www.gnu.org/licenses/>.
19
 */
20

    
21
#include "msi.h"
22
#include "range.h"
23

    
24
/* Eventually those constants should go to Linux pci_regs.h */
25
#define PCI_MSI_PENDING_32      0x10
26
#define PCI_MSI_PENDING_64      0x14
27

    
28
/* PCI_MSI_ADDRESS_LO */
29
#define PCI_MSI_ADDRESS_LO_MASK         (~0x3)
30

    
31
/* If we get rid of cap allocator, we won't need those. */
32
#define PCI_MSI_32_SIZEOF       0x0a
33
#define PCI_MSI_64_SIZEOF       0x0e
34
#define PCI_MSI_32M_SIZEOF      0x14
35
#define PCI_MSI_64M_SIZEOF      0x18
36

    
37
#define PCI_MSI_VECTORS_MAX     32
38

    
39
/* If we get rid of cap allocator, we won't need this. */
40
static inline uint8_t msi_cap_sizeof(uint16_t flags)
41
{
42
    switch (flags & (PCI_MSI_FLAGS_MASKBIT | PCI_MSI_FLAGS_64BIT)) {
43
    case PCI_MSI_FLAGS_MASKBIT | PCI_MSI_FLAGS_64BIT:
44
        return PCI_MSI_64M_SIZEOF;
45
    case PCI_MSI_FLAGS_64BIT:
46
        return PCI_MSI_64_SIZEOF;
47
    case PCI_MSI_FLAGS_MASKBIT:
48
        return PCI_MSI_32M_SIZEOF;
49
    case 0:
50
        return PCI_MSI_32_SIZEOF;
51
    default:
52
        abort();
53
        break;
54
    }
55
    return 0;
56
}
57

    
58
//#define MSI_DEBUG
59

    
60
#ifdef MSI_DEBUG
61
# define MSI_DPRINTF(fmt, ...)                                          \
62
    fprintf(stderr, "%s:%d " fmt, __func__, __LINE__, ## __VA_ARGS__)
63
#else
64
# define MSI_DPRINTF(fmt, ...)  do { } while (0)
65
#endif
66
#define MSI_DEV_PRINTF(dev, fmt, ...)                                   \
67
    MSI_DPRINTF("%s:%x " fmt, (dev)->name, (dev)->devfn, ## __VA_ARGS__)
68

    
69
static inline unsigned int msi_nr_vectors(uint16_t flags)
70
{
71
    return 1U <<
72
        ((flags & PCI_MSI_FLAGS_QSIZE) >> (ffs(PCI_MSI_FLAGS_QSIZE) - 1));
73
}
74

    
75
static inline uint8_t msi_flags_off(const PCIDevice* dev)
76
{
77
    return dev->msi_cap + PCI_MSI_FLAGS;
78
}
79

    
80
static inline uint8_t msi_address_lo_off(const PCIDevice* dev)
81
{
82
    return dev->msi_cap + PCI_MSI_ADDRESS_LO;
83
}
84

    
85
static inline uint8_t msi_address_hi_off(const PCIDevice* dev)
86
{
87
    return dev->msi_cap + PCI_MSI_ADDRESS_HI;
88
}
89

    
90
static inline uint8_t msi_data_off(const PCIDevice* dev, bool msi64bit)
91
{
92
    return dev->msi_cap + (msi64bit ? PCI_MSI_DATA_64 : PCI_MSI_DATA_32);
93
}
94

    
95
static inline uint8_t msi_mask_off(const PCIDevice* dev, bool msi64bit)
96
{
97
    return dev->msi_cap + (msi64bit ? PCI_MSI_MASK_64 : PCI_MSI_MASK_32);
98
}
99

    
100
static inline uint8_t msi_pending_off(const PCIDevice* dev, bool msi64bit)
101
{
102
    return dev->msi_cap + (msi64bit ? PCI_MSI_PENDING_64 : PCI_MSI_PENDING_32);
103
}
104

    
105
bool msi_enabled(const PCIDevice *dev)
106
{
107
    return msi_present(dev) &&
108
        (pci_get_word(dev->config + msi_flags_off(dev)) &
109
         PCI_MSI_FLAGS_ENABLE);
110
}
111

    
112
int msi_init(struct PCIDevice *dev, uint8_t offset,
113
             unsigned int nr_vectors, bool msi64bit, bool msi_per_vector_mask)
114
{
115
    unsigned int vectors_order;
116
    uint16_t flags;
117
    uint8_t cap_size;
118
    int config_offset;
119
    MSI_DEV_PRINTF(dev,
120
                   "init offset: 0x%"PRIx8" vector: %"PRId8
121
                   " 64bit %d mask %d\n",
122
                   offset, nr_vectors, msi64bit, msi_per_vector_mask);
123

    
124
    assert(!(nr_vectors & (nr_vectors - 1)));   /* power of 2 */
125
    assert(nr_vectors > 0);
126
    assert(nr_vectors <= PCI_MSI_VECTORS_MAX);
127
    /* the nr of MSI vectors is up to 32 */
128
    vectors_order = ffs(nr_vectors) - 1;
129

    
130
    flags = vectors_order << (ffs(PCI_MSI_FLAGS_QMASK) - 1);
131
    if (msi64bit) {
132
        flags |= PCI_MSI_FLAGS_64BIT;
133
    }
134
    if (msi_per_vector_mask) {
135
        flags |= PCI_MSI_FLAGS_MASKBIT;
136
    }
137

    
138
    cap_size = msi_cap_sizeof(flags);
139
    config_offset = pci_add_capability(dev, PCI_CAP_ID_MSI, offset, cap_size);
140
    if (config_offset < 0) {
141
        return config_offset;
142
    }
143

    
144
    dev->msi_cap = config_offset;
145
    dev->cap_present |= QEMU_PCI_CAP_MSI;
146

    
147
    pci_set_word(dev->config + msi_flags_off(dev), flags);
148
    pci_set_word(dev->wmask + msi_flags_off(dev),
149
                 PCI_MSI_FLAGS_QSIZE | PCI_MSI_FLAGS_ENABLE);
150
    pci_set_long(dev->wmask + msi_address_lo_off(dev),
151
                 PCI_MSI_ADDRESS_LO_MASK);
152
    if (msi64bit) {
153
        pci_set_long(dev->wmask + msi_address_hi_off(dev), 0xffffffff);
154
    }
155
    pci_set_word(dev->wmask + msi_data_off(dev, msi64bit), 0xffff);
156

    
157
    if (msi_per_vector_mask) {
158
        pci_set_long(dev->wmask + msi_mask_off(dev, msi64bit),
159
                     /* (1U << nr_vectors) - 1 is undefined
160
                        when nr_vectors = 32 */
161
                     0xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors));
162
    }
163
    return config_offset;
164
}
165

    
166
void msi_uninit(struct PCIDevice *dev)
167
{
168
    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
169
    uint8_t cap_size = msi_cap_sizeof(flags);
170
    pci_del_capability(dev, PCI_CAP_ID_MSIX, cap_size);
171
    MSI_DEV_PRINTF(dev, "uninit\n");
172
}
173

    
174
void msi_reset(PCIDevice *dev)
175
{
176
    uint16_t flags;
177
    bool msi64bit;
178

    
179
    flags = pci_get_word(dev->config + msi_flags_off(dev));
180
    flags &= ~(PCI_MSI_FLAGS_QSIZE | PCI_MSI_FLAGS_ENABLE);
181
    msi64bit = flags & PCI_MSI_FLAGS_64BIT;
182

    
183
    pci_set_word(dev->config + msi_flags_off(dev), flags);
184
    pci_set_long(dev->config + msi_address_lo_off(dev), 0);
185
    if (msi64bit) {
186
        pci_set_long(dev->config + msi_address_hi_off(dev), 0);
187
    }
188
    pci_set_word(dev->config + msi_data_off(dev, msi64bit), 0);
189
    if (flags & PCI_MSI_FLAGS_MASKBIT) {
190
        pci_set_long(dev->config + msi_mask_off(dev, msi64bit), 0);
191
        pci_set_long(dev->config + msi_pending_off(dev, msi64bit), 0);
192
    }
193
    MSI_DEV_PRINTF(dev, "reset\n");
194
}
195

    
196
static bool msi_is_masked(const PCIDevice *dev, unsigned int vector)
197
{
198
    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
199
    uint32_t mask;
200
    assert(vector < PCI_MSI_VECTORS_MAX);
201

    
202
    if (!(flags & PCI_MSI_FLAGS_MASKBIT)) {
203
        return false;
204
    }
205

    
206
    mask = pci_get_long(dev->config +
207
                        msi_mask_off(dev, flags & PCI_MSI_FLAGS_64BIT));
208
    return mask & (1U << vector);
209
}
210

    
211
void msi_notify(PCIDevice *dev, unsigned int vector)
212
{
213
    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
214
    bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
215
    unsigned int nr_vectors = msi_nr_vectors(flags);
216
    uint64_t address;
217
    uint32_t data;
218

    
219
    assert(vector < nr_vectors);
220
    if (msi_is_masked(dev, vector)) {
221
        assert(flags & PCI_MSI_FLAGS_MASKBIT);
222
        pci_long_test_and_set_mask(
223
            dev->config + msi_pending_off(dev, msi64bit), 1U << vector);
224
        MSI_DEV_PRINTF(dev, "pending vector 0x%x\n", vector);
225
        return;
226
    }
227

    
228
    if (msi64bit){
229
        address = pci_get_quad(dev->config + msi_address_lo_off(dev));
230
    } else {
231
        address = pci_get_long(dev->config + msi_address_lo_off(dev));
232
    }
233

    
234
    /* upper bit 31:16 is zero */
235
    data = pci_get_word(dev->config + msi_data_off(dev, msi64bit));
236
    if (nr_vectors > 1) {
237
        data &= ~(nr_vectors - 1);
238
        data |= vector;
239
    }
240

    
241
    MSI_DEV_PRINTF(dev,
242
                   "notify vector 0x%x"
243
                   " address: 0x%"PRIx64" data: 0x%"PRIx32"\n",
244
                   vector, address, data);
245
    stl_phys(address, data);
246
}
247

    
248
/* call this function after updating configs by pci_default_write_config(). */
249
void msi_write_config(PCIDevice *dev, uint32_t addr, uint32_t val, int len)
250
{
251
    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
252
    bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
253
    bool msi_per_vector_mask = flags & PCI_MSI_FLAGS_MASKBIT;
254
    unsigned int nr_vectors;
255
    uint8_t log_num_vecs;
256
    uint8_t log_max_vecs;
257
    unsigned int vector;
258
    uint32_t pending;
259
    int i;
260

    
261
    if (!ranges_overlap(addr, len, dev->msi_cap, msi_cap_sizeof(flags))) {
262
        return;
263
    }
264

    
265
#ifdef MSI_DEBUG
266
    MSI_DEV_PRINTF(dev, "addr 0x%"PRIx32" val 0x%"PRIx32" len %d\n",
267
                   addr, val, len);
268
    MSI_DEV_PRINTF(dev, "ctrl: 0x%"PRIx16" address: 0x%"PRIx32,
269
                   flags,
270
                   pci_get_long(dev->config + msi_address_lo_off(dev)));
271
    if (msi64bit) {
272
        fprintf(stderr, " addrss-hi: 0x%"PRIx32,
273
                pci_get_long(dev->config + msi_address_hi_off(dev)));
274
    }
275
    fprintf(stderr, " data: 0x%"PRIx16,
276
            pci_get_word(dev->config + msi_data_off(dev, msi64bit)));
277
    if (flags & PCI_MSI_FLAGS_MASKBIT) {
278
        fprintf(stderr, " mask 0x%"PRIx32" pending 0x%"PRIx32,
279
                pci_get_long(dev->config + msi_mask_off(dev, msi64bit)),
280
                pci_get_long(dev->config + msi_pending_off(dev, msi64bit)));
281
    }
282
    fprintf(stderr, "\n");
283
#endif
284

    
285
    if (!(flags & PCI_MSI_FLAGS_ENABLE)) {
286
        return;
287
    }
288

    
289
    /*
290
     * Now MSI is enabled, clear INTx# interrupts.
291
     * the driver is prohibited from writing enable bit to mask
292
     * a service request. But the guest OS could do this.
293
     * So we just discard the interrupts as moderate fallback.
294
     *
295
     * 6.8.3.3. Enabling Operation
296
     *   While enabled for MSI or MSI-X operation, a function is prohibited
297
     *   from using its INTx# pin (if implemented) to request
298
     *   service (MSI, MSI-X, and INTx# are mutually exclusive).
299
     */
300
    for (i = 0; i < PCI_NUM_PINS; ++i) {
301
        qemu_set_irq(dev->irq[i], 0);
302
    }
303

    
304
    /*
305
     * nr_vectors might be set bigger than capable. So clamp it.
306
     * This is not legal by spec, so we can do anything we like,
307
     * just don't crash the host
308
     */
309
    log_num_vecs =
310
        (flags & PCI_MSI_FLAGS_QSIZE) >> (ffs(PCI_MSI_FLAGS_QSIZE) - 1);
311
    log_max_vecs =
312
        (flags & PCI_MSI_FLAGS_QMASK) >> (ffs(PCI_MSI_FLAGS_QMASK) - 1);
313
    if (log_num_vecs > log_max_vecs) {
314
        flags &= ~PCI_MSI_FLAGS_QSIZE;
315
        flags |= log_max_vecs << (ffs(PCI_MSI_FLAGS_QSIZE) - 1);
316
        pci_set_word(dev->config + msi_flags_off(dev), flags);
317
    }
318

    
319
    if (!msi_per_vector_mask) {
320
        /* if per vector masking isn't supported,
321
           there is no pending interrupt. */
322
        return;
323
    }
324

    
325
    nr_vectors = msi_nr_vectors(flags);
326

    
327
    /* This will discard pending interrupts, if any. */
328
    pending = pci_get_long(dev->config + msi_pending_off(dev, msi64bit));
329
    pending &= 0xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors);
330
    pci_set_long(dev->config + msi_pending_off(dev, msi64bit), pending);
331

    
332
    /* deliver pending interrupts which are unmasked */
333
    for (vector = 0; vector < nr_vectors; ++vector) {
334
        if (msi_is_masked(dev, vector) || !(pending & (1U << vector))) {
335
            continue;
336
        }
337

    
338
        pci_long_test_and_clear_mask(
339
            dev->config + msi_pending_off(dev, msi64bit), 1U << vector);
340
        msi_notify(dev, vector);
341
    }
342
}
343

    
344
unsigned int msi_nr_vectors_allocated(const PCIDevice *dev)
345
{
346
    uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
347
    return msi_nr_vectors(flags);
348
}