/* $NetBSD: aupcmcia.c,v 1.13 2022/09/25 12:41:46 andvar Exp $ */

/*-
* Copyright (c) 2006 Itronix Inc.
* All rights reserved.
*
* Written by Garrett D'Amore for Itronix Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of Itronix Inc. may not be used to endorse
*    or promote products derived from this software without specific
*    prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/* #include "opt_pci.h" */
/* #include "pci.h" */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: aupcmcia.c,v 1.13 2022/09/25 12:41:46 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/intr.h>
#include <sys/device.h>

#include <dev/pcmcia/pcmciareg.h>
#include <dev/pcmcia/pcmciavar.h>
#include <dev/pcmcia/pcmciachip.h>

#include <mips/alchemy/include/au_himem_space.h>
#include <mips/alchemy/include/aubusvar.h>
#include <mips/alchemy/include/aureg.h>
#include <mips/alchemy/include/auvar.h>

#include <mips/alchemy/dev/aupcmciareg.h>
#include <mips/alchemy/dev/aupcmciavar.h>

/*
* Borrow PCMCIADEBUG for now.  Generally aupcmcia is the only PCMCIA
* host on these machines anyway.
*/
#ifdef  PCMCIADEBUG
int     aupcm_debug = 1;
#define DPRINTF(arg)    if (aupcm_debug) printf arg
#else
#define DPRINTF(arg)
#endif

/*
* And for information about mappings, etc. use this one.
*/
#ifdef  AUPCMCIANOISY
#define NOISY(arg)      printf arg
#else
#define NOISY(arg)
#endif

/*
* Note, we use prefix "aupcm" instead of "aupcmcia", even though our
* driver is the latter, mostly because my fingers have trouble typing
* the former.  "aupcm" should be sufficiently unique to avoid
* confusion.
*/

static int aupcm_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
   struct pcmcia_mem_handle *);
static void aupcm_mem_free(pcmcia_chipset_handle_t,
   struct pcmcia_mem_handle *);
static int aupcm_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t,
   bus_size_t, struct pcmcia_mem_handle *, bus_size_t *, int *);
static void aupcm_mem_unmap(pcmcia_chipset_handle_t, int);

static int aupcm_io_alloc(pcmcia_chipset_handle_t, bus_addr_t, bus_size_t,
   bus_size_t, struct pcmcia_io_handle *);
static void aupcm_io_free(pcmcia_chipset_handle_t, struct pcmcia_io_handle *);
static int aupcm_io_map(pcmcia_chipset_handle_t, int, bus_addr_t,
   bus_size_t, struct pcmcia_io_handle *, int *);
static void aupcm_io_unmap(pcmcia_chipset_handle_t, int);
static void *aupcm_intr_establish(pcmcia_chipset_handle_t,
   struct pcmcia_function *, int, int (*)(void *), void *);
static void aupcm_intr_disestablish(pcmcia_chipset_handle_t, void *);

static void aupcm_slot_enable(pcmcia_chipset_handle_t);
static void aupcm_slot_disable(pcmcia_chipset_handle_t);
static void aupcm_slot_settype(pcmcia_chipset_handle_t, int);

static int aupcm_match(device_t, struct cfdata *, void *);
static void aupcm_attach(device_t, device_t, void *);

static void aupcm_event_thread(void *);
static int aupcm_card_intr(void *);
static void aupcm_softintr(void *);
static int aupcm_print(void *, const char *);

struct aupcm_slot {
       struct aupcm_softc      *as_softc;
       int                     as_slot;
       int                     as_status;
       int                     as_enabled;
       int                     (*as_intr)(void *);
       int                     as_card_irq;
       int                     as_status_irq;
       void                    *as_intrarg;
       void                    *as_softint;
       void                    *as_hardint;
       const char              *as_name;
       bus_addr_t              as_offset;
       struct mips_bus_space   as_iot;
       struct mips_bus_space   as_attrt;
       struct mips_bus_space   as_memt;
       void                    *as_wins[AUPCMCIA_NWINS];

       device_t                as_pcmcia;
};

/* this structure needs to be exposed... */
struct aupcm_softc {
       device_t                sc_dev;
       pcmcia_chipset_tag_t    sc_pct;

       void                    (*sc_slot_enable)(int);
       void                    (*sc_slot_disable)(int);
       int                     (*sc_slot_status)(int);

       paddr_t                 sc_base;

       int                     sc_wake;
       lwp_t                   *sc_thread;

       int                     sc_nslots;
       struct aupcm_slot       sc_slots[AUPCMCIA_NSLOTS];
};

static struct pcmcia_chip_functions aupcm_functions = {
       aupcm_mem_alloc,
       aupcm_mem_free,
       aupcm_mem_map,
       aupcm_mem_unmap,

       aupcm_io_alloc,
       aupcm_io_free,
       aupcm_io_map,
       aupcm_io_unmap,

       aupcm_intr_establish,
       aupcm_intr_disestablish,

       aupcm_slot_enable,
       aupcm_slot_disable,
       aupcm_slot_settype,
};

static  struct mips_bus_space   aupcm_memt;

CFATTACH_DECL_NEW(aupcmcia, sizeof (struct aupcm_softc),
   aupcm_match, aupcm_attach, NULL, NULL);

int
aupcm_match(device_t parent, struct cfdata *cf, void *aux)
{
       struct aubus_attach_args        *aa = aux;
       static int                      found = 0;

       if (found)
               return 0;

       if (strcmp(aa->aa_name, "aupcmcia") != 0)
               return 0;

       found = 1;

       return 1;
}

void
aupcm_attach(device_t parent, device_t self, void *aux)
{
       /* struct aubus_attach_args     *aa = aux; */
       struct aupcm_softc              *sc = device_private(self);
       static int                      done = 0;
       int                             slot;
       struct aupcmcia_machdep         *md;

       sc->sc_dev = self;

       /* initialize bus space */
       if (done) {
               /* there can be only one. */
               return;
       }

       done = 1;
       /*
        * PCMCIA memory can live within pretty much the entire 32-bit
        * space, modulo 64 MB wraps.  We don't have to support coexisting
        * DMA.
        */
       au_himem_space_init(&aupcm_memt, "pcmciamem",
           PCMCIA_BASE, AUPCMCIA_ATTR_OFFSET, 0xffffffff,
           AU_HIMEM_SPACE_LITTLE_ENDIAN);

       if ((md = aupcmcia_machdep()) == NULL) {
               aprint_error(": unable to get machdep structure\n");
               return;
       }

       sc->sc_nslots = md->am_nslots;
       sc->sc_slot_enable = md->am_slot_enable;
       sc->sc_slot_disable = md->am_slot_disable;
       sc->sc_slot_status = md->am_slot_status;

       aprint_normal(": Alchemy PCMCIA, %d slots\n", sc->sc_nslots);
       aprint_naive("\n");

       sc->sc_pct = (pcmcia_chipset_tag_t)&aupcm_functions;

       for (slot = 0; slot < sc->sc_nslots; slot++) {
               struct aupcm_slot               *sp;
               struct pcmciabus_attach_args    paa;

               sp = &sc->sc_slots[slot];
               sp->as_softc = sc;

               sp->as_slot = slot;
               sp->as_name = md->am_slot_name(slot);
               sp->as_offset = md->am_slot_offset(slot);
               sp->as_card_irq = md->am_slot_irq(slot, AUPCMCIA_IRQ_CARD);
               sp->as_status_irq = md->am_slot_irq(slot,
                   AUPCMCIA_IRQ_INSERT);

               au_himem_space_init(&sp->as_attrt, "pcmciaattr",
                   PCMCIA_BASE + sp->as_offset + AUPCMCIA_ATTR_OFFSET,
                   0, AUPCMCIA_MAP_SIZE, AU_HIMEM_SPACE_LITTLE_ENDIAN);

               au_himem_space_init(&sp->as_memt, "pcmciamem",
                   PCMCIA_BASE + sp->as_offset + AUPCMCIA_MEM_OFFSET,
                   0, AUPCMCIA_MAP_SIZE, AU_HIMEM_SPACE_LITTLE_ENDIAN);

               au_himem_space_init(&sp->as_iot, "pcmciaio",
                   PCMCIA_BASE + sp->as_offset + AUPCMCIA_IO_OFFSET,
                   0, AUPCMCIA_MAP_SIZE,
                   AU_HIMEM_SPACE_LITTLE_ENDIAN | AU_HIMEM_SPACE_IO);

               sp->as_status = 0;

               paa.paa_busname = "pcmcia";
               paa.pct = sc->sc_pct;
               paa.pch = (pcmcia_chipset_handle_t)sp;

               sp->as_pcmcia = config_found(self, &paa, aupcm_print,
                   CFARGS_NONE);

               /* if no pcmcia, make sure slot is powered down */
               if (sp->as_pcmcia == NULL) {
                       aupcm_slot_disable(sp);
                       continue;
               }

               /* this makes sure we probe the slot */
               sc->sc_wake |= (1 << slot);
       }

       /*
        * XXX: this would be an excellent time time to establish a handler
        * for the card insertion interrupt, but that's edge triggered, and
        * au_icu.c won't support it right now.  We poll in the event thread
        * for now.  Start by initializing it now.
        */
       if (kthread_create(PRI_NONE, 0, NULL, aupcm_event_thread, sc,
           &sc->sc_thread, "%s", device_xname(sc->sc_dev)) != 0)
               panic("%s: unable to create event kthread",
                   device_xname(sc->sc_dev));
}

int
aupcm_print(void *aux, const char *pnp)
{
       struct pcmciabus_attach_args *paa = aux;
       struct aupcm_slot *sp = paa->pch;

       printf(" socket %d irq %d, %s", sp->as_slot, sp->as_card_irq,
           sp->as_name);

       return (UNCONF);
}

void *
aupcm_intr_establish(pcmcia_chipset_handle_t pch,
   struct pcmcia_function *pf, int level, int (*handler)(void *), void *arg)
{
       struct aupcm_slot       *sp = (struct aupcm_slot *)pch;
       int                     s;

       /*
        * Hmm. perhaps this intr should be a list. well, PCMCIA
        * devices generally only have one interrupt, and so should
        * generally have only one handler.  So we leave it for now.
        * (Other PCMCIA bus drivers do it this way.)
        */
       sp->as_intr = handler;
       sp->as_intrarg = arg;
       sp->as_softint = softint_establish(IPL_SOFTNET, aupcm_softintr, sp);

       /* set up hard interrupt handler for the card IRQs */
       s = splhigh();
       sp->as_hardint = au_intr_establish(sp->as_card_irq, 0,
           IPL_TTY, IST_LEVEL_LOW, aupcm_card_intr, sp);
       /* if card is not powered up, then leave the IRQ masked */
       if (!sp->as_enabled) {
               au_intr_disable(sp->as_card_irq);
       }
       splx(s);

       return (sp->as_softint);
}

void
aupcm_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
{
       struct aupcm_slot *sp = (struct aupcm_slot *)pch;

       KASSERT(sp->as_softint == ih);
       /* KASSERT(sp->as_hardint); */
       /* set up hard interrupt handler for the card IRQs */

       au_intr_disestablish(sp->as_hardint);
       sp->as_hardint = 0;

       softint_disestablish(ih);
       sp->as_softint = 0;
       sp->as_intr = NULL;
       sp->as_intrarg = NULL;
}

/*
* FYI: Hot detach of PCMCIA is supposedly safe because H/W doesn't
* fault on accesses to missing hardware.
*/
void
aupcm_event_thread(void *arg)
{
       struct aupcm_softc      *sc = arg;
       struct aupcm_slot       *sp;
       int                     s, i, attach, detach;

       for (;;) {
               s = splhigh();
               if (sc->sc_wake == 0) {
                       splx(s);
                       /*
                        * XXX: Currently, the au_icu.c lacks support
                        * for edge-triggered interrupts.  So we
                        * cannot really use the status change
                        * interrupts.  For now we poll (once per sec).
                        * FYI, Linux does it this way, and they *do*
                        * have support for edge triggered interrupts.
                        * Go figure.
                        */
                       tsleep(&sc->sc_wake, PWAIT, "aupcm_event", hz);
                       s = splhigh();
               }
               sc->sc_wake = 0;

               attach = detach = 0;
               for (i = 0; i < sc->sc_nslots; i++) {
                       sp = &sc->sc_slots[i];

                       if (sc->sc_slot_status(sp->as_slot) != 0) {
                               if (!sp->as_status) {
                                       DPRINTF(("%s: card %d insertion\n",
                                           device_xname(sc->sc_dev), i));
                                       attach |= (1 << i);
                                       sp->as_status = 1;
                               }
                       } else {
                               if (sp->as_status) {
                                       DPRINTF(("%s: card %d removal\n",
                                           device_xname(sc->sc_dev), i));
                                       detach |= (1 << i);
                                       sp->as_status = 0;
                               }
                       }
               }
               splx(s);

               for (i = 0; i < sc->sc_nslots; i++) {
                       sp = &sc->sc_slots[i];

                       if (detach & (1 << i)) {
                               aupcm_slot_disable(sp);
                               pcmcia_card_detach(sp->as_pcmcia, DETACH_FORCE);
                       } else if (attach & (1 << i)) {
                               /*
                                * until the function is enabled, don't
                                * honor interrupts
                                */
                               sp->as_enabled = 0;
                               au_intr_disable(sp->as_card_irq);
                               pcmcia_card_attach(sp->as_pcmcia);
                       }
               }
       }
}

#if 0
void
aupcm_status_intr(void *arg)
{
       int s;
       struct aupcm_softc *sc = arg;

       s = splhigh();

       /* kick the status thread so it does its bit */
       sc->sc_wake = 1;
       wakeup(&sc->sc_wake);

       splx(s);
}
#endif

int
aupcm_card_intr(void *arg)
{
       struct aupcm_slot *sp = arg;

       /* disable the hard interrupt for now */
       au_intr_disable(sp->as_card_irq);

       if (sp->as_intr != NULL) {
               softint_schedule(sp->as_softint);
       }

       return 1;
}

void
aupcm_softintr(void *arg)
{
       struct aupcm_slot       *sp = arg;
       int                     s;

       sp->as_intr(sp->as_intrarg);

       s = splhigh();

       if (sp->as_intr && sp->as_enabled) {
               au_intr_enable(sp->as_card_irq);
       }

       splx(s);
}

void
aupcm_slot_enable(pcmcia_chipset_handle_t pch)
{
       struct aupcm_slot       *sp = (struct aupcm_slot *)pch;
       int                     s;

       /* no interrupts while we reset the card, please */
       if (sp->as_intr)
               au_intr_disable(sp->as_card_irq);

       /*
        * XXX: should probably lock to make sure slot_disable and
        * enable not called together.  However, i believe that the
        * event thread basically serializes them anyway.
        */

       sp->as_softc->sc_slot_enable(sp->as_slot);
       /* card is powered up now, honor device interrupts */

       s = splhigh();
       sp->as_enabled = 1;
       if (sp->as_intr)
               au_intr_enable(sp->as_card_irq);
       splx(s);
}

void
aupcm_slot_disable(pcmcia_chipset_handle_t pch)
{
       struct aupcm_slot       *sp = (struct aupcm_slot *)pch;
       int                     s;

       s = splhigh();
       au_intr_disable(sp->as_card_irq);
       sp->as_enabled = 0;
       splx(s);

       sp->as_softc->sc_slot_disable(sp->as_slot);
}

void
aupcm_slot_settype(pcmcia_chipset_handle_t pch, int type)
{
       /* we do nothing now : type == PCMCIA_IFTYPE_IO */
}

int
aupcm_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
   struct pcmcia_mem_handle *pcmh)
{
       pcmh->memt = NULL;
       pcmh->size = pcmh->realsize = size;
       pcmh->addr = 0;
       pcmh->mhandle = 0;

       return 0;
}

void
aupcm_mem_free(pcmcia_chipset_handle_t pch, struct pcmcia_mem_handle *pcmh)
{
       /* nothing to do */
}

int
aupcm_mem_map(pcmcia_chipset_handle_t pch, int kind, bus_addr_t addr,
   bus_size_t size, struct pcmcia_mem_handle *pcmh, bus_size_t *offsetp,
   int *windowp)
{
       struct aupcm_slot       *sp = (struct aupcm_slot *)pch;
       int                     win, err;
       int                     s;

       s = splhigh();
       for (win = 0; win < AUPCMCIA_NWINS; win++) {
               if (sp->as_wins[win] == NULL) {
                       sp->as_wins[win] = pcmh;
                       break;
               }
       }
       splx(s);

       if (win >= AUPCMCIA_NWINS) {
               return ENOMEM;
       }

       if (kind & PCMCIA_MEM_ATTR) {
               pcmh->memt = &sp->as_attrt;
               NOISY(("mapping ATTR addr %x size %x\n", (uint32_t)addr,
                   (uint32_t)size));
       } else {
               pcmh->memt = &sp->as_memt;
               NOISY(("mapping MEMORY addr %x size %x\n", (uint32_t)addr,
                         (uint32_t)size));
       }

       if ((size + addr) > (64 * 1024 * 1024))
               return EINVAL;

       pcmh->size = size;

       err = bus_space_map(pcmh->memt, addr, size, 0, &pcmh->memh);
       if (err != 0) {
               sp->as_wins[win] = NULL;
               return err;
       }
       *offsetp = 0;
       *windowp = win;

       return 0;
}

void
aupcm_mem_unmap(pcmcia_chipset_handle_t pch, int win)
{
       struct aupcm_slot               *sp = (struct aupcm_slot *)pch;
       struct pcmcia_mem_handle        *pcmh;

       pcmh = (struct pcmcia_mem_handle *)sp->as_wins[win];
       sp->as_wins[win] = NULL;

       NOISY(("memory umap virtual %x\n", (uint32_t)pcmh->memh));
       bus_space_unmap(pcmh->memt, pcmh->memh, pcmh->size);
       pcmh->memt = NULL;
}

int
aupcm_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start,
   bus_size_t size, bus_size_t align, struct pcmcia_io_handle *pih)
{
       struct aupcm_slot       *sp = (struct aupcm_slot *)pch;
       bus_space_handle_t      bush;
       int                     err;

       pih->iot = &sp->as_iot;
       pih->size = size;
       pih->flags = 0;

       /*
        * start from the initial offset - this gets us a slot
        * specific address, while still leaving the addresses more or
        * less zero-based which is required for x86-style device
        * drivers.
        */
       err = bus_space_alloc(pih->iot, start, 0x100000,
           size, align, 0, 0, &pih->addr, &bush);
       NOISY(("start = %x, addr = %x, size = %x, bush = %x\n",
                 (uint32_t)start, (uint32_t)pih->addr, (uint32_t)size,
                 (uint32_t)bush));

       /* and we convert it back */
       if (err == 0) {
               pih->ihandle = (void *)bush;
       }

       return (err);
}

void
aupcm_io_free(pcmcia_chipset_handle_t pch, struct pcmcia_io_handle *pih)
{
       bus_space_free(pih->iot, (bus_space_handle_t)pih->ihandle,
           pih->size);
}

int
aupcm_io_map(pcmcia_chipset_handle_t pch, int width, bus_addr_t offset,
   bus_size_t size, struct pcmcia_io_handle *pih, int *windowp)
{
       int                     err;

       err = bus_space_subregion(pih->iot, (bus_space_handle_t)pih->ihandle,
           offset, size, &pih->ioh);
       NOISY(("io map offset = %x, size = %x, ih = %x, hdl=%x\n",
                 (uint32_t)offset, (uint32_t)size,
                 (uint32_t)pih->ihandle, (uint32_t)pih->ioh));

       return err;
}

void
aupcm_io_unmap(pcmcia_chipset_handle_t pch, int win)
{
       /* We mustn't unmap/free subregion bus space! */
       NOISY(("io unmap\n"));
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.