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