1 /*
2 * Support for Atmel AT45DB series DataFlash chips.
3 * This file is part of the flashrom project.
4 *
5 * Copyright (C) 2012 Aidan Thornton
6 * Copyright (C) 2013 Stefan Tauner
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18 #include <string.h>
19 #include "flash.h"
20 #include "chipdrivers.h"
21 #include "programmer.h"
22 #include "spi.h"
23
24 /* Status register bits */
25 #define AT45DB_READY (1<<7)
26 #define AT45DB_CMP (1<<6)
27 #define AT45DB_PROT (1<<1)
28 #define AT45DB_POWEROF2 (1<<0)
29
30 /* Opcodes */
31 #define AT45DB_STATUS 0xD7 /* NB: this is a block erase command on most other chips(!). */
32 #define AT45DB_DISABLE_PROTECT 0x3D, 0x2A, 0x7F, 0x9A
33 #define AT45DB_READ_ARRAY 0xE8
34 #define AT45DB_READ_PROTECT 0x32
35 #define AT45DB_READ_LOCKDOWN 0x35
36 #define AT45DB_PAGE_ERASE 0x81
37 #define AT45DB_BLOCK_ERASE 0x50
38 #define AT45DB_SECTOR_ERASE 0x7C
39 #define AT45DB_CHIP_ERASE 0xC7
40 #define AT45DB_CHIP_ERASE_ADDR 0x94809A /* Magic address. See usage. */
41 #define AT45DB_BUFFER1_WRITE 0x84
42 #define AT45DB_BUFFER1_PAGE_PROGRAM 0x88
43 /* Buffer 2 is unused yet.
44 #define AT45DB_BUFFER2_WRITE 0x87
45 #define AT45DB_BUFFER2_PAGE_PROGRAM 0x89
46 */
47
at45db_read_status_register(struct flashctx * flash,uint8_t * status)48 static uint8_t at45db_read_status_register(struct flashctx *flash, uint8_t *status)
49 {
50 static const uint8_t cmd[] = { AT45DB_STATUS };
51
52 int ret = spi_send_command(flash, sizeof(cmd), 1, cmd, status);
53 if (ret != 0)
54 msg_cerr("Reading the status register failed!\n");
55 else
56 msg_cspew("Status register: 0x%02x.\n", *status);
57 return ret;
58 }
59
spi_disable_blockprotect_at45db(struct flashctx * flash)60 int spi_disable_blockprotect_at45db(struct flashctx *flash)
61 {
62 static const uint8_t cmd[4] = { AT45DB_DISABLE_PROTECT }; /* NB: 4 bytes magic number */
63 int ret = spi_send_command(flash, sizeof(cmd), 0, cmd, NULL);
64 if (ret != 0) {
65 msg_cerr("Sending disable lockdown failed!\n");
66 return ret;
67 }
68 uint8_t status;
69 ret = at45db_read_status_register(flash, &status);
70 if (ret != 0 || ((status & AT45DB_PROT) != 0)) {
71 msg_cerr("Disabling lockdown failed!\n");
72 return 1;
73 }
74
75 return 0;
76 }
77
at45db_get_sector_count(struct flashctx * flash)78 static unsigned int at45db_get_sector_count(struct flashctx *flash)
79 {
80 unsigned int i, j;
81 unsigned int cnt = 0;
82 for (i = 0; i < NUM_ERASEFUNCTIONS; i++) {
83 const struct block_eraser *const eraser = &flash->chip->block_erasers[i];
84 if (eraser->block_erase == SPI_ERASE_AT45DB_SECTOR) {
85 for (j = 0; j < NUM_ERASEREGIONS; j++) {
86 cnt += eraser->eraseblocks[j].count;
87 }
88 }
89 }
90 msg_cspew("%s: number of sectors=%u\n", __func__, cnt);
91 return cnt;
92 }
93
94 /* Reads and prettyprints protection/lockdown registers.
95 * Some elegance of the printouts had to be cut down a bit to share this code. */
at45db_prettyprint_protection_register(struct flashctx * flash,uint8_t opcode,const char * regname)96 static uint8_t at45db_prettyprint_protection_register(struct flashctx *flash, uint8_t opcode, const char *regname)
97 {
98 const uint8_t cmd[] = { opcode, 0, 0, 0 };
99 const size_t sec_count = at45db_get_sector_count(flash);
100 if (sec_count < 2)
101 return 0;
102
103 /* The first two sectors share the first result byte. */
104 uint8_t buf[at45db_get_sector_count(flash) - 1];
105
106 int ret = spi_send_command(flash, sizeof(cmd), sizeof(buf), cmd, buf);
107 if (ret != 0) {
108 msg_cerr("Reading the %s register failed!\n", regname);
109 return ret;
110 }
111
112 unsigned int i;
113 for (i = 0; i < sizeof(buf); i++) {
114 if (buf[i] != 0x00)
115 break;
116 if (i == sizeof(buf) - 1) {
117 msg_cdbg("No Sector is %sed.\n", regname);
118 return 0;
119 }
120 }
121
122 /* TODO: print which addresses are mapped to (un)locked sectors. */
123 msg_cdbg("Sector 0a is %s%sed.\n", ((buf[0] & 0xC0) == 0x00) ? "un" : "", regname);
124 msg_cdbg("Sector 0b is %s%sed.\n", ((buf[0] & 0x30) == 0x00) ? "un" : "", regname);
125 for (i = 1; i < sizeof(buf); i++)
126 msg_cdbg("Sector %2u is %s%sed.\n", i, (buf[i] == 0x00) ? "un" : "", regname);
127
128 return 0;
129 }
130
131 /* bit 7: busy flag
132 * bit 6: memory/buffer compare result
133 * bit 5-2: density (encoding see below)
134 * bit 1: protection enabled (soft or hard)
135 * bit 0: "power of 2" page size indicator (e.g. 1 means 256B; 0 means 264B)
136 *
137 * 5-2 encoding: bit 2 is always 1, bits 3-5 encode the density as "2^(bits - 1)" in Mb e.g.:
138 * AT45DB161D 1011 16Mb */
spi_prettyprint_status_register_at45db(struct flashctx * flash)139 int spi_prettyprint_status_register_at45db(struct flashctx *flash)
140 {
141 uint8_t status;
142 if (at45db_read_status_register(flash, &status) != 0) {
143 return 1;
144 }
145
146 /* AT45DB321C does not support lockdown or a page size of a power of 2... */
147 const bool isAT45DB321C = (strcmp(flash->chip->name, "AT45DB321C") == 0);
148 msg_cdbg("Chip status register is 0x%02x\n", status);
149 msg_cdbg("Chip status register: Bit 7 / Ready is %sset\n", (status & AT45DB_READY) ? "" : "not ");
150 msg_cdbg("Chip status register: Bit 6 / Compare match is %sset\n", (status & AT45DB_CMP) ? "" : "not ");
151 spi_prettyprint_status_register_bit(status, 5);
152 spi_prettyprint_status_register_bit(status, 4);
153 spi_prettyprint_status_register_bit(status, 3);
154 spi_prettyprint_status_register_bit(status, 2);
155 const uint8_t dens = (status >> 3) & 0x7; /* Bit 2 is always 1, we use the other bits only */
156 msg_cdbg("Chip status register: Density is %u Mb\n", 1 << (dens - 1));
157 msg_cdbg("Chip status register: Bit 1 / Protection is %sset\n", (status & AT45DB_PROT) ? "" : "not ");
158
159 if (isAT45DB321C)
160 spi_prettyprint_status_register_bit(status, 0);
161 else
162 msg_cdbg("Chip status register: Bit 0 / \"Power of 2\" is %sset\n",
163 (status & AT45DB_POWEROF2) ? "" : "not ");
164
165 if (status & AT45DB_PROT)
166 at45db_prettyprint_protection_register(flash, AT45DB_READ_PROTECT, "protect");
167
168 if (!isAT45DB321C)
169 at45db_prettyprint_protection_register(flash, AT45DB_READ_LOCKDOWN, "lock");
170
171 return 0;
172 }
173
174 /* Probe function for AT45DB* chips that support multiple page sizes. */
probe_spi_at45db(struct flashctx * flash)175 int probe_spi_at45db(struct flashctx *flash)
176 {
177 uint8_t status;
178 struct flashchip *chip = flash->chip;
179
180 if (!probe_spi_rdid(flash))
181 return 0;
182
183 /* Some AT45DB* chips support two different page sizes each (e.g. 264 and 256 B). In order to tell which
184 * page size this chip has we need to read the status register. */
185 if (at45db_read_status_register(flash, &status) != 0)
186 return 0;
187
188 /* We assume sane power-of-2 page sizes and adjust the chip attributes in case this is not the case. */
189 if ((status & AT45DB_POWEROF2) == 0) {
190 chip->total_size = (chip->total_size / 32) * 33;
191 chip->page_size = (chip->page_size / 32) * 33;
192
193 unsigned int i, j;
194 for (i = 0; i < NUM_ERASEFUNCTIONS; i++) {
195 struct block_eraser *eraser = &chip->block_erasers[i];
196 for (j = 0; j < NUM_ERASEREGIONS; j++) {
197 eraser->eraseblocks[j].size = (eraser->eraseblocks[j].size / 32) * 33;
198 }
199 }
200 }
201
202 switch (chip->page_size) {
203 case 256: chip->gran = WRITE_GRAN_256BYTES; break;
204 case 264: chip->gran = WRITE_GRAN_264BYTES; break;
205 case 512: chip->gran = WRITE_GRAN_512BYTES; break;
206 case 528: chip->gran = WRITE_GRAN_528BYTES; break;
207 case 1024: chip->gran = WRITE_GRAN_1024BYTES; break;
208 case 1056: chip->gran = WRITE_GRAN_1056BYTES; break;
209 default:
210 msg_cerr("%s: unknown page size %d.\n", __func__, chip->page_size);
211 return 0;
212 }
213
214 msg_cdbg2("%s: total size %i kB, page size %i B\n", __func__, chip->total_size * 1024, chip->page_size);
215
216 return 1;
217 }
218
219 /* In case of non-power-of-two page sizes we need to convert the address flashrom uses to the address the
220 * DataFlash chips use. The latter uses a segmented address space where the page address is encoded in the
221 * more significant bits and the offset within the page is encoded in the less significant bits. The exact
222 * partition depends on the page size.
223 */
at45db_convert_addr(unsigned int addr,unsigned int page_size)224 static unsigned int at45db_convert_addr(unsigned int addr, unsigned int page_size)
225 {
226 unsigned int page_bits = address_to_bits(page_size - 1);
227 unsigned int at45db_addr = ((addr / page_size) << page_bits) | (addr % page_size);
228 msg_cspew("%s: addr=0x%x, page_size=%u, page_bits=%u -> at45db_addr=0x%x\n",
229 __func__, addr, page_size, page_bits, at45db_addr);
230 return at45db_addr;
231 }
232
spi_read_at45db(struct flashctx * flash,uint8_t * buf,unsigned int addr,unsigned int len)233 int spi_read_at45db(struct flashctx *flash, uint8_t *buf, unsigned int addr, unsigned int len)
234 {
235 const unsigned int page_size = flash->chip->page_size;
236 const unsigned int total_size = flash->chip->total_size * 1024;
237 if ((addr + len) > total_size) {
238 msg_cerr("%s: tried to read beyond flash boundary: addr=%u, len=%u, size=%u\n",
239 __func__, addr, len, total_size);
240 return 1;
241 }
242
243 /* We have to split this up into chunks to fit within the programmer's read size limit, but those
244 * chunks can cross page boundaries. */
245 const unsigned int max_data_read = flash->mst->spi.max_data_read;
246 const unsigned int max_chunk = (max_data_read > 0) ? max_data_read : page_size;
247 while (len > 0) {
248 unsigned int chunk = min(max_chunk, len);
249 int ret = spi_nbyte_read(flash, at45db_convert_addr(addr, page_size), buf, chunk);
250 if (ret) {
251 msg_cerr("%s: error sending read command!\n", __func__);
252 return ret;
253 }
254 addr += chunk;
255 buf += chunk;
256 len -= chunk;
257 }
258
259 return 0;
260 }
261
262 /* Legacy continuous read, used where spi_read_at45db() is not available.
263 * The first 4 (dummy) bytes read need to be discarded. */
spi_read_at45db_e8(struct flashctx * flash,uint8_t * buf,unsigned int addr,unsigned int len)264 int spi_read_at45db_e8(struct flashctx *flash, uint8_t *buf, unsigned int addr, unsigned int len)
265 {
266 const unsigned int page_size = flash->chip->page_size;
267 const unsigned int total_size = flash->chip->total_size * 1024;
268 if ((addr + len) > total_size) {
269 msg_cerr("%s: tried to read beyond flash boundary: addr=%u, len=%u, size=%u\n",
270 __func__, addr, len, total_size);
271 return 1;
272 }
273
274 /* We have to split this up into chunks to fit within the programmer's read size limit, but those
275 * chunks can cross page boundaries. */
276 const unsigned int max_data_read = flash->mst->spi.max_data_read;
277 const unsigned int max_chunk = (max_data_read > 0) ? max_data_read : page_size;
278 while (len > 0) {
279 const unsigned int addr_at45 = at45db_convert_addr(addr, page_size);
280 const unsigned char cmd[] = {
281 AT45DB_READ_ARRAY,
282 (addr_at45 >> 16) & 0xff,
283 (addr_at45 >> 8) & 0xff,
284 (addr_at45 >> 0) & 0xff
285 };
286 /* We need to leave place for 4 dummy bytes and handle them explicitly. */
287 unsigned int chunk = min(max_chunk, len + 4);
288 uint8_t tmp[chunk];
289 int ret = spi_send_command(flash, sizeof(cmd), chunk, cmd, tmp);
290 if (ret) {
291 msg_cerr("%s: error sending read command!\n", __func__);
292 return ret;
293 }
294 /* Copy result without dummy bytes into buf and advance address counter respectively. */
295 memcpy(buf, tmp + 4, chunk - 4);
296 addr += chunk - 4;
297 buf += chunk - 4;
298 len -= chunk - 4;
299 }
300 return 0;
301 }
302
303 /* Returns 0 when ready, 1 on errors and timeouts. */
at45db_wait_ready(struct flashctx * flash,unsigned int us,unsigned int retries)304 static int at45db_wait_ready (struct flashctx *flash, unsigned int us, unsigned int retries)
305 {
306 while (true) {
307 uint8_t status;
308 int ret = at45db_read_status_register(flash, &status);
309 if ((status & AT45DB_READY) == AT45DB_READY)
310 return 0;
311 if (ret != 0 || retries-- == 0)
312 return 1;
313 programmer_delay(flash, us);
314 }
315 }
316
at45db_erase(struct flashctx * flash,uint8_t opcode,unsigned int at45db_addr,unsigned int stepsize,unsigned int retries)317 static int at45db_erase(struct flashctx *flash, uint8_t opcode, unsigned int at45db_addr, unsigned int stepsize, unsigned int retries)
318 {
319 const uint8_t cmd[] = {
320 opcode,
321 (at45db_addr >> 16) & 0xff,
322 (at45db_addr >> 8) & 0xff,
323 (at45db_addr >> 0) & 0xff
324 };
325
326 /* Send erase command. */
327 int ret = spi_send_command(flash, sizeof(cmd), 0, cmd, NULL);
328 if (ret != 0) {
329 msg_cerr("%s: error sending erase command!\n", __func__);
330 return ret;
331 }
332
333 /* Wait for completion. */
334 ret = at45db_wait_ready(flash, stepsize, retries);
335 if (ret != 0)
336 msg_cerr("%s: chip did not become ready again after sending the erase command!\n", __func__);
337
338 return ret;
339 }
340
spi_erase_at45db_page(struct flashctx * flash,unsigned int addr,unsigned int blocklen)341 int spi_erase_at45db_page(struct flashctx *flash, unsigned int addr, unsigned int blocklen)
342 {
343 const unsigned int page_size = flash->chip->page_size;
344 const unsigned int total_size = flash->chip->total_size * 1024;
345
346 if ((addr % page_size) != 0 || (blocklen % page_size) != 0) {
347 msg_cerr("%s: cannot erase partial pages: addr=%u, blocklen=%u\n", __func__, addr, blocklen);
348 return 1;
349 }
350
351 if ((addr + blocklen) > total_size) {
352 msg_cerr("%s: tried to erase a block beyond flash boundary: addr=%u, blocklen=%u, size=%u\n",
353 __func__, addr, blocklen, total_size);
354 return 1;
355 }
356
357 /* Needs typically about 35 ms for completion, so let's wait 100 ms in 500 us steps. */
358 return at45db_erase(flash, AT45DB_PAGE_ERASE, at45db_convert_addr(addr, page_size), 500, 200);
359 }
360
spi_erase_at45db_block(struct flashctx * flash,unsigned int addr,unsigned int blocklen)361 int spi_erase_at45db_block(struct flashctx *flash, unsigned int addr, unsigned int blocklen)
362 {
363 const unsigned int page_size = flash->chip->page_size;
364 const unsigned int total_size = flash->chip->total_size * 1024;
365
366 if ((addr % page_size) != 0 || (blocklen % page_size) != 0) { // FIXME: should check blocks not pages
367 msg_cerr("%s: cannot erase partial pages: addr=%u, blocklen=%u\n", __func__, addr, blocklen);
368 return 1;
369 }
370
371 if ((addr + blocklen) > total_size) {
372 msg_cerr("%s: tried to erase a block beyond flash boundary: addr=%u, blocklen=%u, size=%u\n",
373 __func__, addr, blocklen, total_size);
374 return 1;
375 }
376
377 /* Needs typically between 20 and 100 ms for completion, so let's wait 300 ms in 1 ms steps. */
378 return at45db_erase(flash, AT45DB_BLOCK_ERASE, at45db_convert_addr(addr, page_size), 1000, 300);
379 }
380
spi_erase_at45db_sector(struct flashctx * flash,unsigned int addr,unsigned int blocklen)381 int spi_erase_at45db_sector(struct flashctx *flash, unsigned int addr, unsigned int blocklen)
382 {
383 const unsigned int page_size = flash->chip->page_size;
384 const unsigned int total_size = flash->chip->total_size * 1024;
385
386 if ((addr % page_size) != 0 || (blocklen % page_size) != 0) { // FIXME: should check sectors not pages
387 msg_cerr("%s: cannot erase partial pages: addr=%u, blocklen=%u\n", __func__, addr, blocklen);
388 return 1;
389 }
390
391 if ((addr + blocklen) > total_size) {
392 msg_cerr("%s: tried to erase a sector beyond flash boundary: addr=%u, blocklen=%u, size=%u\n",
393 __func__, addr, blocklen, total_size);
394 return 1;
395 }
396
397 /* Needs typically about 5 s for completion, so let's wait 20 seconds in 200 ms steps. */
398 return at45db_erase(flash, AT45DB_SECTOR_ERASE, at45db_convert_addr(addr, page_size), 200000, 100);
399 }
400
spi_erase_at45db_chip(struct flashctx * flash,unsigned int addr,unsigned int blocklen)401 int spi_erase_at45db_chip(struct flashctx *flash, unsigned int addr, unsigned int blocklen)
402 {
403 const unsigned int total_size = flash->chip->total_size * 1024;
404
405 if ((addr + blocklen) > total_size) {
406 msg_cerr("%s: tried to erase beyond flash boundary: addr=%u, blocklen=%u, size=%u\n",
407 __func__, addr, blocklen, total_size);
408 return 1;
409 }
410
411 /* Needs typically from about 5 to over 60 s for completion, so let's wait 100 s in 500 ms steps.
412 * NB: the address is not a real address but a magic number. This hack allows to share code. */
413 return at45db_erase(flash, AT45DB_CHIP_ERASE, AT45DB_CHIP_ERASE_ADDR, 500000, 200);
414 }
415
416 /* This one is really special and works only for AT45CS1282. It uses two different opcodes depending on the
417 * address and has an asymmetric layout. */
spi_erase_at45cs_sector(struct flashctx * flash,unsigned int addr,unsigned int blocklen)418 int spi_erase_at45cs_sector(struct flashctx *flash, unsigned int addr, unsigned int blocklen)
419 {
420 const unsigned int page_size = flash->chip->page_size;
421 const unsigned int total_size = flash->chip->total_size * 1024;
422 const struct block_eraser be = flash->chip->block_erasers[0];
423 const unsigned int sec_0a_top = be.eraseblocks[0].size;
424 const unsigned int sec_0b_top = be.eraseblocks[0].size + be.eraseblocks[1].size;
425
426 if ((addr + blocklen) > total_size) {
427 msg_cerr("%s: tried to erase a sector beyond flash boundary: addr=%u, blocklen=%u, size=%u\n",
428 __func__, addr, blocklen, total_size);
429 return 1;
430 }
431
432 bool partial_range = false;
433 uint8_t opcode = 0x7C; /* Used for all but sector 0a. */
434 if (addr < sec_0a_top) {
435 opcode = 0x50;
436 /* One single sector of 8 pages at address 0. */
437 if (addr != 0 || blocklen != (8 * page_size))
438 partial_range = true;
439 } else if (addr < sec_0b_top) {
440 /* One single sector of 248 pages adjacent to the first. */
441 if (addr != sec_0a_top || blocklen != (248 * page_size))
442 partial_range = true;
443 } else {
444 /* The rest is filled by 63 aligned sectors of 256 pages. */
445 if ((addr % (256 * page_size)) != 0 || (blocklen % (256 * page_size)) != 0)
446 partial_range = true;
447 }
448 if (partial_range) {
449 msg_cerr("%s: cannot erase partial sectors: addr=%u, blocklen=%u\n", __func__, addr, blocklen);
450 return 1;
451 }
452
453 /* Needs up to 4 s for completion, so let's wait 20 seconds in 200 ms steps. */
454 return at45db_erase(flash, opcode, at45db_convert_addr(addr, page_size), 200000, 100);
455 }
456
at45db_fill_buffer1(struct flashctx * flash,const uint8_t * bytes,unsigned int off,unsigned int len)457 static int at45db_fill_buffer1(struct flashctx *flash, const uint8_t *bytes, unsigned int off, unsigned int len)
458 {
459 const unsigned int page_size = flash->chip->page_size;
460 if ((off + len) > page_size) {
461 msg_cerr("Tried to write %u bytes at offset %u into a buffer of only %u B.\n",
462 len, off, page_size);
463 return 1;
464 }
465
466 /* Create a suitable buffer to store opcode, address and data chunks for buffer1. */
467 const unsigned int max_data_write = flash->mst->spi.max_data_write;
468 const unsigned int max_chunk = max_data_write > 4 && max_data_write - 4 <= page_size ?
469 max_data_write - 4 : page_size;
470 uint8_t buf[4 + max_chunk];
471
472 buf[0] = AT45DB_BUFFER1_WRITE;
473 while (off < page_size) {
474 unsigned int cur_chunk = min(max_chunk, page_size - off);
475 buf[1] = (off >> 16) & 0xff;
476 buf[2] = (off >> 8) & 0xff;
477 buf[3] = (off >> 0) & 0xff;
478 memcpy(&buf[4], bytes + off, cur_chunk);
479 int ret = spi_send_command(flash, 4 + cur_chunk, 0, buf, NULL);
480 if (ret != 0) {
481 msg_cerr("%s: error sending buffer write!\n", __func__);
482 return ret;
483 }
484 off += cur_chunk;
485 }
486 return 0;
487 }
488
at45db_commit_buffer1(struct flashctx * flash,unsigned int at45db_addr)489 static int at45db_commit_buffer1(struct flashctx *flash, unsigned int at45db_addr)
490 {
491 const uint8_t cmd[] = {
492 AT45DB_BUFFER1_PAGE_PROGRAM,
493 (at45db_addr >> 16) & 0xff,
494 (at45db_addr >> 8) & 0xff,
495 (at45db_addr >> 0) & 0xff
496 };
497
498 /* Send buffer to device. */
499 int ret = spi_send_command(flash, sizeof(cmd), 0, cmd, NULL);
500 if (ret != 0) {
501 msg_cerr("%s: error sending buffer to main memory command!\n", __func__);
502 return ret;
503 }
504
505 /* Wait for completion (typically a few ms). */
506 ret = at45db_wait_ready(flash, 250, 200); // 50 ms
507 if (ret != 0) {
508 msg_cerr("%s: chip did not become ready again!\n", __func__);
509 return ret;
510 }
511
512 return 0;
513 }
514
at45db_program_page(struct flashctx * flash,const uint8_t * buf,unsigned int at45db_addr)515 static int at45db_program_page(struct flashctx *flash, const uint8_t *buf, unsigned int at45db_addr)
516 {
517 int ret = at45db_fill_buffer1(flash, buf, 0, flash->chip->page_size);
518 if (ret != 0) {
519 msg_cerr("%s: filling the buffer failed!\n", __func__);
520 return ret;
521 }
522
523 ret = at45db_commit_buffer1(flash, at45db_addr);
524 if (ret != 0) {
525 msg_cerr("%s: committing page failed!\n", __func__);
526 return ret;
527 }
528
529 return 0;
530 }
531
spi_write_at45db(struct flashctx * flash,const uint8_t * buf,unsigned int start,unsigned int len)532 int spi_write_at45db(struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len)
533 {
534 const unsigned int page_size = flash->chip->page_size;
535 const unsigned int total_size = flash->chip->total_size;
536
537 if ((start % page_size) != 0 || (len % page_size) != 0) {
538 msg_cerr("%s: cannot write partial pages: start=%u, len=%u\n", __func__, start, len);
539 return 1;
540 }
541
542 if ((start + len) > (total_size * 1024)) {
543 msg_cerr("%s: tried to write beyond flash boundary: start=%u, len=%u, size=%u\n",
544 __func__, start, len, total_size);
545 return 1;
546 }
547
548 unsigned int i;
549 for (i = 0; i < len; i += page_size) {
550 if (at45db_program_page(flash, buf + i, at45db_convert_addr(start + i, page_size)) != 0) {
551 msg_cerr("Writing page %u failed!\n", i);
552 return 1;
553 }
554 update_progress(flash, FLASHROM_PROGRESS_WRITE, i + page_size, len);
555 }
556 return 0;
557 }
558