tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

m68knommu: remove the obsolete and long unused comempci chip support

Signed-off-by: Greg Ungerer <gerg@uclinux.org>

Greg Ungerer d88ffccb e8158851

-981
unified split
-1
arch/m68knommu/kernel/Makefile
··· 8 8 setup.o signal.o syscalltable.o sys_m68k.o time.o traps.o 9 9 10 10 obj-$(CONFIG_MODULES) += module.o 11 - obj-$(CONFIG_COMEMPCI) += comempci.o
-980
arch/m68knommu/kernel/comempci.c
··· 1 - /*****************************************************************************/ 2 - 3 - /* 4 - * comemlite.c -- PCI access code for embedded CO-MEM Lite PCI controller. 5 - * 6 - * (C) Copyright 1999-2003, Greg Ungerer (gerg@snapgear.com). 7 - * (C) Copyright 2000, Lineo (www.lineo.com) 8 - */ 9 - 10 - /*****************************************************************************/ 11 - 12 - #include <linux/kernel.h> 13 - #include <linux/types.h> 14 - #include <linux/pci.h> 15 - #include <linux/ptrace.h> 16 - #include <linux/spinlock.h> 17 - #include <linux/interrupt.h> 18 - #include <linux/sched.h> 19 - #include <asm/coldfire.h> 20 - #include <asm/mcfsim.h> 21 - #include <asm/irq.h> 22 - #include <asm/anchor.h> 23 - 24 - #ifdef CONFIG_eLIA 25 - #include <asm/elia.h> 26 - #endif 27 - 28 - /*****************************************************************************/ 29 - 30 - /* 31 - * Debug configuration defines. DEBUGRES sets debugging output for 32 - * the resource allocation phase. DEBUGPCI traces on pcibios_ function 33 - * calls, and DEBUGIO traces all accesses to devices on the PCI bus. 34 - */ 35 - /*#define DEBUGRES 1*/ 36 - /*#define DEBUGPCI 1*/ 37 - /*#define DEBUGIO 1*/ 38 - 39 - /*****************************************************************************/ 40 - 41 - /* 42 - * PCI markers for bus present and active slots. 43 - */ 44 - int pci_bus_is_present = 0; 45 - unsigned long pci_slotmask = 0; 46 - 47 - /* 48 - * We may or may not need to swap the bytes of PCI bus tranfers. 49 - * The endianess is re-roder automatically by the CO-MEM, but it 50 - * will get the wrong byte order for a pure data stream. 51 - */ 52 - #define pci_byteswap 0 53 - 54 - 55 - /* 56 - * Resource tracking. The CO-MEM part creates a virtual address 57 - * space that all the PCI devices live in - it is not in any way 58 - * directly mapped into the ColdFire address space. So we can 59 - * really assign any resources we like to devices, as long as 60 - * they do not clash with other PCI devices. 61 - */ 62 - unsigned int pci_iobase = PCIBIOS_MIN_IO; /* Arbitrary start address */ 63 - unsigned int pci_membase = PCIBIOS_MIN_MEM; /* Arbitrary start address */ 64 - 65 - #define PCI_MINIO 0x100 /* 256 byte minimum I/O */ 66 - #define PCI_MINMEM 0x00010000 /* 64k minimum chunk */ 67 - 68 - /* 69 - * The CO-MEM's shared memory segment is visible inside the PCI 70 - * memory address space. We need to keep track of the address that 71 - * this is mapped at, to setup the bus masters pointers. 72 - */ 73 - unsigned int pci_shmemaddr; 74 - 75 - /*****************************************************************************/ 76 - 77 - void pci_interrupt(int irq, void *id, struct pt_regs *fp); 78 - 79 - /*****************************************************************************/ 80 - 81 - /* 82 - * Some platforms have custom ways of reseting the PCI bus. 83 - */ 84 - 85 - void pci_resetbus(void) 86 - { 87 - #ifdef CONFIG_eLIA 88 - int i; 89 - 90 - #ifdef DEBUGPCI 91 - printk(KERN_DEBUG "pci_resetbus()\n"); 92 - #endif 93 - 94 - *((volatile unsigned short *) (MCF_MBAR+MCFSIM_PADDR)) |= eLIA_PCIRESET; 95 - for (i = 0; (i < 1000); i++) { 96 - *((volatile unsigned short *) (MCF_MBAR + MCFSIM_PADAT)) = 97 - (ppdata | eLIA_PCIRESET); 98 - } 99 - 100 - 101 - *((volatile unsigned short *) (MCF_MBAR + MCFSIM_PADAT)) = ppdata; 102 - #endif 103 - } 104 - 105 - /*****************************************************************************/ 106 - 107 - int pcibios_assign_resource_slot(int slot) 108 - { 109 - volatile unsigned long *rp; 110 - volatile unsigned char *ip; 111 - unsigned int idsel, addr, val, align, i; 112 - int bar; 113 - 114 - #ifdef DEBUGPCI 115 - printk(KERN_INFO "pcibios_assign_resource_slot(slot=%x)\n", slot); 116 - #endif 117 - 118 - rp = (volatile unsigned long *) COMEM_BASE; 119 - idsel = COMEM_DA_ADDR(0x1 << (slot + 16)); 120 - 121 - /* Try to assign resource to each BAR */ 122 - for (bar = 0; (bar < 6); bar++) { 123 - addr = COMEM_PCIBUS + PCI_BASE_ADDRESS_0 + (bar * 4); 124 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGRD | idsel; 125 - val = rp[LREG(addr)]; 126 - #ifdef DEBUGRES 127 - printk(KERN_DEBUG "-----------------------------------" 128 - "-------------------------------------\n"); 129 - printk(KERN_DEBUG "BAR[%d]: read=%08x ", bar, val); 130 - #endif 131 - 132 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGWR | idsel; 133 - rp[LREG(addr)] = 0xffffffff; 134 - 135 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGRD | idsel; 136 - val = rp[LREG(addr)]; 137 - #ifdef DEBUGRES 138 - printk(KERN_DEBUG "write=%08x ", val); 139 - #endif 140 - if (val == 0) { 141 - #ifdef DEBUGRES 142 - printk(KERN_DEBUG "\n"); 143 - #endif 144 - continue; 145 - } 146 - 147 - /* Determine space required by BAR */ 148 - /* FIXME: this should go backwords from 0x80000000... */ 149 - for (i = 0; (i < 32); i++) { 150 - if ((0x1 << i) & (val & 0xfffffffc)) 151 - break; 152 - } 153 - 154 - #ifdef DEBUGRES 155 - printk(KERN_DEBUG "size=%08x(%d)\n", (0x1 << i), i); 156 - #endif 157 - i = 0x1 << i; 158 - 159 - /* Assign a resource */ 160 - if (val & PCI_BASE_ADDRESS_SPACE_IO) { 161 - if (i < PCI_MINIO) 162 - i = PCI_MINIO; 163 - #ifdef DEBUGRES 164 - printk(KERN_DEBUG "BAR[%d]: IO size=%08x iobase=%08x\n", 165 - bar, i, pci_iobase); 166 - #endif 167 - if (i > 0xffff) { 168 - /* Invalid size?? */ 169 - val = 0 | PCI_BASE_ADDRESS_SPACE_IO; 170 - #ifdef DEBUGRES 171 - printk(KERN_DEBUG "BAR[%d]: too big for IO??\n", bar); 172 - #endif 173 - } else { 174 - /* Check for un-alignment */ 175 - if ((align = pci_iobase % i)) 176 - pci_iobase += (i - align); 177 - val = pci_iobase | PCI_BASE_ADDRESS_SPACE_IO; 178 - pci_iobase += i; 179 - } 180 - } else { 181 - if (i < PCI_MINMEM) 182 - i = PCI_MINMEM; 183 - #ifdef DEBUGRES 184 - printk(KERN_DEBUG "BAR[%d]: MEMORY size=%08x membase=%08x\n", 185 - bar, i, pci_membase); 186 - #endif 187 - /* Check for un-alignment */ 188 - if ((align = pci_membase % i)) 189 - pci_membase += (i - align); 190 - val = pci_membase | PCI_BASE_ADDRESS_SPACE_MEMORY; 191 - pci_membase += i; 192 - } 193 - 194 - /* Write resource back into BAR register */ 195 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGWR | idsel; 196 - rp[LREG(addr)] = val; 197 - #ifdef DEBUGRES 198 - printk(KERN_DEBUG "BAR[%d]: assigned bar=%08x\n", bar, val); 199 - #endif 200 - } 201 - 202 - #ifdef DEBUGRES 203 - printk(KERN_DEBUG "-----------------------------------" 204 - "-------------------------------------\n"); 205 - #endif 206 - 207 - /* Assign IRQ if one is wanted... */ 208 - ip = (volatile unsigned char *) (COMEM_BASE + COMEM_PCIBUS); 209 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGRD | idsel; 210 - 211 - addr = (PCI_INTERRUPT_PIN & 0xfc) + (~PCI_INTERRUPT_PIN & 0x03); 212 - if (ip[addr]) { 213 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGWR | idsel; 214 - addr = (PCI_INTERRUPT_LINE & 0xfc)+(~PCI_INTERRUPT_LINE & 0x03); 215 - ip[addr] = 25; 216 - #ifdef DEBUGRES 217 - printk(KERN_DEBUG "IRQ LINE=25\n"); 218 - #endif 219 - } 220 - 221 - return(0); 222 - } 223 - 224 - /*****************************************************************************/ 225 - 226 - int pcibios_enable_slot(int slot) 227 - { 228 - volatile unsigned long *rp; 229 - volatile unsigned short *wp; 230 - unsigned int idsel, addr; 231 - unsigned short cmd; 232 - 233 - #ifdef DEBUGPCI 234 - printk(KERN_DEBUG "pcibios_enbale_slot(slot=%x)\n", slot); 235 - #endif 236 - 237 - rp = (volatile unsigned long *) COMEM_BASE; 238 - wp = (volatile unsigned short *) COMEM_BASE; 239 - idsel = COMEM_DA_ADDR(0x1 << (slot + 16)); 240 - 241 - /* Get current command settings */ 242 - addr = COMEM_PCIBUS + PCI_COMMAND; 243 - addr = (addr & ~0x3) + (~addr & 0x02); 244 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGRD | idsel; 245 - cmd = wp[WREG(addr)]; 246 - /*val = ((val & 0xff) << 8) | ((val >> 8) & 0xff);*/ 247 - 248 - /* Enable I/O and memory accesses to this device */ 249 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_CFGWR | idsel; 250 - cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; 251 - wp[WREG(addr)] = cmd; 252 - 253 - return(0); 254 - } 255 - 256 - /*****************************************************************************/ 257 - 258 - void pcibios_assign_resources(void) 259 - { 260 - volatile unsigned long *rp; 261 - unsigned long sel, id; 262 - int slot; 263 - 264 - rp = (volatile unsigned long *) COMEM_BASE; 265 - 266 - /* 267 - * Do a quick scan of the PCI bus and see what is here. 268 - */ 269 - for (slot = COMEM_MINDEV; (slot <= COMEM_MAXDEV); slot++) { 270 - sel = COMEM_DA_CFGRD | COMEM_DA_ADDR(0x1 << (slot + 16)); 271 - rp[LREG(COMEM_DAHBASE)] = sel; 272 - rp[LREG(COMEM_PCIBUS)] = 0; /* Clear bus */ 273 - id = rp[LREG(COMEM_PCIBUS)]; 274 - if ((id != 0) && ((id & 0xffff0000) != (sel & 0xffff0000))) { 275 - printk(KERN_INFO "PCI: slot=%d id=%08x\n", slot, (int) id); 276 - pci_slotmask |= 0x1 << slot; 277 - pcibios_assign_resource_slot(slot); 278 - pcibios_enable_slot(slot); 279 - } 280 - } 281 - } 282 - 283 - /*****************************************************************************/ 284 - 285 - int pcibios_init(void) 286 - { 287 - volatile unsigned long *rp; 288 - unsigned long sel, id; 289 - int slot; 290 - 291 - #ifdef DEBUGPCI 292 - printk(KERN_DEBUG "pcibios_init()\n"); 293 - #endif 294 - 295 - pci_resetbus(); 296 - 297 - /* 298 - * Do some sort of basic check to see if the CO-MEM part 299 - * is present... This works ok, but I think we really need 300 - * something better... 301 - */ 302 - rp = (volatile unsigned long *) COMEM_BASE; 303 - if ((rp[LREG(COMEM_LBUSCFG)] & 0xff) != 0x50) { 304 - printk(KERN_INFO "PCI: no PCI bus present\n"); 305 - return(0); 306 - } 307 - 308 - #ifdef COMEM_BRIDGEDEV 309 - /* 310 - * Setup the PCI bridge device first. It needs resources too, 311 - * so that bus masters can get to its shared memory. 312 - */ 313 - slot = COMEM_BRIDGEDEV; 314 - sel = COMEM_DA_CFGRD | COMEM_DA_ADDR(0x1 << (slot + 16)); 315 - rp[LREG(COMEM_DAHBASE)] = sel; 316 - rp[LREG(COMEM_PCIBUS)] = 0; /* Clear bus */ 317 - id = rp[LREG(COMEM_PCIBUS)]; 318 - if ((id == 0) || ((id & 0xffff0000) == (sel & 0xffff0000))) { 319 - printk(KERN_INFO "PCI: no PCI bus bridge present\n"); 320 - return(0); 321 - } 322 - 323 - printk(KERN_INFO "PCI: bridge device at slot=%d id=%08x\n", slot, (int) id); 324 - pci_slotmask |= 0x1 << slot; 325 - pci_shmemaddr = pci_membase; 326 - pcibios_assign_resource_slot(slot); 327 - pcibios_enable_slot(slot); 328 - #endif 329 - 330 - pci_bus_is_present = 1; 331 - 332 - /* Get PCI irq for local vectoring */ 333 - if (request_irq(COMEM_IRQ, pci_interrupt, 0, "PCI bridge", NULL)) { 334 - printk(KERN_WARNING "PCI: failed to acquire interrupt %d\n", COMEM_IRQ); 335 - } else { 336 - mcf_autovector(COMEM_IRQ); 337 - } 338 - 339 - pcibios_assign_resources(); 340 - 341 - return(0); 342 - } 343 - 344 - /*****************************************************************************/ 345 - 346 - char *pcibios_setup(char *option) 347 - { 348 - /* Nothing for us to handle. */ 349 - return(option); 350 - } 351 - /*****************************************************************************/ 352 - 353 - void pcibios_fixup_bus(struct pci_bus *b) 354 - { 355 - } 356 - 357 - /*****************************************************************************/ 358 - 359 - void pcibios_align_resource(void *data, struct resource *res, 360 - resource_size_t size, resource_size_t align) 361 - { 362 - } 363 - 364 - /*****************************************************************************/ 365 - 366 - int pcibios_enable_device(struct pci_dev *dev, int mask) 367 - { 368 - int slot; 369 - 370 - slot = PCI_SLOT(dev->devfn); 371 - if ((dev->bus == 0) && (pci_slotmask & (1 << slot))) 372 - pcibios_enable_slot(slot); 373 - return(0); 374 - } 375 - 376 - /*****************************************************************************/ 377 - 378 - /* 379 - * Local routines to interrcept the standard I/O and vector handling 380 - * code. Don't include this 'till now - initialization code above needs 381 - * access to the real code too. 382 - */ 383 - #include <asm/mcfpci.h> 384 - 385 - /*****************************************************************************/ 386 - 387 - void pci_outb(unsigned char val, unsigned int addr) 388 - { 389 - volatile unsigned long *rp; 390 - volatile unsigned char *bp; 391 - 392 - #ifdef DEBUGIO 393 - printk(KERN_DEBUG "pci_outb(val=%02x,addr=%x)\n", val, addr); 394 - #endif 395 - 396 - rp = (volatile unsigned long *) COMEM_BASE; 397 - bp = (volatile unsigned char *) COMEM_BASE; 398 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(addr); 399 - addr = (addr & ~0x3) + (~addr & 0x03); 400 - bp[(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))] = val; 401 - } 402 - 403 - /*****************************************************************************/ 404 - 405 - void pci_outw(unsigned short val, unsigned int addr) 406 - { 407 - volatile unsigned long *rp; 408 - volatile unsigned short *sp; 409 - 410 - #ifdef DEBUGIO 411 - printk(KERN_DEBUG "pci_outw(val=%04x,addr=%x)\n", val, addr); 412 - #endif 413 - 414 - rp = (volatile unsigned long *) COMEM_BASE; 415 - sp = (volatile unsigned short *) COMEM_BASE; 416 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(addr); 417 - addr = (addr & ~0x3) + (~addr & 0x02); 418 - if (pci_byteswap) 419 - val = ((val & 0xff) << 8) | ((val >> 8) & 0xff); 420 - sp[WREG(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))] = val; 421 - } 422 - 423 - /*****************************************************************************/ 424 - 425 - void pci_outl(unsigned int val, unsigned int addr) 426 - { 427 - volatile unsigned long *rp; 428 - volatile unsigned int *lp; 429 - 430 - #ifdef DEBUGIO 431 - printk(KERN_DEBUG "pci_outl(val=%08x,addr=%x)\n", val, addr); 432 - #endif 433 - 434 - rp = (volatile unsigned long *) COMEM_BASE; 435 - lp = (volatile unsigned int *) COMEM_BASE; 436 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(addr); 437 - 438 - if (pci_byteswap) 439 - val = (val << 24) | ((val & 0x0000ff00) << 8) | 440 - ((val & 0x00ff0000) >> 8) | (val >> 24); 441 - 442 - lp[LREG(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))] = val; 443 - } 444 - 445 - /*****************************************************************************/ 446 - 447 - unsigned long pci_blmask[] = { 448 - 0x000000e0, 449 - 0x000000d0, 450 - 0x000000b0, 451 - 0x00000070 452 - }; 453 - 454 - unsigned char pci_inb(unsigned int addr) 455 - { 456 - volatile unsigned long *rp; 457 - volatile unsigned char *bp; 458 - unsigned long r; 459 - unsigned char val; 460 - 461 - #ifdef DEBUGIO 462 - printk(KERN_DEBUG "pci_inb(addr=%x)\n", addr); 463 - #endif 464 - 465 - rp = (volatile unsigned long *) COMEM_BASE; 466 - bp = (volatile unsigned char *) COMEM_BASE; 467 - 468 - r = COMEM_DA_IORD | COMEM_DA_ADDR(addr) | pci_blmask[(addr & 0x3)]; 469 - rp[LREG(COMEM_DAHBASE)] = r; 470 - 471 - addr = (addr & ~0x3) + (~addr & 0x3); 472 - val = bp[(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))]; 473 - return(val); 474 - } 475 - 476 - /*****************************************************************************/ 477 - 478 - unsigned long pci_bwmask[] = { 479 - 0x000000c0, 480 - 0x000000c0, 481 - 0x00000030, 482 - 0x00000030 483 - }; 484 - 485 - unsigned short pci_inw(unsigned int addr) 486 - { 487 - volatile unsigned long *rp; 488 - volatile unsigned short *sp; 489 - unsigned long r; 490 - unsigned short val; 491 - 492 - #ifdef DEBUGIO 493 - printk(KERN_DEBUG "pci_inw(addr=%x)", addr); 494 - #endif 495 - 496 - rp = (volatile unsigned long *) COMEM_BASE; 497 - r = COMEM_DA_IORD | COMEM_DA_ADDR(addr) | pci_bwmask[(addr & 0x3)]; 498 - rp[LREG(COMEM_DAHBASE)] = r; 499 - 500 - sp = (volatile unsigned short *) COMEM_BASE; 501 - addr = (addr & ~0x3) + (~addr & 0x02); 502 - val = sp[WREG(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))]; 503 - if (pci_byteswap) 504 - val = ((val & 0xff) << 8) | ((val >> 8) & 0xff); 505 - #ifdef DEBUGIO 506 - printk(KERN_DEBUG "=%04x\n", val); 507 - #endif 508 - return(val); 509 - } 510 - 511 - /*****************************************************************************/ 512 - 513 - unsigned int pci_inl(unsigned int addr) 514 - { 515 - volatile unsigned long *rp; 516 - volatile unsigned int *lp; 517 - unsigned int val; 518 - 519 - #ifdef DEBUGIO 520 - printk(KERN_DEBUG "pci_inl(addr=%x)", addr); 521 - #endif 522 - 523 - rp = (volatile unsigned long *) COMEM_BASE; 524 - lp = (volatile unsigned int *) COMEM_BASE; 525 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IORD | COMEM_DA_ADDR(addr); 526 - val = lp[LREG(COMEM_PCIBUS + COMEM_DA_OFFSET(addr))]; 527 - 528 - if (pci_byteswap) 529 - val = (val << 24) | ((val & 0x0000ff00) << 8) | 530 - ((val & 0x00ff0000) >> 8) | (val >> 24); 531 - 532 - #ifdef DEBUGIO 533 - printk(KERN_DEBUG "=%08x\n", val); 534 - #endif 535 - return(val); 536 - } 537 - 538 - /*****************************************************************************/ 539 - 540 - void pci_outsb(void *addr, void *buf, int len) 541 - { 542 - volatile unsigned long *rp; 543 - volatile unsigned char *bp; 544 - unsigned char *dp = (unsigned char *) buf; 545 - unsigned int a = (unsigned int) addr; 546 - 547 - #ifdef DEBUGIO 548 - printk(KERN_DEBUG "pci_outsb(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 549 - #endif 550 - 551 - rp = (volatile unsigned long *) COMEM_BASE; 552 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(a); 553 - 554 - a = (a & ~0x3) + (~a & 0x03); 555 - bp = (volatile unsigned char *) 556 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 557 - 558 - while (len--) 559 - *bp = *dp++; 560 - } 561 - 562 - /*****************************************************************************/ 563 - 564 - void pci_outsw(void *addr, void *buf, int len) 565 - { 566 - volatile unsigned long *rp; 567 - volatile unsigned short *wp; 568 - unsigned short w, *dp = (unsigned short *) buf; 569 - unsigned int a = (unsigned int) addr; 570 - 571 - #ifdef DEBUGIO 572 - printk(KERN_DEBUG "pci_outsw(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 573 - #endif 574 - 575 - rp = (volatile unsigned long *) COMEM_BASE; 576 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(a); 577 - 578 - a = (a & ~0x3) + (~a & 0x2); 579 - wp = (volatile unsigned short *) 580 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 581 - 582 - while (len--) { 583 - w = *dp++; 584 - if (pci_byteswap) 585 - w = ((w & 0xff) << 8) | ((w >> 8) & 0xff); 586 - *wp = w; 587 - } 588 - } 589 - 590 - /*****************************************************************************/ 591 - 592 - void pci_outsl(void *addr, void *buf, int len) 593 - { 594 - volatile unsigned long *rp; 595 - volatile unsigned long *lp; 596 - unsigned long l, *dp = (unsigned long *) buf; 597 - unsigned int a = (unsigned int) addr; 598 - 599 - #ifdef DEBUGIO 600 - printk(KERN_DEBUG "pci_outsl(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 601 - #endif 602 - 603 - rp = (volatile unsigned long *) COMEM_BASE; 604 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IOWR | COMEM_DA_ADDR(a); 605 - 606 - lp = (volatile unsigned long *) 607 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 608 - 609 - while (len--) { 610 - l = *dp++; 611 - if (pci_byteswap) 612 - l = (l << 24) | ((l & 0x0000ff00) << 8) | 613 - ((l & 0x00ff0000) >> 8) | (l >> 24); 614 - *lp = l; 615 - } 616 - } 617 - 618 - /*****************************************************************************/ 619 - 620 - void pci_insb(void *addr, void *buf, int len) 621 - { 622 - volatile unsigned long *rp; 623 - volatile unsigned char *bp; 624 - unsigned char *dp = (unsigned char *) buf; 625 - unsigned int a = (unsigned int) addr; 626 - 627 - #ifdef DEBUGIO 628 - printk(KERN_DEBUG "pci_insb(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 629 - #endif 630 - 631 - rp = (volatile unsigned long *) COMEM_BASE; 632 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IORD | COMEM_DA_ADDR(a); 633 - 634 - a = (a & ~0x3) + (~a & 0x03); 635 - bp = (volatile unsigned char *) 636 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 637 - 638 - while (len--) 639 - *dp++ = *bp; 640 - } 641 - 642 - /*****************************************************************************/ 643 - 644 - void pci_insw(void *addr, void *buf, int len) 645 - { 646 - volatile unsigned long *rp; 647 - volatile unsigned short *wp; 648 - unsigned short w, *dp = (unsigned short *) buf; 649 - unsigned int a = (unsigned int) addr; 650 - 651 - #ifdef DEBUGIO 652 - printk(KERN_DEBUG "pci_insw(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 653 - #endif 654 - 655 - rp = (volatile unsigned long *) COMEM_BASE; 656 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IORD | COMEM_DA_ADDR(a); 657 - 658 - a = (a & ~0x3) + (~a & 0x2); 659 - wp = (volatile unsigned short *) 660 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 661 - 662 - while (len--) { 663 - w = *wp; 664 - if (pci_byteswap) 665 - w = ((w & 0xff) << 8) | ((w >> 8) & 0xff); 666 - *dp++ = w; 667 - } 668 - } 669 - 670 - /*****************************************************************************/ 671 - 672 - void pci_insl(void *addr, void *buf, int len) 673 - { 674 - volatile unsigned long *rp; 675 - volatile unsigned long *lp; 676 - unsigned long l, *dp = (unsigned long *) buf; 677 - unsigned int a = (unsigned int) addr; 678 - 679 - #ifdef DEBUGIO 680 - printk(KERN_DEBUG "pci_insl(addr=%x,buf=%x,len=%d)\n", (int)addr, (int)buf, len); 681 - #endif 682 - 683 - rp = (volatile unsigned long *) COMEM_BASE; 684 - rp[LREG(COMEM_DAHBASE)] = COMEM_DA_IORD | COMEM_DA_ADDR(a); 685 - 686 - lp = (volatile unsigned long *) 687 - (COMEM_BASE + COMEM_PCIBUS + COMEM_DA_OFFSET(a)); 688 - 689 - while (len--) { 690 - l = *lp; 691 - if (pci_byteswap) 692 - l = (l << 24) | ((l & 0x0000ff00) << 8) | 693 - ((l & 0x00ff0000) >> 8) | (l >> 24); 694 - *dp++ = l; 695 - } 696 - } 697 - 698 - /*****************************************************************************/ 699 - 700 - struct pci_localirqlist { 701 - void (*handler)(int, void *, struct pt_regs *); 702 - const char *device; 703 - void *dev_id; 704 - }; 705 - 706 - struct pci_localirqlist pci_irqlist[COMEM_MAXPCI]; 707 - 708 - /*****************************************************************************/ 709 - 710 - int pci_request_irq(unsigned int irq, 711 - void (*handler)(int, void *, struct pt_regs *), 712 - unsigned long flags, const char *device, void *dev_id) 713 - { 714 - int i; 715 - 716 - #ifdef DEBUGIO 717 - printk(KERN_DEBUG "pci_request_irq(irq=%d,handler=%x,flags=%x,device=%s," 718 - "dev_id=%x)\n", irq, (int) handler, (int) flags, device, 719 - (int) dev_id); 720 - #endif 721 - 722 - /* Check if this interrupt handler is already lodged */ 723 - for (i = 0; (i < COMEM_MAXPCI); i++) { 724 - if (pci_irqlist[i].handler == handler) 725 - return(0); 726 - } 727 - 728 - /* Find a free spot to put this handler */ 729 - for (i = 0; (i < COMEM_MAXPCI); i++) { 730 - if (pci_irqlist[i].handler == 0) { 731 - pci_irqlist[i].handler = handler; 732 - pci_irqlist[i].device = device; 733 - pci_irqlist[i].dev_id = dev_id; 734 - return(0); 735 - } 736 - } 737 - 738 - /* Couldn't fit?? */ 739 - return(1); 740 - } 741 - 742 - /*****************************************************************************/ 743 - 744 - void pci_free_irq(unsigned int irq, void *dev_id) 745 - { 746 - int i; 747 - 748 - #ifdef DEBUGIO 749 - printk(KERN_DEBUG "pci_free_irq(irq=%d,dev_id=%x)\n", irq, (int) dev_id); 750 - #endif 751 - 752 - if (dev_id == (void *) NULL) 753 - return; 754 - 755 - /* Check if this interrupt handler is lodged */ 756 - for (i = 0; (i < COMEM_MAXPCI); i++) { 757 - if (pci_irqlist[i].dev_id == dev_id) { 758 - pci_irqlist[i].handler = NULL; 759 - pci_irqlist[i].device = NULL; 760 - pci_irqlist[i].dev_id = NULL; 761 - break; 762 - } 763 - } 764 - } 765 - 766 - /*****************************************************************************/ 767 - 768 - void pci_interrupt(int irq, void *id, struct pt_regs *fp) 769 - { 770 - int i; 771 - 772 - #ifdef DEBUGIO 773 - printk(KERN_DEBUG "pci_interrupt(irq=%d,id=%x,fp=%x)\n", irq, (int) id, (int) fp); 774 - #endif 775 - 776 - for (i = 0; (i < COMEM_MAXPCI); i++) { 777 - if (pci_irqlist[i].handler) 778 - (*pci_irqlist[i].handler)(irq,pci_irqlist[i].dev_id,fp); 779 - } 780 - } 781 - 782 - /*****************************************************************************/ 783 - 784 - /* 785 - * The shared memory region is broken up into contiguous 512 byte 786 - * regions for easy allocation... This is not an optimal solution 787 - * but it makes allocation and freeing regions really easy. 788 - */ 789 - 790 - #define PCI_MEMSLOTSIZE 512 791 - #define PCI_MEMSLOTS (COMEM_SHMEMSIZE / PCI_MEMSLOTSIZE) 792 - 793 - char pci_shmemmap[PCI_MEMSLOTS]; 794 - 795 - 796 - void *pci_bmalloc(int size) 797 - { 798 - int i, j, nrslots; 799 - 800 - #ifdef DEBUGIO 801 - printk(KERN_DEBUG "pci_bmalloc(size=%d)\n", size); 802 - #endif 803 - 804 - if (size <= 0) 805 - return((void *) NULL); 806 - 807 - nrslots = (size - 1) / PCI_MEMSLOTSIZE; 808 - 809 - for (i = 0; (i < (PCI_MEMSLOTS-nrslots)); i++) { 810 - if (pci_shmemmap[i] == 0) { 811 - for (j = i+1; (j < (i+nrslots)); j++) { 812 - if (pci_shmemmap[j]) 813 - goto restart; 814 - } 815 - 816 - for (j = i; (j <= i+nrslots); j++) 817 - pci_shmemmap[j] = 1; 818 - break; 819 - } 820 - restart: 821 - } 822 - 823 - return((void *) (COMEM_BASE + COMEM_SHMEM + (i * PCI_MEMSLOTSIZE))); 824 - } 825 - 826 - /*****************************************************************************/ 827 - 828 - void pci_bmfree(void *mp, int size) 829 - { 830 - int i, j, nrslots; 831 - 832 - #ifdef DEBUGIO 833 - printk(KERN_DEBUG "pci_bmfree(mp=%x,size=%d)\n", (int) mp, size); 834 - #endif 835 - 836 - nrslots = size / PCI_MEMSLOTSIZE; 837 - i = (((unsigned long) mp) - (COMEM_BASE + COMEM_SHMEM)) / 838 - PCI_MEMSLOTSIZE; 839 - 840 - for (j = i; (j < (i+nrslots)); j++) 841 - pci_shmemmap[j] = 0; 842 - } 843 - 844 - /*****************************************************************************/ 845 - 846 - unsigned long pci_virt_to_bus(volatile void *address) 847 - { 848 - unsigned long l; 849 - 850 - #ifdef DEBUGIO 851 - printk(KERN_DEBUG "pci_virt_to_bus(address=%x)", (int) address); 852 - #endif 853 - 854 - l = ((unsigned long) address) - COMEM_BASE; 855 - #ifdef DEBUGIO 856 - printk(KERN_DEBUG "=%x\n", (int) (l+pci_shmemaddr)); 857 - #endif 858 - return(l + pci_shmemaddr); 859 - } 860 - 861 - /*****************************************************************************/ 862 - 863 - void *pci_bus_to_virt(unsigned long address) 864 - { 865 - unsigned long l; 866 - 867 - #ifdef DEBUGIO 868 - printk(KERN_DEBUG "pci_bus_to_virt(address=%x)", (int) address); 869 - #endif 870 - 871 - l = address - pci_shmemaddr; 872 - #ifdef DEBUGIO 873 - printk(KERN_DEBUG "=%x\n", (int) (address + COMEM_BASE)); 874 - #endif 875 - return((void *) (address + COMEM_BASE)); 876 - } 877 - 878 - /*****************************************************************************/ 879 - 880 - void pci_bmcpyto(void *dst, void *src, int len) 881 - { 882 - unsigned long *dp, *sp, val; 883 - unsigned char *dcp, *scp; 884 - int i, j; 885 - 886 - #ifdef DEBUGIO 887 - printk(KERN_DEBUG "pci_bmcpyto(dst=%x,src=%x,len=%d)\n", (int)dst, (int)src, len); 888 - #endif 889 - 890 - dp = (unsigned long *) dst; 891 - sp = (unsigned long *) src; 892 - i = len >> 2; 893 - 894 - #if 0 895 - printk(KERN_INFO "DATA:"); 896 - scp = (unsigned char *) sp; 897 - for (i = 0; (i < len); i++) { 898 - if ((i % 16) == 0) printk(KERN_INFO "\n%04x: ", i); 899 - printk(KERN_INFO "%02x ", *scp++); 900 - } 901 - printk(KERN_INFO "\n"); 902 - #endif 903 - 904 - for (j = 0; (i >= 0); i--, j++) { 905 - val = *sp++; 906 - val = (val << 24) | ((val & 0x0000ff00) << 8) | 907 - ((val & 0x00ff0000) >> 8) | (val >> 24); 908 - *dp++ = val; 909 - } 910 - 911 - if (len & 0x3) { 912 - dcp = (unsigned char *) dp; 913 - scp = ((unsigned char *) sp) + 3; 914 - for (i = 0; (i < (len & 0x3)); i++) 915 - *dcp++ = *scp--; 916 - } 917 - } 918 - 919 - /*****************************************************************************/ 920 - 921 - void pci_bmcpyfrom(void *dst, void *src, int len) 922 - { 923 - unsigned long *dp, *sp, val; 924 - unsigned char *dcp, *scp; 925 - int i; 926 - 927 - #ifdef DEBUGIO 928 - printk(KERN_DEBUG "pci_bmcpyfrom(dst=%x,src=%x,len=%d)\n",(int)dst,(int)src,len); 929 - #endif 930 - 931 - dp = (unsigned long *) dst; 932 - sp = (unsigned long *) src; 933 - i = len >> 2; 934 - 935 - for (; (i >= 0); i--) { 936 - val = *sp++; 937 - val = (val << 24) | ((val & 0x0000ff00) << 8) | 938 - ((val & 0x00ff0000) >> 8) | (val >> 24); 939 - *dp++ = val; 940 - } 941 - 942 - if (len & 0x3) { 943 - dcp = ((unsigned char *) dp) + 3; 944 - scp = (unsigned char *) sp; 945 - for (i = 0; (i < (len & 0x3)); i++) 946 - *dcp++ = *scp--; 947 - } 948 - 949 - #if 0 950 - printk(KERN_INFO "DATA:"); 951 - dcp = (unsigned char *) dst; 952 - for (i = 0; (i < len); i++) { 953 - if ((i % 16) == 0) printk(KERN_INFO "\n%04x: ", i); 954 - printk(KERN_INFO "%02x ", *dcp++); 955 - } 956 - printk(KERN_INFO "\n"); 957 - #endif 958 - } 959 - 960 - /*****************************************************************************/ 961 - 962 - void *pci_alloc_consistent(struct pci_dev *dev, size_t size, dma_addr_t *dma_addr) 963 - { 964 - void *mp; 965 - if ((mp = pci_bmalloc(size)) != NULL) { 966 - dma_addr = mp - (COMEM_BASE + COMEM_SHMEM); 967 - return(mp); 968 - } 969 - *dma_addr = (dma_addr_t) NULL; 970 - return(NULL); 971 - } 972 - 973 - /*****************************************************************************/ 974 - 975 - void pci_free_consistent(struct pci_dev *dev, size_t size, void *cpu_addr, dma_addr_t dma_addr) 976 - { 977 - pci_bmfree(cpu_addr, size); 978 - } 979 - 980 - /*****************************************************************************/