7297eb69b3839e7841e567d7fcb3f862bcc79688
[barrelfish] / usr / pci / pci_service.c
1  /**
2  * \file
3  * \brief PCI service code
4  *
5  * This file exports the PCI service interface for drivers
6  */
7
8 /*
9  * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
10  * All rights reserved.
11  *
12  * This file is distributed under the terms in the attached LICENSE file.
13  * If you do not find this file, copies can be found by writing to:
14  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
15  */
16
17 #include <stdio.h>
18 #include <stdlib.h>
19
20 #include <barrelfish/barrelfish.h>
21 #include <barrelfish/nameservice_client.h>
22 #include <barrelfish/sys_debug.h>
23
24 #include <if/pci_defs.h>
25 #include <if/acpi_rpcclient_defs.h>
26
27 #include <acpi_client/acpi_client.h>
28 #include <mm/mm.h>
29 //#include "pci_confspace.h"
30
31 #include "pci.h"
32 #include "pci_debug.h"
33
34 /*****************************************************************
35  * Data types:
36  *****************************************************************/
37
38 /* Per-client state
39  * XXX: this assumes only one driver per client */
40 struct client_state {
41 //    struct device_mem *bar_info;
42     uint8_t initialized;
43     int nr_allocated_bars;
44     uint32_t nr_caps_bar[PCI_NBARS];
45     uint32_t bus;
46     uint32_t dev;
47     uint32_t fun;
48     bool pcie;
49     void *cont_st;
50 };
51
52 /*****************************************************************
53  * Event handlers:
54  *****************************************************************/
55 /*
56     cc->bus = cc->dev = cc->fun = 0;
57 */
58
59 static void init_pci_device_handler(struct pci_binding *b,
60                                     uint32_t class_code, uint32_t sub_class,
61                                     uint32_t prog_if, uint32_t vendor_id,
62                                     uint32_t device_id,
63                                     uint32_t bus, uint32_t dev, uint32_t fun)
64 {
65     struct client_state *cc = (struct client_state *) b->st;
66     errval_t err;
67
68
69     err = device_init(class_code, sub_class, prog_if, vendor_id, device_id,
70                       &bus, &dev, &fun, &(cc->pcie), &(cc->nr_allocated_bars));
71
72     cc->bus = bus;
73     cc->dev = dev;
74     cc->fun = fun;
75
76     for (int i = 0; i < cc->nr_allocated_bars; i++) {
77         cc->nr_caps_bar[i] = pci_get_nr_caps_for_bar(bus, dev, fun, i);
78     }
79
80     if (err_is_fail(err)) {
81         err = b->tx_vtbl.init_pci_device_response(b, NOP_CONT, err, 0,
82                                                   cc->nr_caps_bar);
83
84     } else {
85         err = b->tx_vtbl.init_pci_device_response(b, NOP_CONT, err,
86                                                   cc->nr_allocated_bars,
87                                                   cc->nr_caps_bar);
88     }
89     assert(err_is_ok(err));
90 }
91
92 static void irq_enable_handler(struct pci_binding *b)
93 {
94     struct client_state *cc = (struct client_state *) b->st;
95     if(!cc->initialized){
96         b->tx_vtbl.irq_enable_response(b, NOP_CONT, PCI_ERR_DEVICE_NOT_INIT);
97         return;
98     }
99
100     pci_enable_interrupt_for_device(cc->bus, cc->dev, cc->fun, cc->pcie);
101     b->tx_vtbl.irq_enable_response(b, NOP_CONT, SYS_ERR_OK);
102 }
103
104 static void init_legacy_device_handler(struct pci_binding *b,
105                                        uint16_t iomin, uint16_t iomax,
106                                        uint8_t irq, coreid_t coreid,
107                                        uint32_t vector)
108 {
109     struct capref iocap = NULL_CAP;
110     errval_t e = SYS_ERR_OK;
111
112     PCI_DEBUG("pci: init_legacy_device_handler: called. irq:%"PRIu8", coreid:%"PRIuCOREID", vector:%"PRIu32"\n", irq, coreid, vector);
113
114     /* TODO: make sure nobody else has claimed iomin-iomax range */
115
116     /* construct iocap for this region */
117     if (iomin != 0 || iomax != 0) {
118         e = slot_alloc(&iocap);
119         if (err_is_fail(e)) {
120             e = err_push(e, LIB_ERR_SLOT_ALLOC);
121             goto reply;
122         }
123
124         e = cap_mint(iocap, cap_io, iomin, iomax);
125         if (err_is_fail(e)) {
126             e = err_push(e, PCI_ERR_MINT_IOCAP);
127             goto reply;
128         }
129     }
130
131     /* determine IOAPIC INTI for given GSI and map to core */
132     if (vector != (uint32_t)-1) {
133
134         struct acpi_rpc_client* cl = get_acpi_rpc_client();
135         errval_t ret_error;
136         e = cl->vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
137         assert(err_is_ok(e));
138         if (err_is_fail(ret_error)) {
139             DEBUG_ERR(e, "failed to route interrupt %d -> %d\n", irq, vector);
140             e = err_push(e, PCI_ERR_ROUTING_IRQ);
141             goto reply;
142         }
143     }
144
145     /* send reply */
146 reply:
147     e = b->tx_vtbl.init_legacy_device_response(b, NOP_CONT, e,
148                                                err_is_ok(e) ? iocap : NULL_CAP);
149     if (err_is_fail(e)) {
150         DEBUG_ERR(e, "failed to send reply");
151     }
152
153     PCI_DEBUG("pci: init_legacy_device_handler: terminated.\n");
154 }
155
156 static void get_bar_cap_response_resend(void *arg);
157
158 static void get_bar_cap_response_cont(struct pci_binding *b, errval_t err,
159                                   struct capref cap, uint8_t type, uint8_t bar_nr)
160 {
161     errval_t e;
162     e = b->tx_vtbl.get_bar_cap_response(b, NOP_CONT, err, cap, type, bar_nr);
163     if(err_is_fail(e)) {
164         if(err_no(e) == FLOUNDER_ERR_TX_BUSY) {
165             struct client_state *st = b->st;
166             struct pci_get_bar_cap_response__args *me = malloc(sizeof(*me));
167             assert(me != NULL);
168             me->err = err;
169             me->cap = cap;
170             me->type = type;
171             me->bar_nr = bar_nr;
172             st->cont_st = me;
173
174             e = b->register_send(b, get_default_waitset(),
175                                  MKCONT(get_bar_cap_response_resend, b));
176             assert(err_is_ok(e));
177         } else {
178             USER_PANIC_ERR(e, "get_bar_cap_response");
179         }
180     }
181 }
182
183 static void get_bar_cap_response_resend(void *arg)
184 {
185     struct pci_binding *b = arg;
186     struct client_state *st = b->st;
187     struct pci_get_bar_cap_response__args *a = st->cont_st;
188     get_bar_cap_response_cont(b, a->err, a->cap, a->type, a->bar_nr);
189     free(a);
190 }
191
192 static void get_irq_cap_handler(struct pci_binding *b, uint16_t idx){
193     // TODO: This method works only for non legacy devices
194     // and supports only one interrupt per device at the moment
195     assert(idx == 0);
196     errval_t err;
197     struct capref cap;
198     slot_alloc(&cap);
199
200     struct client_state *st = b->st;
201
202     // TODO: This should be part of the routing step
203     int irq = pci_setup_interrupt(st->bus, st->dev, st->fun);
204     PCI_DEBUG("pci: init_device_handler_irq: init interrupt.\n");
205
206     pci_enable_interrupt_for_device(st->bus, st->dev, st->fun, st->pcie);
207
208     PCI_DEBUG("pci: Interrupt enabled.\n");
209
210     err = sys_debug_create_irq_src_cap(cap, irq);
211     if (err_is_fail(err)) {
212         USER_PANIC_ERR(err, "create irq src cap failed.");
213     }
214
215     err = b->tx_vtbl.get_irq_cap_response(b, NOP_CONT, err, cap);
216     if (err_is_fail(err)) {
217         USER_PANIC_ERR(err, "cap response failed.");
218     }
219 }
220
221 static void get_bar_cap_handler(struct pci_binding *b, uint32_t idx,
222                             uint32_t cap_nr)
223 {
224     struct client_state *st = b->st;
225     assert(st != NULL);
226     errval_t e;
227
228     if (idx >= st->nr_allocated_bars) {
229         e = b->tx_vtbl.get_bar_cap_response(b, NOP_CONT, PCI_ERR_WRONG_INDEX,
230                                         NULL_CAP, 0, 0);
231         assert(err_is_ok(e));
232     } else {
233         struct capref cap = pci_get_bar_cap_for_device(st->bus, st->dev,
234                                                    st->fun, idx, cap_nr);
235         uint8_t type = pci_get_bar_cap_type_for_device(st->bus, st->dev,
236                                                    st->fun, idx);
237         uint8_t bar_nr = pci_get_bar_nr_for_index(st->bus, st->dev,
238                                                    st->fun, idx);
239 /*
240 XXX: I/O-Cap??
241         uint8_t type = st->bar_info[idx].type;
242         struct capref cap = NULL_CAP;
243
244         if(type == 0) {
245             cap = st->bar_info[idx].frame_cap;
246         } else {
247             cap = st->bar_info[idx].io_cap;
248         }
249 */
250
251         get_bar_cap_response_cont(b, SYS_ERR_OK, cap, type, bar_nr);
252     }
253 }
254 /*
255 static void get_vbe_bios_cap(struct pci_binding *b)
256 {
257     errval_t err;
258     err = b->tx_vtbl.get_vbe_bios_cap_response(b, NOP_CONT, SYS_ERR_OK, biosmem,
259                                                1UL << BIOS_BITS);
260     assert(err_is_ok(err));
261 }*/
262
263 static void read_conf_header_handler(struct pci_binding *b, uint32_t dword)
264 {
265
266     struct client_state *cc = (struct client_state *) b->st;
267     struct pci_address addr = {
268         .bus= cc->bus,
269         .device=cc->dev,
270         .function=cc->fun,
271     };
272     PCI_DEBUG("Read config header from %u:%u:%u\n",addr.bus, addr.device, addr.function);
273     uint32_t val = pci_read_conf_header(&addr, dword);
274
275     errval_t err;
276     err = b->tx_vtbl.read_conf_header_response(b, NOP_CONT, SYS_ERR_OK, val);
277     assert(err_is_ok(err));
278 }
279
280 static void reregister_interrupt_handler(struct pci_binding *b,
281                                     uint32_t class_code, uint32_t sub_class,
282                                     uint32_t prog_if, uint32_t vendor_id,
283                                     uint32_t device_id,
284                                     uint32_t bus, uint32_t dev, uint32_t fun,
285                                     coreid_t coreid, uint32_t vector)
286 {
287     errval_t err;
288     err = device_reregister_interrupt(coreid, vector,
289                       class_code, sub_class, prog_if, vendor_id, device_id,
290                       &bus, &dev, &fun);
291     err = b->tx_vtbl.reregister_interrupt_response(b, NOP_CONT, err);
292     assert(err_is_ok(err));
293 }
294
295 static void write_conf_header_handler(struct pci_binding *b, uint32_t dword, uint32_t val)
296 {
297     struct client_state *cc = (struct client_state *) b->st;
298     struct pci_address addr = {
299         .bus= cc->bus,
300         .device=cc->dev,
301         .function=cc->fun,
302     };
303     PCI_DEBUG("Write config header from %u:%u:%u\n",addr.bus, addr.device, addr.function);
304     pci_write_conf_header(&addr, dword, val);
305
306     errval_t err;
307     err = b->tx_vtbl.write_conf_header_response(b, NOP_CONT, SYS_ERR_OK);
308     assert(err_is_ok(err));
309 }
310
311 static void msix_enable_addr_handler(struct pci_binding *b, uint8_t bus,
312                                       uint8_t dev, uint8_t fun)
313 {
314     struct client_state *cc = (struct client_state *) b->st;
315     struct pci_address addr;
316
317     /* XXX: find another way to do this */
318
319     if (bus == cc->bus && dev == cc->dev) {
320         addr.bus= bus;
321         addr.device=dev;
322         addr.function=fun;
323     } else {
324         addr.bus= cc->bus;
325         addr.device=cc->dev;
326         addr.function=fun;
327     }
328
329     errval_t err;
330     uint16_t count;
331
332     debug_printf("enabling MSI-X for device (%u, %u, %u)\n", addr.bus,
333                  addr.device, addr.function);
334
335     err = pci_msix_enable(&addr, &count);
336     err = b->tx_vtbl.msix_enable_response(b, NOP_CONT, err, count);
337     assert(err_is_ok(err));
338 }
339
340 static void msix_enable_handler(struct pci_binding *b)
341 {
342     struct client_state *cc = (struct client_state *) b->st;
343     msix_enable_addr_handler(b, cc->bus, cc->dev, cc->fun);
344 }
345
346 static void msix_vector_init_addr_handler(struct pci_binding *b, uint8_t bus,
347                                           uint8_t dev, uint8_t fun, uint16_t idx,
348                                           uint8_t destination, uint8_t vector)
349 {
350     struct client_state *cc = (struct client_state *) b->st;
351     struct pci_address addr;
352
353     /* XXX: find another way to do this */
354
355     if (bus == cc->bus && dev == cc->dev) {
356         addr.bus= bus;
357         addr.device=dev;
358         addr.function=fun;
359     } else {
360         addr.bus= cc->bus;
361         addr.device=cc->dev;
362         addr.function=fun;
363     }
364
365     debug_printf("initialize MSI-X vector for device (%u, %u, %u)\n", addr.bus,
366                      addr.device, addr.function);
367
368     errval_t err;
369
370     err = pci_msix_vector_init(&addr, idx, destination, vector);
371     err = b->tx_vtbl.msix_vector_init_response(b, NOP_CONT, err);
372     assert(err_is_ok(err));
373 }
374
375 static void msix_vector_init_handler(struct pci_binding *b, uint16_t idx,
376                                      uint8_t destination, uint8_t vector)
377 {
378     struct client_state *cc = (struct client_state *) b->st;
379
380     msix_vector_init_addr_handler(b, cc->bus, cc->dev, cc->fun, idx, destination,
381                                   vector);
382 }
383
384 struct pci_rx_vtbl pci_rx_vtbl = {
385     .init_pci_device_call = init_pci_device_handler,
386     .init_legacy_device_call = init_legacy_device_handler,
387     .get_bar_cap_call = get_bar_cap_handler,
388     .get_irq_cap_call = get_irq_cap_handler,
389     .reregister_interrupt_call = reregister_interrupt_handler,
390     //.get_vbe_bios_cap_call = get_vbe_bios_cap,
391     .read_conf_header_call = read_conf_header_handler,
392     .write_conf_header_call = write_conf_header_handler,
393     .irq_enable_call = irq_enable_handler,
394
395     .msix_enable_call = msix_enable_handler,
396     .msix_enable_addr_call = msix_enable_addr_handler,
397     .msix_vector_init_call = msix_vector_init_handler,
398     .msix_vector_init_addr_call = msix_vector_init_addr_handler,
399 };
400
401 static void export_callback(void *st, errval_t err, iref_t iref)
402 {
403     assert(err_is_ok(err));
404
405     err = nameservice_register("pci", iref);
406     if (err_is_fail(err)) {
407         USER_PANIC_ERR(err, "nameservice_register failed");
408     }
409 }
410
411 static errval_t connect_callback(void *cst, struct pci_binding *b)
412 {
413     struct client_state *st = malloc(sizeof(struct client_state));
414     assert(st != NULL);
415
416     b->rx_vtbl = pci_rx_vtbl;
417     b->st = st;
418 //    st->bar_info = 0;
419     st->nr_allocated_bars = 0;
420     for (int i = 0; i < PCI_NBARS; i++) {
421         st->nr_caps_bar[i] = 0;
422     }
423
424     return SYS_ERR_OK;
425 }
426
427 /*****************************************************************
428  * Boots up the PCI server:
429  *****************************************************************/
430
431 void pci_init(void)
432 {
433     PCI_DEBUG("pci: pci_init: called\n");
434
435     PCI_DEBUG("pci: pci_init: launch listening\n");
436     errval_t r = pci_export(NULL, export_callback, connect_callback,
437                             get_default_waitset(), IDC_EXPORT_FLAGS_DEFAULT);
438     assert(err_is_ok(r));
439
440     PCI_DEBUG("pci: pci_init: terminated\n");
441 }