Go to most recent revision | Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 4300 | trochtova | 1 | /* |
| 2 | * The PCI Library -- User Access |
||
| 3 | * |
||
| 4 | * Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz> |
||
| 5 | * |
||
| 6 | * May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar. |
||
| 7 | * |
||
| 8 | * Can be freely distributed and used under the terms of the GNU GPL. |
||
| 9 | */ |
||
| 10 | |||
| 11 | #include <stdio.h> |
||
| 12 | #include <stdlib.h> |
||
| 13 | #include <stdarg.h> |
||
| 14 | #include <string.h> |
||
| 15 | |||
| 16 | #include "internal.h" |
||
| 17 | |||
| 18 | static struct pci_methods *pci_methods[PCI_ACCESS_MAX] = { |
||
| 19 | #ifdef UARCH_ia32 |
||
| 20 | &pm_intel_conf1, |
||
| 21 | &pm_intel_conf2, |
||
| 22 | #else |
||
| 23 | 0, |
||
| 24 | 0, |
||
| 25 | #endif |
||
| 26 | |||
| 27 | #ifdef UARCH_sparc64 |
||
| 28 | &pm_us2 |
||
| 29 | #else |
||
| 30 | |||
| 31 | #endif |
||
| 32 | }; |
||
| 33 | |||
| 34 | struct pci_access *pci_alloc(void) |
||
| 35 | { |
||
| 36 | struct pci_access *a = malloc(sizeof(struct pci_access)); |
||
| 37 | int i; |
||
| 38 | |||
| 39 | if (!a) |
||
| 40 | return NULL; |
||
| 41 | |||
| 42 | bzero(a, sizeof(*a)); |
||
| 43 | for (i = 0; i < PCI_ACCESS_MAX; i++) |
||
| 44 | if (pci_methods[i] && pci_methods[i]->config) |
||
| 45 | pci_methods[i]->config(a); |
||
| 46 | return a; |
||
| 47 | } |
||
| 48 | |||
| 49 | void *pci_malloc(struct pci_access *a, int size) |
||
| 50 | { |
||
| 51 | void *x = malloc(size); |
||
| 52 | |||
| 53 | if (!x) |
||
| 54 | a->error("Out of memory (allocation of %d bytes failed)", size); |
||
| 55 | return x; |
||
| 56 | } |
||
| 57 | |||
| 58 | void pci_mfree(void *x) |
||
| 59 | { |
||
| 60 | if (x) |
||
| 61 | free(x); |
||
| 62 | } |
||
| 63 | |||
| 64 | static void pci_generic_error(char *msg, ...) |
||
| 65 | { |
||
| 66 | va_list args; |
||
| 67 | |||
| 68 | va_start(args, msg); |
||
| 69 | puts("pcilib: "); |
||
| 70 | vprintf(msg, args); |
||
| 71 | putchar('\n'); |
||
| 72 | exit(1); |
||
| 73 | } |
||
| 74 | |||
| 75 | static void pci_generic_warn(char *msg, ...) |
||
| 76 | { |
||
| 77 | va_list args; |
||
| 78 | |||
| 79 | va_start(args, msg); |
||
| 80 | puts("pcilib: "); |
||
| 81 | vprintf(msg, args); |
||
| 82 | putchar('\n'); |
||
| 83 | } |
||
| 84 | |||
| 85 | static void pci_generic_debug(char *msg, ...) |
||
| 86 | { |
||
| 87 | va_list args; |
||
| 88 | |||
| 89 | va_start(args, msg); |
||
| 90 | vprintf(msg, args); |
||
| 91 | va_end(args); |
||
| 92 | } |
||
| 93 | |||
| 94 | static void pci_null_debug(char *msg UNUSED, ...) |
||
| 95 | { |
||
| 96 | } |
||
| 97 | |||
| 98 | void pci_init(struct pci_access *a) |
||
| 99 | { |
||
| 100 | if (!a->error) |
||
| 101 | a->error = pci_generic_error; |
||
| 102 | if (!a->warning) |
||
| 103 | a->warning = pci_generic_warn; |
||
| 104 | if (!a->debug) |
||
| 105 | a->debug = pci_generic_debug; |
||
| 106 | if (!a->debugging) |
||
| 107 | a->debug = pci_null_debug; |
||
| 108 | |||
| 109 | if (a->method) { |
||
| 110 | if (a->method >= PCI_ACCESS_MAX || !pci_methods[a->method]) |
||
| 111 | a->error("This access method is not supported."); |
||
| 112 | a->methods = pci_methods[a->method]; |
||
| 113 | } else { |
||
| 114 | unsigned int i; |
||
| 115 | for (i = 0; i < PCI_ACCESS_MAX; i++) |
||
| 116 | if (pci_methods[i]) { |
||
| 117 | a->debug("Trying method %d...", i); |
||
| 118 | if (pci_methods[i]->detect(a)) { |
||
| 119 | a->debug("...OK\n"); |
||
| 120 | a->methods = pci_methods[i]; |
||
| 121 | a->method = i; |
||
| 122 | break; |
||
| 123 | } |
||
| 124 | a->debug("...No.\n"); |
||
| 125 | } |
||
| 126 | if (!a->methods) |
||
| 127 | a->error("Cannot find any working access method."); |
||
| 128 | } |
||
| 129 | a->debug("Decided to use %s\n", a->methods->name); |
||
| 130 | a->methods->init(a); |
||
| 131 | } |
||
| 132 | |||
| 133 | void pci_cleanup(struct pci_access *a) |
||
| 134 | { |
||
| 135 | struct pci_dev *d, *e; |
||
| 136 | |||
| 137 | for (d = a->devices; d; d = e) { |
||
| 138 | e = d->next; |
||
| 139 | pci_free_dev(d); |
||
| 140 | } |
||
| 141 | if (a->methods) |
||
| 142 | a->methods->cleanup(a); |
||
| 143 | pci_free_name_list(a); |
||
| 144 | pci_mfree(a); |
||
| 145 | } |
||
| 146 | |||
| 147 | void pci_scan_bus(struct pci_access *a) |
||
| 148 | { |
||
| 149 | a->methods->scan(a); |
||
| 150 | } |
||
| 151 | |||
| 152 | struct pci_dev *pci_alloc_dev(struct pci_access *a) |
||
| 153 | { |
||
| 154 | struct pci_dev *d = pci_malloc(a, sizeof(struct pci_dev)); |
||
| 155 | |||
| 156 | bzero(d, sizeof(*d)); |
||
| 157 | d->access = a; |
||
| 158 | d->methods = a->methods; |
||
| 159 | d->hdrtype = -1; |
||
| 160 | if (d->methods->init_dev) |
||
| 161 | d->methods->init_dev(d); |
||
| 162 | return d; |
||
| 163 | } |
||
| 164 | |||
| 165 | int pci_link_dev(struct pci_access *a, struct pci_dev *d) |
||
| 166 | { |
||
| 167 | d->next = a->devices; |
||
| 168 | a->devices = d; |
||
| 169 | |||
| 170 | return 1; |
||
| 171 | } |
||
| 172 | |||
| 173 | struct pci_dev *pci_get_dev(struct pci_access *a, int domain, int bus, |
||
| 174 | int dev, int func) |
||
| 175 | { |
||
| 176 | struct pci_dev *d = pci_alloc_dev(a); |
||
| 177 | |||
| 178 | d->domain = domain; |
||
| 179 | d->bus = bus; |
||
| 180 | d->dev = dev; |
||
| 181 | d->func = func; |
||
| 182 | return d; |
||
| 183 | } |
||
| 184 | |||
| 185 | void pci_free_dev(struct pci_dev *d) |
||
| 186 | { |
||
| 187 | if (d->methods->cleanup_dev) |
||
| 188 | d->methods->cleanup_dev(d); |
||
| 189 | pci_mfree(d); |
||
| 190 | } |
||
| 191 | |||
| 192 | static inline void |
||
| 193 | pci_read_data(struct pci_dev *d, void *buf, int pos, int len) |
||
| 194 | { |
||
| 195 | if (pos & (len - 1)) |
||
| 196 | d->access->error("Unaligned read: pos=%02x, len=%d", pos, |
||
| 197 | len); |
||
| 198 | if (pos + len <= d->cache_len) |
||
| 199 | memcpy(buf, d->cache + pos, len); |
||
| 200 | else if (!d->methods->read(d, pos, buf, len)) |
||
| 201 | memset(buf, 0xff, len); |
||
| 202 | } |
||
| 203 | |||
| 204 | byte pci_read_byte(struct pci_dev *d, int pos) |
||
| 205 | { |
||
| 206 | byte buf; |
||
| 207 | pci_read_data(d, &buf, pos, 1); |
||
| 208 | return buf; |
||
| 209 | } |
||
| 210 | |||
| 211 | word pci_read_word(struct pci_dev * d, int pos) |
||
| 212 | { |
||
| 213 | word buf; |
||
| 214 | pci_read_data(d, &buf, pos, 2); |
||
| 215 | return le16_to_cpu(buf); |
||
| 216 | } |
||
| 217 | |||
| 218 | u32 pci_read_long(struct pci_dev * d, int pos) |
||
| 219 | { |
||
| 220 | u32 buf; |
||
| 221 | pci_read_data(d, &buf, pos, 4); |
||
| 222 | return le32_to_cpu(buf); |
||
| 223 | } |
||
| 224 | |||
| 225 | int pci_read_block(struct pci_dev *d, int pos, byte * buf, int len) |
||
| 226 | { |
||
| 227 | return d->methods->read(d, pos, buf, len); |
||
| 228 | } |
||
| 229 | |||
| 230 | static inline int |
||
| 231 | pci_write_data(struct pci_dev *d, void *buf, int pos, int len) |
||
| 232 | { |
||
| 233 | if (pos & (len - 1)) |
||
| 234 | d->access->error("Unaligned write: pos=%02x,len=%d", pos, len); |
||
| 235 | if (pos + len <= d->cache_len) |
||
| 236 | memcpy(d->cache + pos, buf, len); |
||
| 237 | return d->methods->write(d, pos, buf, len); |
||
| 238 | } |
||
| 239 | |||
| 240 | int pci_write_byte(struct pci_dev *d, int pos, byte data) |
||
| 241 | { |
||
| 242 | return pci_write_data(d, &data, pos, 1); |
||
| 243 | } |
||
| 244 | |||
| 245 | int pci_write_word(struct pci_dev *d, int pos, word data) |
||
| 246 | { |
||
| 247 | word buf = cpu_to_le16(data); |
||
| 248 | return pci_write_data(d, &buf, pos, 2); |
||
| 249 | } |
||
| 250 | |||
| 251 | int pci_write_long(struct pci_dev *d, int pos, u32 data) |
||
| 252 | { |
||
| 253 | u32 buf = cpu_to_le32(data); |
||
| 254 | return pci_write_data(d, &buf, pos, 4); |
||
| 255 | } |
||
| 256 | |||
| 257 | int pci_write_block(struct pci_dev *d, int pos, byte * buf, int len) |
||
| 258 | { |
||
| 259 | if (pos < d->cache_len) { |
||
| 260 | int l = (pos + len >= d->cache_len) ? (d->cache_len - pos) : len; |
||
| 261 | memcpy(d->cache + pos, buf, l); |
||
| 262 | } |
||
| 263 | return d->methods->write(d, pos, buf, len); |
||
| 264 | } |
||
| 265 | |||
| 266 | int pci_fill_info(struct pci_dev *d, int flags) |
||
| 267 | { |
||
| 268 | if (flags & PCI_FILL_RESCAN) { |
||
| 269 | flags &= ~PCI_FILL_RESCAN; |
||
| 270 | d->known_fields = 0; |
||
| 271 | } |
||
| 272 | if (flags & ~d->known_fields) |
||
| 273 | d->known_fields |= d->methods->fill_info(d, flags & ~d->known_fields); |
||
| 274 | return d->known_fields; |
||
| 275 | } |
||
| 276 | |||
| 277 | void pci_setup_cache(struct pci_dev *d, byte * cache, int len) |
||
| 278 | { |
||
| 279 | d->cache = cache; |
||
| 280 | d->cache_len = len; |
||
| 281 | } |