1 /* 2 * linux/arch/arm/kernel/ecard.c 3 * 4 * Copyright 1995-2001 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * Find all installed expansion cards, and handle interrupts from them. 11 * 12 * Created from information from Acorns RiscOS3 PRMs 13 * 14 * 08-Dec-1996 RMK Added code for the 9'th expansion card - the ether 15 * podule slot. 16 * 06-May-1997 RMK Added blacklist for cards whose loader doesn't work. 17 * 12-Sep-1997 RMK Created new handling of interrupt enables/disables 18 * - cards can now register their own routine to control 19 * interrupts (recommended). 20 * 29-Sep-1997 RMK Expansion card interrupt hardware not being re-enabled 21 * on reset from Linux. (Caused cards not to respond 22 * under RiscOS without hard reset). 23 * 15-Feb-1998 RMK Added DMA support 24 * 12-Sep-1998 RMK Added EASI support 25 * 10-Jan-1999 RMK Run loaders in a simulated RISC OS environment. 26 * 17-Apr-1999 RMK Support for EASI Type C cycles. 27 */ 28 #define ECARD_C 29 30 #include <linux/module.h> 31 #include <linux/kernel.h> 32 #include <linux/types.h> 33 #include <linux/sched.h> 34 #include <linux/sched/mm.h> 35 #include <linux/interrupt.h> 36 #include <linux/completion.h> 37 #include <linux/reboot.h> 38 #include <linux/mm.h> 39 #include <linux/slab.h> 40 #include <linux/proc_fs.h> 41 #include <linux/seq_file.h> 42 #include <linux/device.h> 43 #include <linux/init.h> 44 #include <linux/mutex.h> 45 #include <linux/kthread.h> 46 #include <linux/irq.h> 47 #include <linux/io.h> 48 49 #include <asm/dma.h> 50 #include <asm/ecard.h> 51 #include <mach/hardware.h> 52 #include <asm/irq.h> 53 #include <asm/mmu_context.h> 54 #include <asm/mach/irq.h> 55 #include <asm/tlbflush.h> 56 57 #include "ecard.h" 58 59 struct ecard_request { 60 void (*fn)(struct ecard_request *); 61 ecard_t *ec; 62 unsigned int address; 63 unsigned int length; 64 unsigned int use_loader; 65 void *buffer; 66 struct completion *complete; 67 }; 68 69 struct expcard_blacklist { 70 unsigned short manufacturer; 71 unsigned short product; 72 const char *type; 73 }; 74 75 static ecard_t *cards; 76 static ecard_t *slot_to_expcard[MAX_ECARDS]; 77 static unsigned int ectcr; 78 79 /* List of descriptions of cards which don't have an extended 80 * identification, or chunk directories containing a description. 81 */ 82 static struct expcard_blacklist __initdata blacklist[] = { 83 { MANU_ACORN, PROD_ACORN_ETHER1, "Acorn Ether1" } 84 }; 85 86 asmlinkage extern int 87 ecard_loader_reset(unsigned long base, loader_t loader); 88 asmlinkage extern int 89 ecard_loader_read(int off, unsigned long base, loader_t loader); 90 91 static inline unsigned short ecard_getu16(unsigned char *v) 92 { 93 return v[0] | v[1] << 8; 94 } 95 96 static inline signed long ecard_gets24(unsigned char *v) 97 { 98 return v[0] | v[1] << 8 | v[2] << 16 | ((v[2] & 0x80) ? 0xff000000 : 0); 99 } 100 101 static inline ecard_t *slot_to_ecard(unsigned int slot) 102 { 103 return slot < MAX_ECARDS ? slot_to_expcard[slot] : NULL; 104 } 105 106 /* ===================== Expansion card daemon ======================== */ 107 /* 108 * Since the loader programs on the expansion cards need to be run 109 * in a specific environment, create a separate task with this 110 * environment up, and pass requests to this task as and when we 111 * need to. 112 * 113 * This should allow 99% of loaders to be called from Linux. 114 * 115 * From a security standpoint, we trust the card vendors. This 116 * may be a misplaced trust. 117 */ 118 static void ecard_task_reset(struct ecard_request *req) 119 { 120 struct expansion_card *ec = req->ec; 121 struct resource *res; 122 123 res = ec->slot_no == 8 124 ? &ec->resource[ECARD_RES_MEMC] 125 : ec->easi 126 ? &ec->resource[ECARD_RES_EASI] 127 : &ec->resource[ECARD_RES_IOCSYNC]; 128 129 ecard_loader_reset(res->start, ec->loader); 130 } 131 132 static void ecard_task_readbytes(struct ecard_request *req) 133 { 134 struct expansion_card *ec = req->ec; 135 unsigned char *buf = req->buffer; 136 unsigned int len = req->length; 137 unsigned int off = req->address; 138 139 if (ec->slot_no == 8) { 140 void __iomem *base = (void __iomem *) 141 ec->resource[ECARD_RES_MEMC].start; 142 143 /* 144 * The card maintains an index which increments the address 145 * into a 4096-byte page on each access. We need to keep 146 * track of the counter. 147 */ 148 static unsigned int index; 149 unsigned int page; 150 151 page = (off >> 12) * 4; 152 if (page > 256 * 4) 153 return; 154 155 off &= 4095; 156 157 /* 158 * If we are reading offset 0, or our current index is 159 * greater than the offset, reset the hardware index counter. 160 */ 161 if (off == 0 || index > off) { 162 writeb(0, base); 163 index = 0; 164 } 165 166 /* 167 * Increment the hardware index counter until we get to the 168 * required offset. The read bytes are discarded. 169 */ 170 while (index < off) { 171 readb(base + page); 172 index += 1; 173 } 174 175 while (len--) { 176 *buf++ = readb(base + page); 177 index += 1; 178 } 179 } else { 180 unsigned long base = (ec->easi 181 ? &ec->resource[ECARD_RES_EASI] 182 : &ec->resource[ECARD_RES_IOCSYNC])->start; 183 void __iomem *pbase = (void __iomem *)base; 184 185 if (!req->use_loader || !ec->loader) { 186 off *= 4; 187 while (len--) { 188 *buf++ = readb(pbase + off); 189 off += 4; 190 } 191 } else { 192 while(len--) { 193 /* 194 * The following is required by some 195 * expansion card loader programs. 196 */ 197 *(unsigned long *)0x108 = 0; 198 *buf++ = ecard_loader_read(off++, base, 199 ec->loader); 200 } 201 } 202 } 203 204 } 205 206 static DECLARE_WAIT_QUEUE_HEAD(ecard_wait); 207 static struct ecard_request *ecard_req; 208 static DEFINE_MUTEX(ecard_mutex); 209 210 /* 211 * Set up the expansion card daemon's page tables. 212 */ 213 static void ecard_init_pgtables(struct mm_struct *mm) 214 { 215 struct vm_area_struct vma; 216 217 /* We want to set up the page tables for the following mapping: 218 * Virtual Physical 219 * 0x03000000 0x03000000 220 * 0x03010000 unmapped 221 * 0x03210000 0x03210000 222 * 0x03400000 unmapped 223 * 0x08000000 0x08000000 224 * 0x10000000 unmapped 225 * 226 * FIXME: we don't follow this 100% yet. 227 */ 228 pgd_t *src_pgd, *dst_pgd; 229 230 src_pgd = pgd_offset(mm, (unsigned long)IO_BASE); 231 dst_pgd = pgd_offset(mm, IO_START); 232 233 memcpy(dst_pgd, src_pgd, sizeof(pgd_t) * (IO_SIZE / PGDIR_SIZE)); 234 235 src_pgd = pgd_offset(mm, (unsigned long)EASI_BASE); 236 dst_pgd = pgd_offset(mm, EASI_START); 237 238 memcpy(dst_pgd, src_pgd, sizeof(pgd_t) * (EASI_SIZE / PGDIR_SIZE)); 239 240 vma.vm_flags = VM_EXEC; 241 vma.vm_mm = mm; 242 243 flush_tlb_range(&vma, IO_START, IO_START + IO_SIZE); 244 flush_tlb_range(&vma, EASI_START, EASI_START + EASI_SIZE); 245 } 246 247 static int ecard_init_mm(void) 248 { 249 struct mm_struct * mm = mm_alloc(); 250 struct mm_struct *active_mm = current->active_mm; 251 252 if (!mm) 253 return -ENOMEM; 254 255 current->mm = mm; 256 current->active_mm = mm; 257 activate_mm(active_mm, mm); 258 mmdrop(active_mm); 259 ecard_init_pgtables(mm); 260 return 0; 261 } 262 263 static int 264 ecard_task(void * unused) 265 { 266 /* 267 * Allocate a mm. We're not a lazy-TLB kernel task since we need 268 * to set page table entries where the user space would be. Note 269 * that this also creates the page tables. Failure is not an 270 * option here. 271 */ 272 if (ecard_init_mm()) 273 panic("kecardd: unable to alloc mm\n"); 274 275 while (1) { 276 struct ecard_request *req; 277 278 wait_event_interruptible(ecard_wait, ecard_req != NULL); 279 280 req = xchg(&ecard_req, NULL); 281 if (req != NULL) { 282 req->fn(req); 283 complete(req->complete); 284 } 285 } 286 } 287 288 /* 289 * Wake the expansion card daemon to action our request. 290 * 291 * FIXME: The test here is not sufficient to detect if the 292 * kcardd is running. 293 */ 294 static void ecard_call(struct ecard_request *req) 295 { 296 DECLARE_COMPLETION_ONSTACK(completion); 297 298 req->complete = &completion; 299 300 mutex_lock(&ecard_mutex); 301 ecard_req = req; 302 wake_up(&ecard_wait); 303 304 /* 305 * Now wait for kecardd to run. 306 */ 307 wait_for_completion(&completion); 308 mutex_unlock(&ecard_mutex); 309 } 310 311 /* ======================= Mid-level card control ===================== */ 312 313 static void 314 ecard_readbytes(void *addr, ecard_t *ec, int off, int len, int useld) 315 { 316 struct ecard_request req; 317 318 req.fn = ecard_task_readbytes; 319 req.ec = ec; 320 req.address = off; 321 req.length = len; 322 req.use_loader = useld; 323 req.buffer = addr; 324 325 ecard_call(&req); 326 } 327 328 int ecard_readchunk(struct in_chunk_dir *cd, ecard_t *ec, int id, int num) 329 { 330 struct ex_chunk_dir excd; 331 int index = 16; 332 int useld = 0; 333 334 if (!ec->cid.cd) 335 return 0; 336 337 while(1) { 338 ecard_readbytes(&excd, ec, index, 8, useld); 339 index += 8; 340 if (c_id(&excd) == 0) { 341 if (!useld && ec->loader) { 342 useld = 1; 343 index = 0; 344 continue; 345 } 346 return 0; 347 } 348 if (c_id(&excd) == 0xf0) { /* link */ 349 index = c_start(&excd); 350 continue; 351 } 352 if (c_id(&excd) == 0x80) { /* loader */ 353 if (!ec->loader) { 354 ec->loader = kmalloc(c_len(&excd), 355 GFP_KERNEL); 356 if (ec->loader) 357 ecard_readbytes(ec->loader, ec, 358 (int)c_start(&excd), 359 c_len(&excd), useld); 360 else 361 return 0; 362 } 363 continue; 364 } 365 if (c_id(&excd) == id && num-- == 0) 366 break; 367 } 368 369 if (c_id(&excd) & 0x80) { 370 switch (c_id(&excd) & 0x70) { 371 case 0x70: 372 ecard_readbytes((unsigned char *)excd.d.string, ec, 373 (int)c_start(&excd), c_len(&excd), 374 useld); 375 break; 376 case 0x00: 377 break; 378 } 379 } 380 cd->start_offset = c_start(&excd); 381 memcpy(cd->d.string, excd.d.string, 256); 382 return 1; 383 } 384 385 /* ======================= Interrupt control ============================ */ 386 387 static void ecard_def_irq_enable(ecard_t *ec, int irqnr) 388 { 389 } 390 391 static void ecard_def_irq_disable(ecard_t *ec, int irqnr) 392 { 393 } 394 395 static int ecard_def_irq_pending(ecard_t *ec) 396 { 397 return !ec->irqmask || readb(ec->irqaddr) & ec->irqmask; 398 } 399 400 static void ecard_def_fiq_enable(ecard_t *ec, int fiqnr) 401 { 402 panic("ecard_def_fiq_enable called - impossible"); 403 } 404 405 static void ecard_def_fiq_disable(ecard_t *ec, int fiqnr) 406 { 407 panic("ecard_def_fiq_disable called - impossible"); 408 } 409 410 static int ecard_def_fiq_pending(ecard_t *ec) 411 { 412 return !ec->fiqmask || readb(ec->fiqaddr) & ec->fiqmask; 413 } 414 415 static expansioncard_ops_t ecard_default_ops = { 416 ecard_def_irq_enable, 417 ecard_def_irq_disable, 418 ecard_def_irq_pending, 419 ecard_def_fiq_enable, 420 ecard_def_fiq_disable, 421 ecard_def_fiq_pending 422 }; 423 424 /* 425 * Enable and disable interrupts from expansion cards. 426 * (interrupts are disabled for these functions). 427 * 428 * They are not meant to be called directly, but via enable/disable_irq. 429 */ 430 static void ecard_irq_unmask(struct irq_data *d) 431 { 432 ecard_t *ec = irq_data_get_irq_chip_data(d); 433 434 if (ec) { 435 if (!ec->ops) 436 ec->ops = &ecard_default_ops; 437 438 if (ec->claimed && ec->ops->irqenable) 439 ec->ops->irqenable(ec, d->irq); 440 else 441 printk(KERN_ERR "ecard: rejecting request to " 442 "enable IRQs for %d\n", d->irq); 443 } 444 } 445 446 static void ecard_irq_mask(struct irq_data *d) 447 { 448 ecard_t *ec = irq_data_get_irq_chip_data(d); 449 450 if (ec) { 451 if (!ec->ops) 452 ec->ops = &ecard_default_ops; 453 454 if (ec->ops && ec->ops->irqdisable) 455 ec->ops->irqdisable(ec, d->irq); 456 } 457 } 458 459 static struct irq_chip ecard_chip = { 460 .name = "ECARD", 461 .irq_ack = ecard_irq_mask, 462 .irq_mask = ecard_irq_mask, 463 .irq_unmask = ecard_irq_unmask, 464 }; 465 466 void ecard_enablefiq(unsigned int fiqnr) 467 { 468 ecard_t *ec = slot_to_ecard(fiqnr); 469 470 if (ec) { 471 if (!ec->ops) 472 ec->ops = &ecard_default_ops; 473 474 if (ec->claimed && ec->ops->fiqenable) 475 ec->ops->fiqenable(ec, fiqnr); 476 else 477 printk(KERN_ERR "ecard: rejecting request to " 478 "enable FIQs for %d\n", fiqnr); 479 } 480 } 481 482 void ecard_disablefiq(unsigned int fiqnr) 483 { 484 ecard_t *ec = slot_to_ecard(fiqnr); 485 486 if (ec) { 487 if (!ec->ops) 488 ec->ops = &ecard_default_ops; 489 490 if (ec->ops->fiqdisable) 491 ec->ops->fiqdisable(ec, fiqnr); 492 } 493 } 494 495 static void ecard_dump_irq_state(void) 496 { 497 ecard_t *ec; 498 499 printk("Expansion card IRQ state:\n"); 500 501 for (ec = cards; ec; ec = ec->next) { 502 if (ec->slot_no == 8) 503 continue; 504 505 printk(" %d: %sclaimed, ", 506 ec->slot_no, ec->claimed ? "" : "not "); 507 508 if (ec->ops && ec->ops->irqpending && 509 ec->ops != &ecard_default_ops) 510 printk("irq %spending\n", 511 ec->ops->irqpending(ec) ? "" : "not "); 512 else 513 printk("irqaddr %p, mask = %02X, status = %02X\n", 514 ec->irqaddr, ec->irqmask, readb(ec->irqaddr)); 515 } 516 } 517 518 static void ecard_check_lockup(struct irq_desc *desc) 519 { 520 static unsigned long last; 521 static int lockup; 522 523 /* 524 * If the timer interrupt has not run since the last million 525 * unrecognised expansion card interrupts, then there is 526 * something seriously wrong. Disable the expansion card 527 * interrupts so at least we can continue. 528 * 529 * Maybe we ought to start a timer to re-enable them some time 530 * later? 531 */ 532 if (last == jiffies) { 533 lockup += 1; 534 if (lockup > 1000000) { 535 printk(KERN_ERR "\nInterrupt lockup detected - " 536 "disabling all expansion card interrupts\n"); 537 538 desc->irq_data.chip->irq_mask(&desc->irq_data); 539 ecard_dump_irq_state(); 540 } 541 } else 542 lockup = 0; 543 544 /* 545 * If we did not recognise the source of this interrupt, 546 * warn the user, but don't flood the user with these messages. 547 */ 548 if (!last || time_after(jiffies, last + 5*HZ)) { 549 last = jiffies; 550 printk(KERN_WARNING "Unrecognised interrupt from backplane\n"); 551 ecard_dump_irq_state(); 552 } 553 } 554 555 static void ecard_irq_handler(struct irq_desc *desc) 556 { 557 ecard_t *ec; 558 int called = 0; 559 560 desc->irq_data.chip->irq_mask(&desc->irq_data); 561 for (ec = cards; ec; ec = ec->next) { 562 int pending; 563 564 if (!ec->claimed || !ec->irq || ec->slot_no == 8) 565 continue; 566 567 if (ec->ops && ec->ops->irqpending) 568 pending = ec->ops->irqpending(ec); 569 else 570 pending = ecard_default_ops.irqpending(ec); 571 572 if (pending) { 573 generic_handle_irq(ec->irq); 574 called ++; 575 } 576 } 577 desc->irq_data.chip->irq_unmask(&desc->irq_data); 578 579 if (called == 0) 580 ecard_check_lockup(desc); 581 } 582 583 static void __iomem *__ecard_address(ecard_t *ec, card_type_t type, card_speed_t speed) 584 { 585 void __iomem *address = NULL; 586 int slot = ec->slot_no; 587 588 if (ec->slot_no == 8) 589 return ECARD_MEMC8_BASE; 590 591 ectcr &= ~(1 << slot); 592 593 switch (type) { 594 case ECARD_MEMC: 595 if (slot < 4) 596 address = ECARD_MEMC_BASE + (slot << 14); 597 break; 598 599 case ECARD_IOC: 600 if (slot < 4) 601 address = ECARD_IOC_BASE + (slot << 14); 602 else 603 address = ECARD_IOC4_BASE + ((slot - 4) << 14); 604 if (address) 605 address += speed << 19; 606 break; 607 608 case ECARD_EASI: 609 address = ECARD_EASI_BASE + (slot << 24); 610 if (speed == ECARD_FAST) 611 ectcr |= 1 << slot; 612 break; 613 614 default: 615 break; 616 } 617 618 #ifdef IOMD_ECTCR 619 iomd_writeb(ectcr, IOMD_ECTCR); 620 #endif 621 return address; 622 } 623 624 static int ecard_prints(struct seq_file *m, ecard_t *ec) 625 { 626 seq_printf(m, " %d: %s ", ec->slot_no, ec->easi ? "EASI" : " "); 627 628 if (ec->cid.id == 0) { 629 struct in_chunk_dir incd; 630 631 seq_printf(m, "[%04X:%04X] ", 632 ec->cid.manufacturer, ec->cid.product); 633 634 if (!ec->card_desc && ec->cid.cd && 635 ecard_readchunk(&incd, ec, 0xf5, 0)) { 636 ec->card_desc = kmalloc(strlen(incd.d.string)+1, GFP_KERNEL); 637 638 if (ec->card_desc) 639 strcpy((char *)ec->card_desc, incd.d.string); 640 } 641 642 seq_printf(m, "%s\n", ec->card_desc ? ec->card_desc : "*unknown*"); 643 } else 644 seq_printf(m, "Simple card %d\n", ec->cid.id); 645 646 return 0; 647 } 648 649 static int ecard_devices_proc_show(struct seq_file *m, void *v) 650 { 651 ecard_t *ec = cards; 652 653 while (ec) { 654 ecard_prints(m, ec); 655 ec = ec->next; 656 } 657 return 0; 658 } 659 660 static int ecard_devices_proc_open(struct inode *inode, struct file *file) 661 { 662 return single_open(file, ecard_devices_proc_show, NULL); 663 } 664 665 static const struct file_operations bus_ecard_proc_fops = { 666 .owner = THIS_MODULE, 667 .open = ecard_devices_proc_open, 668 .read = seq_read, 669 .llseek = seq_lseek, 670 .release = single_release, 671 }; 672 673 static struct proc_dir_entry *proc_bus_ecard_dir = NULL; 674 675 static void ecard_proc_init(void) 676 { 677 proc_bus_ecard_dir = proc_mkdir("bus/ecard", NULL); 678 proc_create("devices", 0, proc_bus_ecard_dir, &bus_ecard_proc_fops); 679 } 680 681 #define ec_set_resource(ec,nr,st,sz) \ 682 do { \ 683 (ec)->resource[nr].name = dev_name(&ec->dev); \ 684 (ec)->resource[nr].start = st; \ 685 (ec)->resource[nr].end = (st) + (sz) - 1; \ 686 (ec)->resource[nr].flags = IORESOURCE_MEM; \ 687 } while (0) 688 689 static void __init ecard_free_card(struct expansion_card *ec) 690 { 691 int i; 692 693 for (i = 0; i < ECARD_NUM_RESOURCES; i++) 694 if (ec->resource[i].flags) 695 release_resource(&ec->resource[i]); 696 697 kfree(ec); 698 } 699 700 static struct expansion_card *__init ecard_alloc_card(int type, int slot) 701 { 702 struct expansion_card *ec; 703 unsigned long base; 704 int i; 705 706 ec = kzalloc(sizeof(ecard_t), GFP_KERNEL); 707 if (!ec) { 708 ec = ERR_PTR(-ENOMEM); 709 goto nomem; 710 } 711 712 ec->slot_no = slot; 713 ec->easi = type == ECARD_EASI; 714 ec->irq = 0; 715 ec->fiq = 0; 716 ec->dma = NO_DMA; 717 ec->ops = &ecard_default_ops; 718 719 dev_set_name(&ec->dev, "ecard%d", slot); 720 ec->dev.parent = NULL; 721 ec->dev.bus = &ecard_bus_type; 722 ec->dev.dma_mask = &ec->dma_mask; 723 ec->dma_mask = (u64)0xffffffff; 724 ec->dev.coherent_dma_mask = ec->dma_mask; 725 726 if (slot < 4) { 727 ec_set_resource(ec, ECARD_RES_MEMC, 728 PODSLOT_MEMC_BASE + (slot << 14), 729 PODSLOT_MEMC_SIZE); 730 base = PODSLOT_IOC0_BASE + (slot << 14); 731 } else 732 base = PODSLOT_IOC4_BASE + ((slot - 4) << 14); 733 734 #ifdef CONFIG_ARCH_RPC 735 if (slot < 8) { 736 ec_set_resource(ec, ECARD_RES_EASI, 737 PODSLOT_EASI_BASE + (slot << 24), 738 PODSLOT_EASI_SIZE); 739 } 740 741 if (slot == 8) { 742 ec_set_resource(ec, ECARD_RES_MEMC, NETSLOT_BASE, NETSLOT_SIZE); 743 } else 744 #endif 745 746 for (i = 0; i <= ECARD_RES_IOCSYNC - ECARD_RES_IOCSLOW; i++) 747 ec_set_resource(ec, i + ECARD_RES_IOCSLOW, 748 base + (i << 19), PODSLOT_IOC_SIZE); 749 750 for (i = 0; i < ECARD_NUM_RESOURCES; i++) { 751 if (ec->resource[i].flags && 752 request_resource(&iomem_resource, &ec->resource[i])) { 753 dev_err(&ec->dev, "resource(s) not available\n"); 754 ec->resource[i].end -= ec->resource[i].start; 755 ec->resource[i].start = 0; 756 ec->resource[i].flags = 0; 757 } 758 } 759 760 nomem: 761 return ec; 762 } 763 764 static ssize_t ecard_show_irq(struct device *dev, struct device_attribute *attr, char *buf) 765 { 766 struct expansion_card *ec = ECARD_DEV(dev); 767 return sprintf(buf, "%u\n", ec->irq); 768 } 769 770 static ssize_t ecard_show_dma(struct device *dev, struct device_attribute *attr, char *buf) 771 { 772 struct expansion_card *ec = ECARD_DEV(dev); 773 return sprintf(buf, "%u\n", ec->dma); 774 } 775 776 static ssize_t ecard_show_resources(struct device *dev, struct device_attribute *attr, char *buf) 777 { 778 struct expansion_card *ec = ECARD_DEV(dev); 779 char *str = buf; 780 int i; 781 782 for (i = 0; i < ECARD_NUM_RESOURCES; i++) 783 str += sprintf(str, "%08x %08x %08lx\n", 784 ec->resource[i].start, 785 ec->resource[i].end, 786 ec->resource[i].flags); 787 788 return str - buf; 789 } 790 791 static ssize_t ecard_show_vendor(struct device *dev, struct device_attribute *attr, char *buf) 792 { 793 struct expansion_card *ec = ECARD_DEV(dev); 794 return sprintf(buf, "%u\n", ec->cid.manufacturer); 795 } 796 797 static ssize_t ecard_show_device(struct device *dev, struct device_attribute *attr, char *buf) 798 { 799 struct expansion_card *ec = ECARD_DEV(dev); 800 return sprintf(buf, "%u\n", ec->cid.product); 801 } 802 803 static ssize_t ecard_show_type(struct device *dev, struct device_attribute *attr, char *buf) 804 { 805 struct expansion_card *ec = ECARD_DEV(dev); 806 return sprintf(buf, "%s\n", ec->easi ? "EASI" : "IOC"); 807 } 808 809 static struct device_attribute ecard_dev_attrs[] = { 810 __ATTR(device, S_IRUGO, ecard_show_device, NULL), 811 __ATTR(dma, S_IRUGO, ecard_show_dma, NULL), 812 __ATTR(irq, S_IRUGO, ecard_show_irq, NULL), 813 __ATTR(resource, S_IRUGO, ecard_show_resources, NULL), 814 __ATTR(type, S_IRUGO, ecard_show_type, NULL), 815 __ATTR(vendor, S_IRUGO, ecard_show_vendor, NULL), 816 __ATTR_NULL, 817 }; 818 819 820 int ecard_request_resources(struct expansion_card *ec) 821 { 822 int i, err = 0; 823 824 for (i = 0; i < ECARD_NUM_RESOURCES; i++) { 825 if (ecard_resource_end(ec, i) && 826 !request_mem_region(ecard_resource_start(ec, i), 827 ecard_resource_len(ec, i), 828 ec->dev.driver->name)) { 829 err = -EBUSY; 830 break; 831 } 832 } 833 834 if (err) { 835 while (i--) 836 if (ecard_resource_end(ec, i)) 837 release_mem_region(ecard_resource_start(ec, i), 838 ecard_resource_len(ec, i)); 839 } 840 return err; 841 } 842 EXPORT_SYMBOL(ecard_request_resources); 843 844 void ecard_release_resources(struct expansion_card *ec) 845 { 846 int i; 847 848 for (i = 0; i < ECARD_NUM_RESOURCES; i++) 849 if (ecard_resource_end(ec, i)) 850 release_mem_region(ecard_resource_start(ec, i), 851 ecard_resource_len(ec, i)); 852 } 853 EXPORT_SYMBOL(ecard_release_resources); 854 855 void ecard_setirq(struct expansion_card *ec, const struct expansion_card_ops *ops, void *irq_data) 856 { 857 ec->irq_data = irq_data; 858 barrier(); 859 ec->ops = ops; 860 } 861 EXPORT_SYMBOL(ecard_setirq); 862 863 void __iomem *ecardm_iomap(struct expansion_card *ec, unsigned int res, 864 unsigned long offset, unsigned long maxsize) 865 { 866 unsigned long start = ecard_resource_start(ec, res); 867 unsigned long end = ecard_resource_end(ec, res); 868 869 if (offset > (end - start)) 870 return NULL; 871 872 start += offset; 873 if (maxsize && end - start > maxsize) 874 end = start + maxsize; 875 876 return devm_ioremap(&ec->dev, start, end - start); 877 } 878 EXPORT_SYMBOL(ecardm_iomap); 879 880 /* 881 * Probe for an expansion card. 882 * 883 * If bit 1 of the first byte of the card is set, then the 884 * card does not exist. 885 */ 886 static int __init ecard_probe(int slot, unsigned irq, card_type_t type) 887 { 888 ecard_t **ecp; 889 ecard_t *ec; 890 struct ex_ecid cid; 891 void __iomem *addr; 892 int i, rc; 893 894 ec = ecard_alloc_card(type, slot); 895 if (IS_ERR(ec)) { 896 rc = PTR_ERR(ec); 897 goto nomem; 898 } 899 900 rc = -ENODEV; 901 if ((addr = __ecard_address(ec, type, ECARD_SYNC)) == NULL) 902 goto nodev; 903 904 cid.r_zero = 1; 905 ecard_readbytes(&cid, ec, 0, 16, 0); 906 if (cid.r_zero) 907 goto nodev; 908 909 ec->cid.id = cid.r_id; 910 ec->cid.cd = cid.r_cd; 911 ec->cid.is = cid.r_is; 912 ec->cid.w = cid.r_w; 913 ec->cid.manufacturer = ecard_getu16(cid.r_manu); 914 ec->cid.product = ecard_getu16(cid.r_prod); 915 ec->cid.country = cid.r_country; 916 ec->cid.irqmask = cid.r_irqmask; 917 ec->cid.irqoff = ecard_gets24(cid.r_irqoff); 918 ec->cid.fiqmask = cid.r_fiqmask; 919 ec->cid.fiqoff = ecard_gets24(cid.r_fiqoff); 920 ec->fiqaddr = 921 ec->irqaddr = addr; 922 923 if (ec->cid.is) { 924 ec->irqmask = ec->cid.irqmask; 925 ec->irqaddr += ec->cid.irqoff; 926 ec->fiqmask = ec->cid.fiqmask; 927 ec->fiqaddr += ec->cid.fiqoff; 928 } else { 929 ec->irqmask = 1; 930 ec->fiqmask = 4; 931 } 932 933 for (i = 0; i < ARRAY_SIZE(blacklist); i++) 934 if (blacklist[i].manufacturer == ec->cid.manufacturer && 935 blacklist[i].product == ec->cid.product) { 936 ec->card_desc = blacklist[i].type; 937 break; 938 } 939 940 ec->irq = irq; 941 942 /* 943 * hook the interrupt handlers 944 */ 945 if (slot < 8) { 946 irq_set_chip_and_handler(ec->irq, &ecard_chip, 947 handle_level_irq); 948 irq_set_chip_data(ec->irq, ec); 949 irq_clear_status_flags(ec->irq, IRQ_NOREQUEST); 950 } 951 952 #ifdef CONFIG_ARCH_RPC 953 /* On RiscPC, only first two slots have DMA capability */ 954 if (slot < 2) 955 ec->dma = 2 + slot; 956 #endif 957 958 for (ecp = &cards; *ecp; ecp = &(*ecp)->next); 959 960 *ecp = ec; 961 slot_to_expcard[slot] = ec; 962 963 rc = device_register(&ec->dev); 964 if (rc) 965 goto nodev; 966 967 return 0; 968 969 nodev: 970 ecard_free_card(ec); 971 nomem: 972 return rc; 973 } 974 975 /* 976 * Initialise the expansion card system. 977 * Locate all hardware - interrupt management and 978 * actual cards. 979 */ 980 static int __init ecard_init(void) 981 { 982 struct task_struct *task; 983 int slot, irqbase; 984 985 irqbase = irq_alloc_descs(-1, 0, 8, -1); 986 if (irqbase < 0) 987 return irqbase; 988 989 task = kthread_run(ecard_task, NULL, "kecardd"); 990 if (IS_ERR(task)) { 991 printk(KERN_ERR "Ecard: unable to create kernel thread: %ld\n", 992 PTR_ERR(task)); 993 irq_free_descs(irqbase, 8); 994 return PTR_ERR(task); 995 } 996 997 printk("Probing expansion cards\n"); 998 999 for (slot = 0; slot < 8; slot ++) { 1000 if (ecard_probe(slot, irqbase + slot, ECARD_EASI) == -ENODEV) 1001 ecard_probe(slot, irqbase + slot, ECARD_IOC); 1002 } 1003 1004 ecard_probe(8, 11, ECARD_IOC); 1005 1006 irq_set_chained_handler(IRQ_EXPANSIONCARD, ecard_irq_handler); 1007 1008 ecard_proc_init(); 1009 1010 return 0; 1011 } 1012 1013 subsys_initcall(ecard_init); 1014 1015 /* 1016 * ECARD "bus" 1017 */ 1018 static const struct ecard_id * 1019 ecard_match_device(const struct ecard_id *ids, struct expansion_card *ec) 1020 { 1021 int i; 1022 1023 for (i = 0; ids[i].manufacturer != 65535; i++) 1024 if (ec->cid.manufacturer == ids[i].manufacturer && 1025 ec->cid.product == ids[i].product) 1026 return ids + i; 1027 1028 return NULL; 1029 } 1030 1031 static int ecard_drv_probe(struct device *dev) 1032 { 1033 struct expansion_card *ec = ECARD_DEV(dev); 1034 struct ecard_driver *drv = ECARD_DRV(dev->driver); 1035 const struct ecard_id *id; 1036 int ret; 1037 1038 id = ecard_match_device(drv->id_table, ec); 1039 1040 ec->claimed = 1; 1041 ret = drv->probe(ec, id); 1042 if (ret) 1043 ec->claimed = 0; 1044 return ret; 1045 } 1046 1047 static int ecard_drv_remove(struct device *dev) 1048 { 1049 struct expansion_card *ec = ECARD_DEV(dev); 1050 struct ecard_driver *drv = ECARD_DRV(dev->driver); 1051 1052 drv->remove(ec); 1053 ec->claimed = 0; 1054 1055 /* 1056 * Restore the default operations. We ensure that the 1057 * ops are set before we change the data. 1058 */ 1059 ec->ops = &ecard_default_ops; 1060 barrier(); 1061 ec->irq_data = NULL; 1062 1063 return 0; 1064 } 1065 1066 /* 1067 * Before rebooting, we must make sure that the expansion card is in a 1068 * sensible state, so it can be re-detected. This means that the first 1069 * page of the ROM must be visible. We call the expansion cards reset 1070 * handler, if any. 1071 */ 1072 static void ecard_drv_shutdown(struct device *dev) 1073 { 1074 struct expansion_card *ec = ECARD_DEV(dev); 1075 struct ecard_driver *drv = ECARD_DRV(dev->driver); 1076 struct ecard_request req; 1077 1078 if (dev->driver) { 1079 if (drv->shutdown) 1080 drv->shutdown(ec); 1081 ec->claimed = 0; 1082 } 1083 1084 /* 1085 * If this card has a loader, call the reset handler. 1086 */ 1087 if (ec->loader) { 1088 req.fn = ecard_task_reset; 1089 req.ec = ec; 1090 ecard_call(&req); 1091 } 1092 } 1093 1094 int ecard_register_driver(struct ecard_driver *drv) 1095 { 1096 drv->drv.bus = &ecard_bus_type; 1097 1098 return driver_register(&drv->drv); 1099 } 1100 1101 void ecard_remove_driver(struct ecard_driver *drv) 1102 { 1103 driver_unregister(&drv->drv); 1104 } 1105 1106 static int ecard_match(struct device *_dev, struct device_driver *_drv) 1107 { 1108 struct expansion_card *ec = ECARD_DEV(_dev); 1109 struct ecard_driver *drv = ECARD_DRV(_drv); 1110 int ret; 1111 1112 if (drv->id_table) { 1113 ret = ecard_match_device(drv->id_table, ec) != NULL; 1114 } else { 1115 ret = ec->cid.id == drv->id; 1116 } 1117 1118 return ret; 1119 } 1120 1121 struct bus_type ecard_bus_type = { 1122 .name = "ecard", 1123 .dev_attrs = ecard_dev_attrs, 1124 .match = ecard_match, 1125 .probe = ecard_drv_probe, 1126 .remove = ecard_drv_remove, 1127 .shutdown = ecard_drv_shutdown, 1128 }; 1129 1130 static int ecard_bus_init(void) 1131 { 1132 return bus_register(&ecard_bus_type); 1133 } 1134 1135 postcore_initcall(ecard_bus_init); 1136 1137 EXPORT_SYMBOL(ecard_readchunk); 1138 EXPORT_SYMBOL(ecard_register_driver); 1139 EXPORT_SYMBOL(ecard_remove_driver); 1140 EXPORT_SYMBOL(ecard_bus_type); 1141