XPS SPI Core und SD Karte

[Christian F. (christianf)]

Moin !

Ich wollte mal fragen ob einer von Euch mittels Microblaze und XPS SPI 
Core eine SD Karte angesprochen bekommen hat.
Hab im Internet gefunden das es wohl nicht geht?


Gruss !

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Christian F. schrieb:
> Hab im Internet gefunden das es wohl nicht geht?
Und warum nicht?
> mittels Microblaze und XPS SPI Core eine SD Karte angesprochen
Nicht, dass ich diese spezielle Kombination am Laufen hätte, aber: warum 
sollte das nicht gehen? SPI an die Karte und ein uC zur Verwaltung. So 
wird das weltweit gemacht.

[Christian F. (christianf)]

Moin und zwar hat einer in seiner Bachelorarbeit sowas (bzw. genau das) 
in der Art gemacht.

Zitat :

Um die SD Karte anzusteuern, wurde ein eigener SPI-Core entwickelt, da 
der XPS-SPI-Core nicht
flexibel genug ist, um SD-Karten anzusprechen. Das erste Problem war, 
dass bei jedem
Sendevorgang automatisch der eingestellte Slave selektiert wurde. Die 
SD-Ansteuerung erfordert
aber jeweils am Anfang des zu sendenden Kommandos 8 Takte im inaktiven 
Zustand der SD-Karte.

Keine Ahnung woher er das hat, sind damit die ~80 Dummybytes am Anfang 
der Initialisierung gemeint?


Gruss !

[Christian F. (christianf)]

Also meine initialisierung sähe so aus (kleiner Ausschnitt eines 
Beispieles aus SP605 Board mit CF Karte ) :

/***************************** Include Files *********************************/

#include "xparameters.h"  /* EDK generated parameters */
#include "xspi.h"    /* SPI device driver */
#include "mb_interface.h"  /* Microblaze interface */
#include "xuartns550_l.h"


/*
 * The following constants map to the XPAR parameters created in the
 * xparameters.h file. They are defined here such that a user can easily
 * change all the needed parameters in one place.
 */
#define SPI_DEVICE_ID      XPAR_SPI_0_DEVICE_ID


static XSpi Spi;

/*
 * Initialize the SPI driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h.
*/

status = XSpi_Initialize(&Spi, SPI_DEVICE_ID);
if(Status != XST_SUCCESS) {\
     xil_printf("Failure INIT\r\n");
  return XST_FAILURE;
}


/*
   * Set the SPI device as a master and in manual slave select mode such
   * that the slave select signal does not toggle for every byte of a
   * transfer, this must be done before the slave select is set.
   */
  Status = XSpi_SetOptions(&Spi, XSP_MASTER_OPTION |
            XSP_MANUAL_SSELECT_OPTION);
  if(Status != XST_SUCCESS) {
       xil_printf("Failure Options\r\n");
    return XST_FAILURE;
  }

  /*
   * Select the STM flash device on the SPI bus, so that it can be
   * read and written using the SPI bus.
   */
  Status = XSpi_SetSlaveSelect(&Spi, STM_SPI_SELECT);
  if(Status != XST_SUCCESS) {
       xil_printf("Failure Slave Select\r\n");
    return XST_FAILURE;
  }

  /*
   * Start the SPI driver so that interrupts and the device are enabled.
   */
  XSpi_Start(&Spi);

[Christian F. (christianf)]

Moin.

Hab noch mal rumgewerkelt und es sollte in etwa so laufen:

Das einzige Problem das ich habe, ist die Xspi_transfer Funktion.

Sofern irgendeiner schon mit der Xspi.h Xspi.c Bibliothek gearbeitet 
hat. Bitte melden :)

#include "xparameters.h"  /* EDK generated parameters */
#include "xspi.h"    /* SPI device driver */
#include "mb_interface.h"  /* Microblaze interface */

/*
 * The following constants map to the XPAR parameters created in the
 * xparameters.h file. They are defined here such that a user can easily
 * change all the needed parameters in one place.
 */
#define SPI_DEVICE_ID      XPAR_SPI_0_DEVICE_ID

/*
 * The following constant defines the slave select signal that is used to
 * to select the Flash device on the SPI bus, this signal is typically
 * connected to the chip select of the device.
 */
#define STM_SPI_SELECT 0x01 // 0x01 for Port 1 CS ? 
/*
 * The instances to support the device drivers are global such that they
 * are initialized to zero each time the program runs. They could be local
 * but should at least be static so they are zeroed.
 */
static XSpi Spi;

  /*
   * Initialize the SPI driver so that it's ready to use,
   * specify the device ID that is generated in xparameters.h.
   */
  Status = XSpi_Initialize(&Spi, SPI_DEVICE_ID);
  if(Status != XST_SUCCESS) {\
       xil_printf("Failure INIT\r\n");
    return XST_FAILURE;
  }
  /*
   * Set the SPI device as a master and in manual slave select mode such
   * that the slave select signal does not toggle for every byte of a
   * transfer, this must be done before the slave select is set.
   */
  Status = XSpi_SetOptions(&Spi, XSP_MASTER_OPTION |
            XSP_MANUAL_SSELECT_OPTION);
  if(Status != XST_SUCCESS) {
       xil_printf("Failure Options\r\n");
    return XST_FAILURE;
  }
  /*
   * Select the device on the SPI bus, so that it can be
   * read and written using the SPI bus.
   */
  Status = XSpi_SetSlaveSelect(&Spi, STM_SPI_SELECT);
  if(Status != XST_SUCCESS) {
       xil_printf("Failure Slave Select\r\n");
    return XST_FAILURE;
  }
  /*
   * Start the SPI driver so that the device are enabled.
   */
  XSpi_Start(&Spi);

// ****************** SD INIT ***********************
  /*
   * Prepare the WriteBuffer.
   */
WriteBuffer[BYTE1] = CMD 0;
WriteBuffer[BYTE2] = Argument Byte 1/4;
WriteBuffer[BYTE3] = Argument Byte 2/4;
WriteBuffer[BYTE4] = Argument Byte 3/4;
WriteBuffer[BYTE5] = Argument Byte 4/4;
WriteBuffer[BYTE6] = CRC BYTE


/*
   * Initiate the Transfer.
   */
  TransferInProgress = TRUE;
  Status = XSpi_Transfer(SpiPtr, WriteBuffer, NULL,
        STM_WRITE_ENABLE_BYTES);
  if(Status != XST_SUCCESS) {
    xil_printf("Error in transfer\r\n");
    return XST_FAILURE;
  }

[Christian F. (christianf)]

Gibt es keinen hier der schonmal mit dem SPI Core versucht hat eine SD 
Karte anzusprechen? :(

Gruss !

[Duke Scarring (Gast)]

Christian F. schrieb:
> Gibt es keinen hier der schonmal mit dem SPI Core versucht hat eine SD
> Karte anzusprechen? :(
Sieht nicht so aus. Wo hängt es denn jetzt? Kann doch nicht so schwer 
sein. Machen hier im Forum doch alle mit AVR & Co.

Duke

[Christian F. (christianf)]

Naja das Problem das ich habe ist der SPI Core an sich und die Xilinx 
Treiber.

Es gibt vorgefertigte Funktionen wie z.B. XSpi_Transfer etc.

Allerdings ist es dort wohl kritisch in Sachen CS Signal.

Jedenfalls hat es wohl einer damit versucht :

Beitrag "SD Karte Spartan 3A XPS_SPI Modul"

Allerdings keine Ahnung wo genau da sein Problem ist.


Es hakt halt in der Timing Sache, also z.B. 80x Dummyclock Senden ohne 
die SD Karte anzusprechen.

Das geht wohl nicht, da die XSpi_Transfer funktion immer ein Slave 
eingestellt haben will und ansonsten:

/*
   * If configured as a master, be sure there is a slave select bit set
   * in the slave select register. If no slaves have been selected, the
   * value of the register will equal the mask.  When the device is in
   * loopback mode, however, no slave selects need be set.
   */
  if (ControlReg & XSP_CR_MASTER_MODE_MASK) {
    if ((ControlReg & XSP_CR_LOOPBACK_MASK) == 0) {
      if (InstancePtr->SlaveSelectReg ==
        InstancePtr->SlaveSelectMask) {
        if (GlobalIntrReg == TRUE) {
          /* Interrupt Mode of operation */
          XSpi_IntrGlobalEnable(InstancePtr);
        }
        return XST_SPI_NO_SLAVE;
      }
    }
  }

Es ist halt schwierig zu erklären, deswegen habe ich gehofft das einer 
sich mit dem XPS SPI Core auseinandergesetzt hat.

[Duke Scarring (Gast)]

Hast Du einen Simulator? Hast Du einen Logic-Analyzer?

Meine Simulation und die Messung auf der Hardware habe ich mal 
angehangen. Ich verwende allerdings den SPI-Flash (im 2x-Mode) auf dem 
SP601 Eval-Board. Angesteuert wird der Chip von spimctrl aus der grlib.

Ich hab das Ganze solange simuliert bis es gut aussah; dann erst bin ich 
auf die Hardware gegangen.

Duke

[Christian F. (christianf)]

Hi,

Ich könnte auf ChipScope zugreifen. Allerdings habe ich noch nie damit 
gearbeitet.

Ich glaub ich werde nicht die Xilinx Treiber nehmen, sondern die low 
level Treiber auf denen auch dieses Treiber existieren.

Dann schreibe ich direkt in die Register und erzeuge mir so eine low 
level Routine zum Schreiben/Lesen eines Bytes.

Das ist dazu die Beschreibung des Cores :

http://www.xilinx.com/support/documentation/ip_documentation/xps_spi.pdf

Nur versteh ich da nicht die Verwendung vom CS Signal (einfach SPISSR 
auf Low ? ) sowie den genauen Start eines Transferes ( Clock wird 
erzeugt? ).

" Angesteuert wird der Chip von spimctrl aus der grlib." = ? :)