nplmmc.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005 by egnite Software GmbH. All rights reserved.
 *
 * 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. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``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 EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS 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.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/clock.h>

#include <sys/event.h>

#include <dev/twif.h>
#include <dev/npl.h>
#include <dev/mmcard.h>
#include <dev/cy2239x.h>
#include <dev/nplmmc.h>

#if !defined(NPL_MMC_CLOCK) || (NPL_MMC_CLOCK < 1000)
#undef NPL_MMC_CLOCK
#define NPL_MMC_CLOCK   12500000
#endif

#if 0
/* Use for local debugging. */
#define NUTDEBUG
#include <stdio.h>
#endif


#ifndef I2C_SLA_PLL
#define I2C_SLA_PLL     0x69
#endif

typedef struct _MMCDCB {
    int dcb_avail;              
    int dcb_changed;            
} MMCDCB;

static MMCDCB mmc0_dcb;

static int NplMmCard0Init(void)
{
    mmc0_dcb.dcb_changed = 0;
    if (mmc0_dcb.dcb_avail) {
        return 0;
    }
    return -1;
}

static int NplMmCard0Select(int on)
{
    int rc = (inb(NPL_XER) & NPL_MMCS) == NPL_MMCS;

    if (on == 1) {
        outb(NPL_XER, inb(NPL_XER) & ~NPL_MMCS);
    } else if (on == 0) {
        outb(NPL_XER, inb(NPL_XER) | NPL_MMCS);
    }
    return rc;
}

static uint8_t NplMmCard0Io(uint8_t val)
{
    uint8_t rc;
    unsigned int tmo = 255;

    while ((inb(NPL_SLR) & NPL_MMCREADY) == 0) {
        if (--tmo == 0) {
            break;
        }
    }

    _NOP(); _NOP(); _NOP(); _NOP();
    rc = inb(NPL_MMCDR);
    _NOP(); _NOP(); _NOP(); _NOP();
    outb(NPL_MMCDR, val);
    _NOP(); _NOP(); _NOP(); _NOP();

#ifdef NUTDEBUG
    putchar('[');
    if (rc != 0xFF) {
        printf("r%02X", rc);
    } else if (val != 0xFF) {
        printf("s%02X", val);
    }
    putchar(']');
#endif

    return rc;
}

int NplMmCard0Avail(void)
{
    if (mmc0_dcb.dcb_avail) {
        if (mmc0_dcb.dcb_changed) {
            return 2;
        }
        return 1;
    }
    return 0;
}

int NplMmCard0WrProt(void)
{
    return 0;
}

static void NplMmCard0InsIrq(void *arg)
{
    NplIrqDisable(&sig_MMCD);
    mmc0_dcb.dcb_avail = 1;
    mmc0_dcb.dcb_changed = 1;
    NplIrqEnable(&sig_NMMCD);
}

static void NplMmCard0RemIrq(void *arg)
{
    NplIrqDisable(&sig_NMMCD);
    mmc0_dcb.dcb_avail = 0;
    NplIrqEnable(&sig_MMCD);
}

static int NplMmcIfcInit(NUTDEVICE * dev)
{
    int rc;

    /* Disable card select. */
    NplMmCard0Select(0);

#if defined(NUT_PLL_NPLCLK1)
    {
        uint32_t val;

        /* Query the PLL number routed to Clock B. */
        val = Cy2239xGetPll(NUT_PLL_NPLCLK1);
        /* Get the frequency of this PLL. */
        val = Cy2239xPllGetFreq((int)val, 7);
        /* Calculate the required divider value. */
        val = (val + NPL_MMC_CLOCK - 10) / NPL_MMC_CLOCK;
        /* 
         * Not sure about the Cy-routines. The DIVSEL bit specifies which
         * divider is used, which is indirectly connected to S2, which is
         * high by default. For now set both dividers. 
         */
        if (Cy2239xSetDivider(NUT_PLL_NPLCLK1, 1, (int)val)) {
            return -1;
        }
        if (Cy2239xSetDivider(NUT_PLL_NPLCLK1, 0, (int)val)) {
            return -1;
        }
    }
#endif

    /* Initialize the CPLD SPI register. */
    inb(NPL_MMCDR);
    outb(NPL_MMCDR, 0xFF);

    /* Register card detection interrupts. */
    if ((rc = NplRegisterIrqHandler(&sig_MMCD, NplMmCard0InsIrq, 0)) == 0) {
        rc = NplRegisterIrqHandler(&sig_NMMCD, NplMmCard0RemIrq, 0);
    }
    NplIrqEnable(&sig_MMCD);

    return MmCardDevInit(dev);
}

static MMCIFC mmc0_ifc = {
    NplMmCard0Init,             
    NplMmCard0Io,               
    NplMmCard0Select,           
    NplMmCard0Avail,            
    NplMmCard0WrProt            
};

NUTDEVICE devNplMmc0 = {
    0,                          
    {'M', 'M', 'C', '0', 0, 0, 0, 0, 0}
    ,                           
    0,                          
    0,                          
    0,                          
    &mmc0_ifc,                  
    &mmc0_dcb,                  
    NplMmcIfcInit,              
    MmCardIOCtl,                
    MmCardBlockRead,            
    MmCardBlockWrite,           
#ifdef __HARVARD_ARCH__
    MmCardBlockWrite_P,         
#endif
    MmCardMount,                
    MmCardUnmount,              
    0                           
};