spi_mmc_npl.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005 by egnite Software GmbH
 * Copyright (C) 2010 by egnite 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 THE COPYRIGHT HOLDERS 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 THE
 * COPYRIGHT OWNER 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 <cfg/mmci.h>

#include <dev/npl.h>
#include <dev/mmcard.h>
#include <dev/spibus.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


static int NplMmc0Reset(NUTDEVICE * dev);
static void NplMmc0Led(int mode);
static int NplMmc0Power(int mode);

static MEMCARDSUPP mcsSpiMmc0Npl = {
    0,              
    0,              
    NplMmc0Reset,   
    NplMmc0Led,     
    NplMmc0Power,   
};

static void NplMmc0Insertion(void *arg)
{
    MEMCARDSUPP *mcs = (MEMCARDSUPP *) arg;

    /* Set the change flag. */
    mcs->mcs_cf = 1;
    /* Set the card detect flag. */
    mcs->mcs_sf = NUTMC_SF_CD;
    /* Set the card write protect flag. */
    if (inw(NPL_SLR) & NPL_LANWAKEUP) {
        mcs->mcs_sf |= NUTMC_SF_WP;
    }

    /* Disable insert and enable remove interrupts. */
    NplIrqDisable(&sig_MMCD);
    NplIrqEnable(&sig_NMMCD);
}

static void NplMmcRemoval(void *arg)
{
    MEMCARDSUPP *mcs = (MEMCARDSUPP *) arg;

    /* Set the change flag. */
    mcs->mcs_cf = 1;
    /* Clear card detect and write protect flags. */
    mcs->mcs_sf = 0;

    /* Disable remove and enable insert interrupts. */
    NplIrqDisable(&sig_NMMCD);
    NplIrqEnable(&sig_MMCD);
}

static void NplMmc0Led(int mode)
{
#ifdef NPL_MMC0_ULED
    if (mode == NUTMC_IND_OFF) {
        outb(NPL_XER, inb(NPL_XER) | NPL_USRLED);
    } else {
        outb(NPL_XER, inb(NPL_XER) & ~NPL_USRLED);
    }
#endif
}

static int NplMmc0Power(int mode)
{
    return -1;
}

static int NplMmc0Reset(NUTDEVICE * dev)
{
    uint_fast8_t i;

    /* Deactivate negated chip select. */
    outb(NPL_XER, inb(NPL_XER) | NPL_MMCS);
    /* Perform 80 clock cycles. */
    for (i = 0; i < 10; i++) {
        outb(NPL_MMCDR, 0xFF);
        while ((inb(NPL_SLR) & NPL_MMCREADY) == 0);
        inb(NPL_MMCDR);
    }
    /* Switch LED off. */
    NplMmc0Led(NUTMC_IND_OFF);

    return 0;
}

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

    NplMmc0Reset(dev);

    /* Register card detection interrupts. */
    rc = NplRegisterIrqHandler(&sig_MMCD, NplMmc0Insertion, dev->dev_dcb);
    if (rc == 0) {
        rc = NplRegisterIrqHandler(&sig_NMMCD, NplMmcRemoval, dev->dev_dcb);
        if (rc == 0) {
            NplIrqEnable(&sig_MMCD);
            /* Initialize the SPI interface. */
            rc = SpiMmcInit(dev);
        }
    }
    return rc;
}

NUTSPINODE nodeSpiMmc0Npl = {
    NULL,           
    NULL,           
    NPL_MMC_CLOCK,  
    SPI_MODE_0,     
    8,              
    0               
};

NUTDEVICE devNplSpiMmc0 = {
    0,                  
    {'M', 'M', 'C', '0', 0, 0, 0, 0, 0}
    ,                   
    0,                  
    0,                  
    0,                  
    &nodeSpiMmc0Npl,    
    &mcsSpiMmc0Npl,     
    SpiMmc0NplInit,     
    SpiMmcIOCtl,        
    SpiMmcBlockRead,    
    SpiMmcBlockWrite,   
#ifdef __HARVARD_ARCH__
    SpiMmcBlockWrite_P, 
#endif
    SpiMmcMount,        
    SpiMmcUnmount,      
    0                   
};