/* This file is part of the program psim. Copyright (C) 1994-1996, Andrew Cagney This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #ifndef _HW_PHB_C_ #define _HW_PHB_C_ #include "device_table.h" #include "hw_phb.h" #include "corefile.h" #include #include /* DEVICE phb - PCI Host Bridge DESCRIPTION PHB implements a model of the PCI-host bridge described in the PPCP document. For bridge devices, Open Firmware specifies that the <> property be used to specify the mapping of address spaces between a bridges parent and child busses. This PHB model configures itsself according to the information specified in its ranges property. The <> property is described in detail in the Open Firmware documentation. For DMA transfers, any access to a PCI address space which falls outside of the mapped memory space is assumed to be a transfer intended for the parent bus. PROPERTIES ranges = ... (required) Define a number of mappings from the parent bus to one of this devices PCI busses. The exact format of the <> is parent bus dependant. The format of <> is described in the Open Firmware PCI bindings document (note that the address must be non-relocatable). #address-cells = 3 (required) Number of cells used by an Open Firmware PCI address. This property must be defined before specifying the <> property. #size-cells = 2 (required) Number of cells used by an Open Firmware PCI size. This property must be defined before specifying the <> property. EXAMPLES Enable tracing: | $ psim \ | -t phb-device \ Since device tree entries that are specified on the command line are added before most of the device tree has been built it is often necessary to explicitly add certain device properties and thus ensure they are already present in the device tree. For the <> one such property is parent busses <<#address-cells>>. | -o '/#address-cells 1' \ Create the PHB remembering to include the cell size properties: | -o '/phb@0x80000000/#address-cells 3' \ | -o '/phb@0x80000000/#size-cells 2' \ Specify that the memory address range <<0x80000000>> to <<0x8fffffff>> should map directly onto the PCI memory address space while the processor address range <<0xc0000000>> to <<0xc000ffff>> should map onto the PCI I/O address range starting at location zero: | -o '/phb@0x80000000/ranges \ | nm0,0,0,80000000 0x80000000 0x10000000 \ | ni0,0,0,0 0xc0000000 0x10000' \ Insert a 4k <> into slot zero of the PCI bus. Have it directly accessible in both the I/O (address <<0x100>>) and memory (address 0x80001000) spaces: | -o '/phb@0x80000000/nvram@0/assigned-addresses \ | nm0,0,10,80001000 4096 \ | ni0,0,14,100 4096' | -o '/phb@0x80000000/nvram@0/reg \ | 0 0 \ | i0,0,14,0 4096' | -o '/phb@0x80000000/nvram@0/alternate-reg \ | 0 0 \ | m0,0,10,0 4096' The <> property corresponding to what (if it were implemented) be found in the config base registers while the <> and <> properties indicating the location of registers within each address space. Of the possible addresses, only the non-relocatable versions are used when attaching the device to the bus. BUGS The implementation of the PCI configuration space is left as an exercise for the reader. Such a restriction should only impact on systems wanting to dynamically configure devices on the PCI bus. The <> document specfies additional (optional) functionality of the primary PHB. The implementation of such functionality is left as an exercise for the reader. The Open Firmware PCI bus bindings document (rev 1.6 and 2.0) is unclear on the value of the "ss" bits for a 64bit memory address. The correct value, as used by this module, is 0b11. The Open Firmware PCI bus bindings document (rev 1.6) suggests that the register field of non-relocatable PCI address should be zero. Unfortunately, PCI addresses specified in the <> property must be both non-relocatable and have non-zero register fields. The unit-decode method is not inserting a bus number into any address that it decodes. Instead the bus-number is left as zero. Support for aliased memory and I/O addresses is left as an exercise for the reader. Support for interrupt-ack and special cycles are left as an exercise for the reader. One issue to consider when attempting this exercise is how to specify the address of the int-ack and special cycle register. Hint: <> is the wrong answer. Children of this node can only use the client callback interface when attaching themselves to the <>. REFERENCES http://playground.sun.com/1275/home.html#OFDbusPCI */ typedef struct _phb_space { core *map; core_map *readable; core_map *writeable; unsigned_word parent_base; int parent_space; unsigned_word my_base; int my_space; unsigned size; const char *name; } phb_space; typedef struct _hw_phb_device { phb_space space[nr_hw_phb_spaces]; } hw_phb_device; static const char * hw_phb_decode_name(hw_phb_decode level) { switch (level) { case hw_phb_normal_decode: return "normal"; case hw_phb_subtractive_decode: return "subtractive"; case hw_phb_master_abort_decode: return "master-abort"; default: return "invalid decode"; } } static void hw_phb_init_address(device *me) { hw_phb_device *phb = device_data(me); /* check some basic properties */ if (device_nr_address_cells(me) != 3) device_error(me, "incorrect #address-cells"); if (device_nr_size_cells(me) != 2) device_error(me, "incorrect #size-cells"); /* (re) initialize each PCI space */ { hw_phb_spaces space_nr; for (space_nr = 0; space_nr < nr_hw_phb_spaces; space_nr++) { phb_space *pci_space = &phb->space[space_nr]; core_init(pci_space->map); pci_space->size = 0; } } /* decode each of the ranges properties entering the information into the space table */ { range_property_spec range; int ranges_entry; for (ranges_entry = 0; device_find_range_array_property(me, "ranges", ranges_entry, &range); ranges_entry++) { int my_attach_space; unsigned_word my_attach_address; int parent_attach_space; unsigned_word parent_attach_address; unsigned size; phb_space *pci_space; /* convert the addresses into something meaningful */ device_address_to_attach_address(me, &range.child_address, &my_attach_space, &my_attach_address, me); device_address_to_attach_address(device_parent(me), &range.parent_address, &parent_attach_space, &parent_attach_address, me); device_size_to_attach_size(me, &range.size, &size, me); if (my_attach_space < 0 || my_attach_space >= nr_hw_phb_spaces) device_error(me, "ranges property contains an invalid address space"); pci_space = &phb->space[my_attach_space]; if (pci_space->size != 0) device_error(me, "ranges property contains duplicate mappings for %s address space", pci_space->name); pci_space->parent_base = parent_attach_address; pci_space->parent_space = parent_attach_space; pci_space->my_base = my_attach_address; pci_space->my_space = my_attach_space; pci_space->size = size; device_attach_address(device_parent(me), attach_callback, parent_attach_space, parent_attach_address, size, access_read_write_exec, me); DTRACE(phb, ("map %d:0x%lx to %s:0x%lx (0x%lx bytes)\n", (int)parent_attach_space, (unsigned long)parent_attach_address, pci_space->name, (unsigned long)my_attach_address, (unsigned long)size)); } if (ranges_entry == 0) { device_error(me, "Missing or empty ranges property"); } } } static void hw_phb_attach_address(device *me, attach_type type, int space, unsigned_word addr, unsigned nr_bytes, access_type access, device *client) /*callback/default*/ { hw_phb_device *phb = device_data(me); phb_space *pci_space; hw_phb_decode phb_type = (hw_phb_decode)type; /* sanity checks */ if (space < 0 || space >= nr_hw_phb_spaces) device_error(me, "attach space (%d) specified by %s invalid", space, device_path(client)); pci_space = &phb->space[space]; if (addr + nr_bytes > pci_space->my_base + pci_space->size || addr < pci_space->my_base) device_error(me, "attach addr (0x%lx) specified by %s outside of bus address range", (unsigned long)addr, device_path(client)); if (phb_type != hw_phb_normal_decode && phb_type != hw_phb_subtractive_decode) device_error(me, "attach type (%d) specified by %s invalid", type, device_path(client)); /* attach it to the relevant bus */ DTRACE(phb, ("attach %s - %s %s:0x%lx (0x%lx bytes)\n", device_path(client), hw_phb_decode_name(phb_type), pci_space->name, (unsigned long)addr, (unsigned long)nr_bytes)); core_attach(pci_space->map, type, space, access, addr, nr_bytes, client); } /* Extract/set various fields from a PCI unit address. Note: only the least significant 32 bits of each cell is used. Note: for PPC MSB is 0 while for PCI it is 31. */ /* relocatable bit n */ static unsigned extract_n(const device_unit *address) { return EXTRACTED32(address->cells[0], 0, 0); } static void set_n(device_unit *address) { BLIT32(address->cells[0], 0, 1); } /* prefetchable bit p */ static unsigned extract_p(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 1, 1); } static void set_p(device_unit *address) { BLIT32(address->cells[0], 1, 1); } /* aliased bit t */ static unsigned extract_t(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 2, 2); } static void set_t(device_unit *address) { BLIT32(address->cells[0], 2, 1); } /* space code ss */ typedef enum { ss_config_code = 0, ss_io_code = 1, ss_32bit_memory_code = 2, ss_64bit_memory_code = 3, } ss_type; static ss_type extract_ss(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 6, 7); } static void set_ss(device_unit *address, ss_type val) { MBLIT32(address->cells[0], 6, 7, val); } /* bus number bbbbbbbb */ #if 0 static unsigned extract_bbbbbbbb(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 8, 15); } #endif #if 0 static void set_bbbbbbbb(device_unit *address, unsigned val) { MBLIT32(address->cells[0], 8, 15, val); } #endif /* device number ddddd */ static unsigned extract_ddddd(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 16, 20); } static void set_ddddd(device_unit *address, unsigned val) { MBLIT32(address->cells[0], 16, 20, val); } /* function number fff */ static unsigned extract_fff(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 21, 23); } static void set_fff(device_unit *address, unsigned val) { MBLIT32(address->cells[0], 21, 23, val); } /* register number rrrrrrrr */ static unsigned extract_rrrrrrrr(const device_unit *address) { ASSERT(address->nr_cells == 3); return EXTRACTED32(address->cells[0], 24, 31); } static void set_rrrrrrrr(device_unit *address, unsigned val) { MBLIT32(address->cells[0], 24, 31, val); } /* MSW of 64bit address hh..hh */ static unsigned extract_hh_hh(const device_unit *address) { ASSERT(address->nr_cells == 3); return address->cells[1]; } static void set_hh_hh(device_unit *address, unsigned val) { address->cells[2] = val; } /* LSW of 64bit address ll..ll */ static unsigned extract_ll_ll(const device_unit *address) { ASSERT(address->nr_cells == 3); return address->cells[2]; } static void set_ll_ll(device_unit *address, unsigned val) { address->cells[2] = val; } /* Convert PCI textual bus address into a device unit */ static int hw_phb_unit_decode(device *me, const char *unit, device_unit *address) { char *end = NULL; const char *chp = unit; unsigned long val; if (device_nr_address_cells(me) != 3) device_error(me, "PCI bus should have #address-cells == 3"); memset(address, 0, sizeof(*address)); if (unit == NULL) return 0; address->nr_cells = 3; if (isxdigit(*chp)) { set_ss(address, ss_config_code); } else { /* non-relocatable? */ if (*chp == 'n') { set_n(address); chp++; } /* address-space? */ if (*chp == 'i') { set_ss(address, ss_io_code); chp++; } else if (*chp == 'm') { set_ss(address, ss_32bit_memory_code); chp++; } else if (*chp == 'x') { set_ss(address, ss_64bit_memory_code); chp++; } else device_error(me, "Problem parsing PCI address %s", unit); /* possible alias */ if (*chp == 't') { if (extract_ss(address) == ss_64bit_memory_code) device_error(me, "Invalid alias bit in PCI address %s", unit); set_t(address); chp++; } /* possible p */ if (*chp == 'p') { if (extract_ss(address) != ss_32bit_memory_code) device_error(me, "Invalid prefetchable bit (p) in PCI address %s", unit); set_p(address); chp++; } } /* required DD */ if (!isxdigit(*chp)) device_error(me, "Missing device number in PCI address %s", unit); val = strtoul(chp, &end, 16); if (chp == end) device_error(me, "Problem parsing device number in PCI address %s", unit); if ((val & 0x1f) != val) device_error(me, "Device number (0x%lx) out of range (0..0x1f) in PCI address %s", val, unit); set_ddddd(address, val); chp = end; /* For config space, the F is optional */ if (extract_ss(address) == ss_config_code && (isspace(*chp) || *chp == '\0')) return chp - unit; /* function number F */ if (*chp != ',') device_error(me, "Missing function number in PCI address %s", unit); chp++; val = strtoul(chp, &end, 10); if (chp == end) device_error(me, "Problem parsing function number in PCI address %s", unit); if ((val & 7) != val) device_error(me, "Function number (%ld) out of range (0..7) in PCI address %s", (long)val, unit); set_fff(address, val); chp = end; /* for config space, must be end */ if (extract_ss(address) == ss_config_code) { if (!isspace(*chp) && *chp != '\0') device_error(me, "Problem parsing PCI config address %s", unit); return chp - unit; } /* register number RR */ if (*chp != ',') device_error(me, "Missing register number in PCI address %s", unit); chp++; val = strtoul(chp, &end, 16); if (chp == end) device_error(me, "Problem parsing register number in PCI address %s", unit); switch (extract_ss(address)) { case ss_io_code: #if 0 if (extract_n(address) && val != 0) device_error(me, "non-relocatable I/O register must be zero in PCI address %s", unit); else if (!extract_n(address) && val != 0x10 && val != 0x14 && val != 0x18 && val != 0x1c && val != 0x20 && val != 0x24) device_error(me, "I/O register invalid in PCI address %s", unit); #endif break; case ss_32bit_memory_code: #if 0 if (extract_n(address) && val != 0) device_error(me, "non-relocatable memory register must be zero in PCI address %s", unit); else if (!extract_n(address) && val != 0x10 && val != 0x14 && val != 0x18 && val != 0x1c && val != 0x20 && val != 0x24 && val != 0x30) device_error(me, "I/O register (0x%lx) invalid in PCI address %s", val, unit); #endif break; case ss_64bit_memory_code: if (extract_n(address) && val != 0) device_error(me, "non-relocatable 32bit memory register must be zero in PCI address %s", unit); else if (!extract_n(address) && val != 0x10 && val != 0x18 && val != 0x20) device_error(me, "Register number (0x%lx) invalid in 64bit PCI address %s", val, unit); break; case ss_config_code: device_error(me, "internal error"); } if ((val & 0xff) != val) device_error(me, "Register number (0x%lx) out of range (0..0xff) in PCI address %s", val, unit); set_rrrrrrrr(address, val); chp = end; /* address */ if (*chp != ',') device_error(me, "Missing address in PCI address %s", unit); chp++; switch (extract_ss(address)) { case ss_io_code: case ss_32bit_memory_code: val = strtoul(chp, &end, 16); if (chp == end) device_error(me, "Problem parsing address in PCI address %s", unit); switch (extract_ss(address)) { case ss_io_code: if (extract_n(address) && extract_t(address) && (val & 1024) != val) device_error(me, "10bit aliased non-relocatable address (0x%lx) out of range in PCI address %s", val, unit); if (!extract_n(address) && extract_t(address) && (val & 0xffff) != val) device_error(me, "64k relocatable address (0x%lx) out of range in PCI address %s", val, unit); break; case ss_32bit_memory_code: if (extract_t(address) && (val & 0xfffff) != val) device_error(me, "1mb memory address (0x%lx) out of range in PCI address %s", val, unit); if (!extract_t(address) && (val & 0xffffffff) != val) device_error(me, "32bit memory address (0x%lx) out of range in PCI address %s", val, unit); break; case ss_64bit_memory_code: case ss_config_code: device_error(me, "internal error"); } set_ll_ll(address, val); chp = end; break; case ss_64bit_memory_code: device_error(me, "64bit addresses unimplemented"); set_hh_hh(address, val); set_ll_ll(address, val); break; case ss_config_code: device_error(me, "internal error"); break; } /* finished? */ if (!isspace(*chp) && *chp != '\0') device_error(me, "Problem parsing PCI address %s", unit); return chp - unit; } /* Convert PCI device unit into its corresponding textual representation */ static int hw_phb_unit_encode(device *me, const device_unit *unit_address, char *buf, int sizeof_buf) { if (unit_address->nr_cells != 3) device_error(me, "Incorrect number of cells in PCI unit address"); if (device_nr_address_cells(me) != 3) device_error(me, "PCI bus should have #address-cells == 3"); if (extract_ss(unit_address) == ss_config_code && extract_fff(unit_address) == 0 && extract_rrrrrrrr(unit_address) == 0 && extract_hh_hh(unit_address) == 0 && extract_ll_ll(unit_address) == 0) { /* DD - Configuration Space address */ sprintf(buf, "%x", extract_ddddd(unit_address)); } else if (extract_ss(unit_address) == ss_config_code && extract_fff(unit_address) != 0 && extract_rrrrrrrr(unit_address) == 0 && extract_hh_hh(unit_address) == 0 && extract_ll_ll(unit_address) == 0) { /* DD,F - Configuration Space */ sprintf(buf, "%x,%d", extract_ddddd(unit_address), extract_fff(unit_address)); } else if (extract_ss(unit_address) == ss_io_code && extract_hh_hh(unit_address) == 0) { /* [n]i[t]DD,F,RR,NNNNNNNN - 32bit I/O space */ sprintf(buf, "%si%s%x,%d,%x,%x", extract_n(unit_address) ? "n" : "", extract_t(unit_address) ? "t" : "", extract_ddddd(unit_address), extract_fff(unit_address), extract_rrrrrrrr(unit_address), extract_ll_ll(unit_address)); } else if (extract_ss(unit_address) == ss_32bit_memory_code && extract_hh_hh(unit_address) == 0) { /* [n]m[t][p]DD,F,RR,NNNNNNNN - 32bit memory space */ sprintf(buf, "%sm%s%s%x,%d,%x,%x", extract_n(unit_address) ? "n" : "", extract_t(unit_address) ? "t" : "", extract_p(unit_address) ? "p" : "", extract_ddddd(unit_address), extract_fff(unit_address), extract_rrrrrrrr(unit_address), extract_ll_ll(unit_address)); } else if (extract_ss(unit_address) == ss_32bit_memory_code) { /* [n]x[p]DD,F,RR,NNNNNNNNNNNNNNNN - 64bit memory space */ sprintf(buf, "%sx%s%x,%d,%x,%x%08x", extract_n(unit_address) ? "n" : "", extract_p(unit_address) ? "p" : "", extract_ddddd(unit_address), extract_fff(unit_address), extract_rrrrrrrr(unit_address), extract_hh_hh(unit_address), extract_ll_ll(unit_address)); } else { device_error(me, "Invalid PCI unit address 0x%08lx 0x%08lx 0x%08lx", (unsigned long)unit_address->cells[0], (unsigned long)unit_address->cells[1], (unsigned long)unit_address->cells[2]); } if (strlen(buf) > sizeof_buf) error("buffer overflow"); return strlen(buf); } static int hw_phb_address_to_attach_address(device *me, const device_unit *address, int *attach_space, unsigned_word *attach_address, device *client) { if (address->nr_cells != 3) device_error(me, "attach address has incorrect number of cells"); if (address->cells[1] != 0) device_error(me, "64bit attach address unsupported"); /* directly decode the address/space */ *attach_address = address->cells[2]; switch (extract_ss(address)) { case ss_config_code: *attach_space = hw_phb_config_space; break; case ss_io_code: *attach_space = hw_phb_io_space; break; case ss_32bit_memory_code: case ss_64bit_memory_code: *attach_space = hw_phb_memory_space; break; } /* if non-relocatable finished */ if (extract_n(address)) return 1; /* make memory and I/O addresses absolute */ if (*attach_space == hw_phb_io_space || *attach_space == hw_phb_memory_space) { int reg_nr; reg_property_spec assigned; if (extract_ss(address) == ss_64bit_memory_code) device_error(me, "64bit memory address not unsuported"); for (reg_nr = 0; device_find_reg_array_property(client, "assigned-addresses", reg_nr, &assigned); reg_nr++) { if (!extract_n(&assigned.address) || extract_rrrrrrrr(&assigned.address) == 0) device_error(me, "client %s has invalid assigned-address property", device_path(client)); if (extract_rrrrrrrr(address) == extract_rrrrrrrr(&assigned.address)) { /* corresponding base register */ if (extract_ss(address) != extract_ss(&assigned.address)) device_error(me, "client %s has conflicting types for base register 0x%lx", device_path(client), (unsigned long)extract_rrrrrrrr(address)); *attach_address += assigned.address.cells[2]; return 0; } } device_error(me, "client %s missing base address register 0x%lx in assigned-addresses property", device_path(client), (unsigned long)extract_rrrrrrrr(address)); } return 0; } static int hw_phb_size_to_attach_size(device *me, const device_unit *size, unsigned *nr_bytes, device *client) { if (size->nr_cells != 2) device_error(me, "size has incorrect number of cells"); if (size->cells[0] != 0) device_error(me, "64bit size unsupported"); *nr_bytes = size->cells[1]; return size->cells[1]; } static const phb_space * find_phb_space(hw_phb_device *phb, unsigned_word addr, unsigned nr_bytes) { hw_phb_spaces space; /* find the space that matches the address */ for (space = 0; space < nr_hw_phb_spaces; space++) { phb_space *pci_space = &phb->space[space]; if (addr >= pci_space->parent_base && (addr + nr_bytes) <= (pci_space->parent_base + pci_space->size)) { return pci_space; } } return NULL; } static unsigned_word map_phb_addr(const phb_space *space, unsigned_word addr) { return addr - space->parent_base + space->my_base; } static unsigned hw_phb_io_read_buffer(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_phb_device *phb = (hw_phb_device*)device_data(me); const phb_space *pci_space = find_phb_space(phb, addr, nr_bytes); unsigned_word bus_addr; if (pci_space == NULL) return 0; bus_addr = map_phb_addr(pci_space, addr); DTRACE(phb, ("io read - %d:0x%lx -> %s:0x%lx (%u bytes)\n", space, (unsigned long)addr, pci_space->name, (unsigned long)bus_addr, nr_bytes)); return core_map_read_buffer(pci_space->readable, dest, bus_addr, nr_bytes); } static unsigned hw_phb_io_write_buffer(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_phb_device *phb = (hw_phb_device*)device_data(me); const phb_space *pci_space = find_phb_space(phb, addr, nr_bytes); unsigned_word bus_addr; if (pci_space == NULL) return 0; bus_addr = map_phb_addr(pci_space, addr); DTRACE(phb, ("io write - %d:0x%lx -> %s:0x%lx (%u bytes)\n", space, (unsigned long)addr, pci_space->name, (unsigned long)bus_addr, nr_bytes)); return core_map_write_buffer(pci_space->writeable, source, bus_addr, nr_bytes); } static unsigned hw_phb_dma_read_buffer(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes) { hw_phb_device *phb = (hw_phb_device*)device_data(me); const phb_space *pci_space; /* find the space */ if (space != hw_phb_memory_space) device_error(me, "invalid dma address space %d", space); pci_space = &phb->space[space]; /* check out the address */ if ((addr >= pci_space->my_base && addr <= pci_space->my_base + pci_space->size) || (addr + nr_bytes >= pci_space->my_base && addr + nr_bytes <= pci_space->my_base + pci_space->size)) device_error(me, "Do not support DMA into own bus"); /* do it */ DTRACE(phb, ("dma read - %s:0x%lx (%d bytes)\n", pci_space->name, (unsigned long)addr, nr_bytes)); return device_dma_read_buffer(device_parent(me), dest, pci_space->parent_space, addr, nr_bytes); } static unsigned hw_phb_dma_write_buffer(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, int violate_read_only_section) { hw_phb_device *phb = (hw_phb_device*)device_data(me); const phb_space *pci_space; /* find the space */ if (space != hw_phb_memory_space) device_error(me, "invalid dma address space %d", space); pci_space = &phb->space[space]; /* check out the address */ if ((addr >= pci_space->my_base && addr <= pci_space->my_base + pci_space->size) || (addr + nr_bytes >= pci_space->my_base && addr + nr_bytes <= pci_space->my_base + pci_space->size)) device_error(me, "Do not support DMA into own bus"); /* do it */ DTRACE(phb, ("dma write - %s:0x%lx (%d bytes)\n", pci_space->name, (unsigned long)addr, nr_bytes)); return device_dma_write_buffer(device_parent(me), source, pci_space->parent_space, addr, nr_bytes, violate_read_only_section); } static device_callbacks const hw_phb_callbacks = { { hw_phb_init_address, }, { hw_phb_attach_address, }, { hw_phb_io_read_buffer, hw_phb_io_write_buffer }, { hw_phb_dma_read_buffer, hw_phb_dma_write_buffer }, { NULL, }, /* interrupt */ { hw_phb_unit_decode, hw_phb_unit_encode, hw_phb_address_to_attach_address, hw_phb_size_to_attach_size } }; static void * hw_phb_create(const char *name, const device_unit *unit_address, const char *args) { /* create the descriptor */ hw_phb_device *phb = ZALLOC(hw_phb_device); /* create the core maps now */ hw_phb_spaces space_nr; for (space_nr = 0; space_nr < nr_hw_phb_spaces; space_nr++) { phb_space *pci_space = &phb->space[space_nr]; pci_space->map = core_create(); pci_space->readable = core_readable(pci_space->map); pci_space->writeable = core_writeable(pci_space->map); switch (space_nr) { case hw_phb_memory_space: pci_space->name = "memory"; break; case hw_phb_io_space: pci_space->name = "I/O"; break; case hw_phb_config_space: pci_space->name = "config"; break; case hw_phb_special_space: pci_space->name = "special"; break; default: error ("internal error"); break; } } return phb; } const device_descriptor hw_phb_device_descriptor[] = { { "phb", hw_phb_create, &hw_phb_callbacks }, { "pci", NULL, &hw_phb_callbacks }, { NULL, }, }; #endif /* _HW_PHB_ */