git.barrelfish.org Git - barrelfish/blob - 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 }