Contiki-NG
xmem.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2006, Swedish Institute of Computer Science
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the Institute nor the names of its contributors
14  * may be used to endorse or promote products derived from this software
15  * without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  */
30 
31 /**
32  * \file
33  * Device driver for the ST M25P16 40MHz 1Mbyte external memory.
34  * \author
35  * Björn Grönvall <bg@sics.se>
36  * Enric M. Calvo <ecalvo@zolertia.com>
37  *
38  * Data is written bit inverted (~-operator) to flash so that
39  * unwritten data will read as zeros (UNIX style).
40  */
41 
42 #include <stdio.h>
43 #include <string.h>
44 
45 #include "contiki.h"
46 #include "dev/spi-legacy.h"
47 #include "dev/xmem.h"
48 #include "dev/watchdog.h"
49 
50 #if 1
51 #define PRINTF(...) printf(__VA_ARGS__)
52 #else
53 #define PRINTF(...) do {} while (0)
54 #endif
55 
56 #define SPI_FLASH_INS_WREN 0x06
57 #define SPI_FLASH_INS_WRDI 0x04
58 #define SPI_FLASH_INS_RDSR 0x05
59 #define SPI_FLASH_INS_WRSR 0x01
60 #define SPI_FLASH_INS_READ 0x03
61 #define SPI_FLASH_INS_FAST_READ 0x0b
62 #define SPI_FLASH_INS_PP 0x02
63 #define SPI_FLASH_INS_SE 0xd8
64 #define SPI_FLASH_INS_BE 0xc7
65 #define SPI_FLASH_INS_DP 0xb9
66 #define SPI_FLASH_INS_RES 0xab
67 /*---------------------------------------------------------------------------*/
68 static void
69 write_enable(void)
70 {
71  int s;
72 
73  s = splhigh();
74  SPI_FLASH_ENABLE();
75 
76  SPI_WRITE(SPI_FLASH_INS_WREN);
77 
78  SPI_FLASH_DISABLE();
79  splx(s);
80 }
81 /*---------------------------------------------------------------------------*/
82 static unsigned
83 read_status_register(void)
84 {
85  unsigned char u;
86 
87  int s;
88 
89  s = splhigh();
90  SPI_FLASH_ENABLE();
91 
92 
93  SPI_WRITE(SPI_FLASH_INS_RDSR);
94 
95  SPI_FLUSH();
96  SPI_READ(u);
97 
98  SPI_FLASH_DISABLE();
99  splx(s);
100 
101  return u;
102 }
103 /*---------------------------------------------------------------------------*/
104 /*
105  * Wait for a write/erase operation to finish.
106  */
107 static unsigned
108 wait_ready(void)
109 {
110  unsigned u;
111  do {
112  u = read_status_register();
114  } while(u & 0x01); /* WIP=1, write in progress */
115  return u;
116 }
117 /*---------------------------------------------------------------------------*/
118 /*
119  * Erase 64k bytes of data. It takes about 1s before WIP goes low!
120  */
121 static void
122 erase_sector(unsigned long offset)
123 {
124  int s;
125  wait_ready();
126 
127  write_enable();
128 
129  s = splhigh();
130  SPI_FLASH_ENABLE();
131 
132  SPI_WRITE_FAST(SPI_FLASH_INS_SE);
133  SPI_WRITE_FAST(offset >> 16); /* MSB */
134  SPI_WRITE_FAST(offset >> 8);
135  SPI_WRITE_FAST(offset >> 0); /* LSB */
136  SPI_WAITFORTx_ENDED();
137 
138  SPI_FLASH_DISABLE();
139  splx(s);
140 }
141 /*---------------------------------------------------------------------------*/
142 /*
143  * Initialize external flash *and* SPI bus!
144  */
145 void
146 xmem_init(void)
147 {
148  spi_init();
149 
150  P4DIR |= BV(FLASH_CS); /* Unnecessary for Zolertia Z1 | BV(FLASH_PWR); */
151  P5DIR |= BV(FLASH_HOLD); /* In P5 for Z1 */
152 
153  SPI_FLASH_DISABLE(); /* Unselect flash. */
154  SPI_FLASH_UNHOLD();
155 }
156 /*---------------------------------------------------------------------------*/
157 int
158 xmem_pread(void *_p, int size, unsigned long offset)
159 {
160  unsigned char *p = _p;
161  const unsigned char *end = p + size;
162  int s;
163  wait_ready();
164 
165  s = splhigh();
166  SPI_FLASH_ENABLE();
167 
168  SPI_WRITE_FAST(SPI_FLASH_INS_READ);
169  SPI_WRITE_FAST(offset >> 16); /* MSB */
170  SPI_WRITE_FAST(offset >> 8);
171  SPI_WRITE_FAST(offset >> 0); /* LSB */
172  SPI_WAITFORTx_ENDED();
173 
174  SPI_FLUSH();
175  for(; p < end; p++) {
176  unsigned char u;
177  SPI_READ(u);
178  *p = ~u;
179  }
180 
181  SPI_FLASH_DISABLE();
182  splx(s);
183 
184  return size;
185 }
186 /*---------------------------------------------------------------------------*/
187 static const unsigned char *
188 program_page(unsigned long offset, const unsigned char *p, int nbytes)
189 {
190  const unsigned char *end = p + nbytes;
191  int s;
192 
193  wait_ready();
194 
195  write_enable();
196 
197  s = splhigh();
198  SPI_FLASH_ENABLE();
199 
200  SPI_WRITE_FAST(SPI_FLASH_INS_PP);
201  SPI_WRITE_FAST(offset >> 16); /* MSB */
202  SPI_WRITE_FAST(offset >> 8);
203  SPI_WRITE_FAST(offset >> 0); /* LSB */
204 
205  for(; p < end; p++) {
206  SPI_WRITE_FAST(~*p);
207  }
208  SPI_WAITFORTx_ENDED();
209 
210  SPI_FLASH_DISABLE();
211  splx(s);
212 
213  return p;
214 }
215 /*---------------------------------------------------------------------------*/
216 int
217 xmem_pwrite(const void *_buf, int size, unsigned long addr)
218 {
219  const unsigned char *p = _buf;
220  const unsigned long end = addr + size;
221  unsigned long i, next_page;
222 
223  for(i = addr; i < end;) {
224  next_page = (i | 0xff) + 1;
225  if(next_page > end) {
226  next_page = end;
227  }
228  p = program_page(i, p, next_page - i);
229  i = next_page;
230  }
231 
232  return size;
233 }
234 /*---------------------------------------------------------------------------*/
235 int
236 xmem_erase(long size, unsigned long addr)
237 {
238  unsigned long end = addr + size;
239 
240  if(size % XMEM_ERASE_UNIT_SIZE != 0) {
241  PRINTF("xmem_erase: bad size\n");
242  return -1;
243  }
244 
245  if(addr % XMEM_ERASE_UNIT_SIZE != 0) {
246  PRINTF("xmem_erase: bad offset\n");
247  return -1;
248  }
249 
250  for (; addr < end; addr += XMEM_ERASE_UNIT_SIZE) {
251  erase_sector(addr);
252  }
253 
254  return size;
255 }
256 /*---------------------------------------------------------------------------*/
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Definition: uip-nd6.c:107
static bool write_enable(const spi_device_t *flash_spi_configuration)
Enable write.
Definition: ext-flash.c:306
Basic SPI macros
static bool wait_ready(const spi_device_t *flash_spi_configuration)
Wait till previous erase/program operation completes.
Definition: ext-flash.c:157
void watchdog_periodic(void)
Writes the WDT clear sequence.
Definition: watchdog.c:85