1 /*
2 * Simulate a SPI flash
3 *
4 * Copyright (c) 2011-2013 The Chromium OS Authors.
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * Licensed under the GPL-2 or later.
9 */
10
11 #include <common.h>
12 #include <dm.h>
13 #include <malloc.h>
14 #include <spi.h>
15 #include <os.h>
16
17 #include <spi_flash.h>
18 #include "sf_internal.h"
19
20 #include <asm/getopt.h>
21 #include <asm/spi.h>
22 #include <asm/state.h>
23 #include <dm/device-internal.h>
24 #include <dm/lists.h>
25 #include <dm/uclass-internal.h>
26
27 /*
28 * The different states that our SPI flash transitions between.
29 * We need to keep track of this across multiple xfer calls since
30 * the SPI bus could possibly call down into us multiple times.
31 */
32 enum sandbox_sf_state {
33 SF_CMD, /* default state -- we're awaiting a command */
34 SF_ID, /* read the flash's (jedec) ID code */
35 SF_ADDR, /* processing the offset in the flash to read/etc... */
36 SF_READ, /* reading data from the flash */
37 SF_WRITE, /* writing data to the flash, i.e. page programming */
38 SF_ERASE, /* erase the flash */
39 SF_READ_STATUS, /* read the flash's status register */
40 SF_READ_STATUS1, /* read the flash's status register upper 8 bits*/
41 SF_WRITE_STATUS, /* write the flash's status register */
42 };
43
sandbox_sf_state_name(enum sandbox_sf_state state)44 static const char *sandbox_sf_state_name(enum sandbox_sf_state state)
45 {
46 static const char * const states[] = {
47 "CMD", "ID", "ADDR", "READ", "WRITE", "ERASE", "READ_STATUS",
48 "READ_STATUS1", "WRITE_STATUS",
49 };
50 return states[state];
51 }
52
53 /* Bits for the status register */
54 #define STAT_WIP (1 << 0)
55 #define STAT_WEL (1 << 1)
56
57 /* Assume all SPI flashes have 3 byte addresses since they do atm */
58 #define SF_ADDR_LEN 3
59
60 #define IDCODE_LEN 3
61
62 /* Used to quickly bulk erase backing store */
63 static u8 sandbox_sf_0xff[0x1000];
64
65 /* Internal state data for each SPI flash */
66 struct sandbox_spi_flash {
67 unsigned int cs; /* Chip select we are attached to */
68 /*
69 * As we receive data over the SPI bus, our flash transitions
70 * between states. For example, we start off in the SF_CMD
71 * state where the first byte tells us what operation to perform
72 * (such as read or write the flash). But the operation itself
73 * can go through a few states such as first reading in the
74 * offset in the flash to perform the requested operation.
75 * Thus "state" stores the exact state that our machine is in
76 * while "cmd" stores the overall command we're processing.
77 */
78 enum sandbox_sf_state state;
79 uint cmd;
80 /* Erase size of current erase command */
81 uint erase_size;
82 /* Current position in the flash; used when reading/writing/etc... */
83 uint off;
84 /* How many address bytes we've consumed */
85 uint addr_bytes, pad_addr_bytes;
86 /* The current flash status (see STAT_XXX defines above) */
87 u16 status;
88 /* Data describing the flash we're emulating */
89 const struct spi_flash_info *data;
90 /* The file on disk to serv up data from */
91 int fd;
92 };
93
94 struct sandbox_spi_flash_plat_data {
95 const char *filename;
96 const char *device_name;
97 int bus;
98 int cs;
99 };
100
101 /**
102 * This is a very strange probe function. If it has platform data (which may
103 * have come from the device tree) then this function gets the filename and
104 * device type from there. Failing that it looks at the command line
105 * parameter.
106 */
sandbox_sf_probe(struct udevice * dev)107 static int sandbox_sf_probe(struct udevice *dev)
108 {
109 /* spec = idcode:file */
110 struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
111 const char *file;
112 size_t len, idname_len;
113 const struct spi_flash_info *data;
114 struct sandbox_spi_flash_plat_data *pdata = dev_get_platdata(dev);
115 struct sandbox_state *state = state_get_current();
116 struct udevice *bus = dev->parent;
117 const char *spec = NULL;
118 int ret = 0;
119 int cs = -1;
120 int i;
121
122 debug("%s: bus %d, looking for emul=%p: ", __func__, bus->seq, dev);
123 if (bus->seq >= 0 && bus->seq < CONFIG_SANDBOX_SPI_MAX_BUS) {
124 for (i = 0; i < CONFIG_SANDBOX_SPI_MAX_CS; i++) {
125 if (state->spi[bus->seq][i].emul == dev)
126 cs = i;
127 }
128 }
129 if (cs == -1) {
130 printf("Error: Unknown chip select for device '%s'\n",
131 dev->name);
132 return -EINVAL;
133 }
134 debug("found at cs %d\n", cs);
135
136 if (!pdata->filename) {
137 struct sandbox_state *state = state_get_current();
138
139 assert(bus->seq != -1);
140 if (bus->seq < CONFIG_SANDBOX_SPI_MAX_BUS)
141 spec = state->spi[bus->seq][cs].spec;
142 if (!spec) {
143 debug("%s: No spec found for bus %d, cs %d\n",
144 __func__, bus->seq, cs);
145 ret = -ENOENT;
146 goto error;
147 }
148
149 file = strchr(spec, ':');
150 if (!file) {
151 printf("%s: unable to parse file\n", __func__);
152 ret = -EINVAL;
153 goto error;
154 }
155 idname_len = file - spec;
156 pdata->filename = file + 1;
157 pdata->device_name = spec;
158 ++file;
159 } else {
160 spec = strchr(pdata->device_name, ',');
161 if (spec)
162 spec++;
163 else
164 spec = pdata->device_name;
165 idname_len = strlen(spec);
166 }
167 debug("%s: device='%s'\n", __func__, spec);
168
169 for (data = spi_flash_ids; data->name; data++) {
170 len = strlen(data->name);
171 if (idname_len != len)
172 continue;
173 if (!strncasecmp(spec, data->name, len))
174 break;
175 }
176 if (!data->name) {
177 printf("%s: unknown flash '%*s'\n", __func__, (int)idname_len,
178 spec);
179 ret = -EINVAL;
180 goto error;
181 }
182
183 if (sandbox_sf_0xff[0] == 0x00)
184 memset(sandbox_sf_0xff, 0xff, sizeof(sandbox_sf_0xff));
185
186 sbsf->fd = os_open(pdata->filename, 02);
187 if (sbsf->fd == -1) {
188 printf("%s: unable to open file '%s'\n", __func__,
189 pdata->filename);
190 ret = -EIO;
191 goto error;
192 }
193
194 sbsf->data = data;
195 sbsf->cs = cs;
196
197 return 0;
198
199 error:
200 debug("%s: Got error %d\n", __func__, ret);
201 return ret;
202 }
203
sandbox_sf_remove(struct udevice * dev)204 static int sandbox_sf_remove(struct udevice *dev)
205 {
206 struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
207
208 os_close(sbsf->fd);
209
210 return 0;
211 }
212
sandbox_sf_cs_activate(struct udevice * dev)213 static void sandbox_sf_cs_activate(struct udevice *dev)
214 {
215 struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
216
217 debug("sandbox_sf: CS activated; state is fresh!\n");
218
219 /* CS is asserted, so reset state */
220 sbsf->off = 0;
221 sbsf->addr_bytes = 0;
222 sbsf->pad_addr_bytes = 0;
223 sbsf->state = SF_CMD;
224 sbsf->cmd = SF_CMD;
225 }
226
sandbox_sf_cs_deactivate(struct udevice * dev)227 static void sandbox_sf_cs_deactivate(struct udevice *dev)
228 {
229 debug("sandbox_sf: CS deactivated; cmd done processing!\n");
230 }
231
232 /*
233 * There are times when the data lines are allowed to tristate. What
234 * is actually sensed on the line depends on the hardware. It could
235 * always be 0xFF/0x00 (if there are pull ups/downs), or things could
236 * float and so we'd get garbage back. This func encapsulates that
237 * scenario so we can worry about the details here.
238 */
sandbox_spi_tristate(u8 * buf,uint len)239 static void sandbox_spi_tristate(u8 *buf, uint len)
240 {
241 /* XXX: make this into a user config option ? */
242 memset(buf, 0xff, len);
243 }
244
245 /* Figure out what command this stream is telling us to do */
sandbox_sf_process_cmd(struct sandbox_spi_flash * sbsf,const u8 * rx,u8 * tx)246 static int sandbox_sf_process_cmd(struct sandbox_spi_flash *sbsf, const u8 *rx,
247 u8 *tx)
248 {
249 enum sandbox_sf_state oldstate = sbsf->state;
250
251 /* We need to output a byte for the cmd byte we just ate */
252 if (tx)
253 sandbox_spi_tristate(tx, 1);
254
255 sbsf->cmd = rx[0];
256 switch (sbsf->cmd) {
257 case CMD_READ_ID:
258 sbsf->state = SF_ID;
259 sbsf->cmd = SF_ID;
260 break;
261 case CMD_READ_ARRAY_FAST:
262 sbsf->pad_addr_bytes = 1;
263 case CMD_READ_ARRAY_SLOW:
264 case CMD_PAGE_PROGRAM:
265 sbsf->state = SF_ADDR;
266 break;
267 case CMD_WRITE_DISABLE:
268 debug(" write disabled\n");
269 sbsf->status &= ~STAT_WEL;
270 break;
271 case CMD_READ_STATUS:
272 sbsf->state = SF_READ_STATUS;
273 break;
274 case CMD_READ_STATUS1:
275 sbsf->state = SF_READ_STATUS1;
276 break;
277 case CMD_WRITE_ENABLE:
278 debug(" write enabled\n");
279 sbsf->status |= STAT_WEL;
280 break;
281 case CMD_WRITE_STATUS:
282 sbsf->state = SF_WRITE_STATUS;
283 break;
284 default: {
285 int flags = sbsf->data->flags;
286
287 /* we only support erase here */
288 if (sbsf->cmd == CMD_ERASE_CHIP) {
289 sbsf->erase_size = sbsf->data->sector_size *
290 sbsf->data->n_sectors;
291 } else if (sbsf->cmd == CMD_ERASE_4K && (flags & SECT_4K)) {
292 sbsf->erase_size = 4 << 10;
293 } else if (sbsf->cmd == CMD_ERASE_64K && !(flags & SECT_4K)) {
294 sbsf->erase_size = 64 << 10;
295 } else {
296 debug(" cmd unknown: %#x\n", sbsf->cmd);
297 return -EIO;
298 }
299 sbsf->state = SF_ADDR;
300 break;
301 }
302 }
303
304 if (oldstate != sbsf->state)
305 debug(" cmd: transition to %s state\n",
306 sandbox_sf_state_name(sbsf->state));
307
308 return 0;
309 }
310
sandbox_erase_part(struct sandbox_spi_flash * sbsf,int size)311 int sandbox_erase_part(struct sandbox_spi_flash *sbsf, int size)
312 {
313 int todo;
314 int ret;
315
316 while (size > 0) {
317 todo = min(size, (int)sizeof(sandbox_sf_0xff));
318 ret = os_write(sbsf->fd, sandbox_sf_0xff, todo);
319 if (ret != todo)
320 return ret;
321 size -= todo;
322 }
323
324 return 0;
325 }
326
sandbox_sf_xfer(struct udevice * dev,unsigned int bitlen,const void * rxp,void * txp,unsigned long flags)327 static int sandbox_sf_xfer(struct udevice *dev, unsigned int bitlen,
328 const void *rxp, void *txp, unsigned long flags)
329 {
330 struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
331 const uint8_t *rx = rxp;
332 uint8_t *tx = txp;
333 uint cnt, pos = 0;
334 int bytes = bitlen / 8;
335 int ret;
336
337 debug("sandbox_sf: state:%x(%s) bytes:%u\n", sbsf->state,
338 sandbox_sf_state_name(sbsf->state), bytes);
339
340 if ((flags & SPI_XFER_BEGIN))
341 sandbox_sf_cs_activate(dev);
342
343 if (sbsf->state == SF_CMD) {
344 /* Figure out the initial state */
345 ret = sandbox_sf_process_cmd(sbsf, rx, tx);
346 if (ret)
347 return ret;
348 ++pos;
349 }
350
351 /* Process the remaining data */
352 while (pos < bytes) {
353 switch (sbsf->state) {
354 case SF_ID: {
355 u8 id;
356
357 debug(" id: off:%u tx:", sbsf->off);
358 if (sbsf->off < IDCODE_LEN) {
359 /* Extract correct byte from ID 0x00aabbcc */
360 id = ((JEDEC_MFR(sbsf->data) << 16) |
361 JEDEC_ID(sbsf->data)) >>
362 (8 * (IDCODE_LEN - 1 - sbsf->off));
363 } else {
364 id = 0;
365 }
366 debug("%d %02x\n", sbsf->off, id);
367 tx[pos++] = id;
368 ++sbsf->off;
369 break;
370 }
371 case SF_ADDR:
372 debug(" addr: bytes:%u rx:%02x ", sbsf->addr_bytes,
373 rx[pos]);
374
375 if (sbsf->addr_bytes++ < SF_ADDR_LEN)
376 sbsf->off = (sbsf->off << 8) | rx[pos];
377 debug("addr:%06x\n", sbsf->off);
378
379 if (tx)
380 sandbox_spi_tristate(&tx[pos], 1);
381 pos++;
382
383 /* See if we're done processing */
384 if (sbsf->addr_bytes <
385 SF_ADDR_LEN + sbsf->pad_addr_bytes)
386 break;
387
388 /* Next state! */
389 if (os_lseek(sbsf->fd, sbsf->off, OS_SEEK_SET) < 0) {
390 puts("sandbox_sf: os_lseek() failed");
391 return -EIO;
392 }
393 switch (sbsf->cmd) {
394 case CMD_READ_ARRAY_FAST:
395 case CMD_READ_ARRAY_SLOW:
396 sbsf->state = SF_READ;
397 break;
398 case CMD_PAGE_PROGRAM:
399 sbsf->state = SF_WRITE;
400 break;
401 default:
402 /* assume erase state ... */
403 sbsf->state = SF_ERASE;
404 goto case_sf_erase;
405 }
406 debug(" cmd: transition to %s state\n",
407 sandbox_sf_state_name(sbsf->state));
408 break;
409 case SF_READ:
410 /*
411 * XXX: need to handle exotic behavior:
412 * - reading past end of device
413 */
414
415 cnt = bytes - pos;
416 debug(" tx: read(%u)\n", cnt);
417 assert(tx);
418 ret = os_read(sbsf->fd, tx + pos, cnt);
419 if (ret < 0) {
420 puts("sandbox_sf: os_read() failed\n");
421 return -EIO;
422 }
423 pos += ret;
424 break;
425 case SF_READ_STATUS:
426 debug(" read status: %#x\n", sbsf->status);
427 cnt = bytes - pos;
428 memset(tx + pos, sbsf->status, cnt);
429 pos += cnt;
430 break;
431 case SF_READ_STATUS1:
432 debug(" read status: %#x\n", sbsf->status);
433 cnt = bytes - pos;
434 memset(tx + pos, sbsf->status >> 8, cnt);
435 pos += cnt;
436 break;
437 case SF_WRITE_STATUS:
438 debug(" write status: %#x (ignored)\n", rx[pos]);
439 pos = bytes;
440 break;
441 case SF_WRITE:
442 /*
443 * XXX: need to handle exotic behavior:
444 * - unaligned addresses
445 * - more than a page (256) worth of data
446 * - reading past end of device
447 */
448 if (!(sbsf->status & STAT_WEL)) {
449 puts("sandbox_sf: write enable not set before write\n");
450 goto done;
451 }
452
453 cnt = bytes - pos;
454 debug(" rx: write(%u)\n", cnt);
455 if (tx)
456 sandbox_spi_tristate(&tx[pos], cnt);
457 ret = os_write(sbsf->fd, rx + pos, cnt);
458 if (ret < 0) {
459 puts("sandbox_spi: os_write() failed\n");
460 return -EIO;
461 }
462 pos += ret;
463 sbsf->status &= ~STAT_WEL;
464 break;
465 case SF_ERASE:
466 case_sf_erase: {
467 if (!(sbsf->status & STAT_WEL)) {
468 puts("sandbox_sf: write enable not set before erase\n");
469 goto done;
470 }
471
472 /* verify address is aligned */
473 if (sbsf->off & (sbsf->erase_size - 1)) {
474 debug(" sector erase: cmd:%#x needs align:%#x, but we got %#x\n",
475 sbsf->cmd, sbsf->erase_size,
476 sbsf->off);
477 sbsf->status &= ~STAT_WEL;
478 goto done;
479 }
480
481 debug(" sector erase addr: %u, size: %u\n", sbsf->off,
482 sbsf->erase_size);
483
484 cnt = bytes - pos;
485 if (tx)
486 sandbox_spi_tristate(&tx[pos], cnt);
487 pos += cnt;
488
489 /*
490 * TODO(vapier@gentoo.org): latch WIP in status, and
491 * delay before clearing it ?
492 */
493 ret = sandbox_erase_part(sbsf, sbsf->erase_size);
494 sbsf->status &= ~STAT_WEL;
495 if (ret) {
496 debug("sandbox_sf: Erase failed\n");
497 goto done;
498 }
499 goto done;
500 }
501 default:
502 debug(" ??? no idea what to do ???\n");
503 goto done;
504 }
505 }
506
507 done:
508 if (flags & SPI_XFER_END)
509 sandbox_sf_cs_deactivate(dev);
510 return pos == bytes ? 0 : -EIO;
511 }
512
sandbox_sf_ofdata_to_platdata(struct udevice * dev)513 int sandbox_sf_ofdata_to_platdata(struct udevice *dev)
514 {
515 struct sandbox_spi_flash_plat_data *pdata = dev_get_platdata(dev);
516
517 pdata->filename = dev_read_string(dev, "sandbox,filename");
518 pdata->device_name = dev_read_string(dev, "compatible");
519 if (!pdata->filename || !pdata->device_name) {
520 debug("%s: Missing properties, filename=%s, device_name=%s\n",
521 __func__, pdata->filename, pdata->device_name);
522 return -EINVAL;
523 }
524
525 return 0;
526 }
527
528 static const struct dm_spi_emul_ops sandbox_sf_emul_ops = {
529 .xfer = sandbox_sf_xfer,
530 };
531
532 #ifdef CONFIG_SPI_FLASH
sandbox_cmdline_cb_spi_sf(struct sandbox_state * state,const char * arg)533 static int sandbox_cmdline_cb_spi_sf(struct sandbox_state *state,
534 const char *arg)
535 {
536 unsigned long bus, cs;
537 const char *spec = sandbox_spi_parse_spec(arg, &bus, &cs);
538
539 if (!spec)
540 return 1;
541
542 /*
543 * It is safe to not make a copy of 'spec' because it comes from the
544 * command line.
545 *
546 * TODO(sjg@chromium.org): It would be nice if we could parse the
547 * spec here, but the problem is that no U-Boot init has been done
548 * yet. Perhaps we can figure something out.
549 */
550 state->spi[bus][cs].spec = spec;
551 debug("%s: Setting up spec '%s' for bus %ld, cs %ld\n", __func__,
552 spec, bus, cs);
553
554 return 0;
555 }
556 SANDBOX_CMDLINE_OPT(spi_sf, 1, "connect a SPI flash: <bus>:<cs>:<id>:<file>");
557
sandbox_sf_bind_emul(struct sandbox_state * state,int busnum,int cs,struct udevice * bus,int of_offset,const char * spec)558 int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
559 struct udevice *bus, int of_offset, const char *spec)
560 {
561 struct udevice *emul;
562 char name[20], *str;
563 struct driver *drv;
564 int ret;
565
566 /* now the emulator */
567 strncpy(name, spec, sizeof(name) - 6);
568 name[sizeof(name) - 6] = '\0';
569 strcat(name, "-emul");
570 drv = lists_driver_lookup_name("sandbox_sf_emul");
571 if (!drv) {
572 puts("Cannot find sandbox_sf_emul driver\n");
573 return -ENOENT;
574 }
575 str = strdup(name);
576 if (!str)
577 return -ENOMEM;
578 ret = device_bind(bus, drv, str, NULL, of_offset, &emul);
579 if (ret) {
580 free(str);
581 printf("Cannot create emul device for spec '%s' (err=%d)\n",
582 spec, ret);
583 return ret;
584 }
585 state->spi[busnum][cs].emul = emul;
586
587 return 0;
588 }
589
sandbox_sf_unbind_emul(struct sandbox_state * state,int busnum,int cs)590 void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs)
591 {
592 struct udevice *dev;
593
594 dev = state->spi[busnum][cs].emul;
595 device_remove(dev, DM_REMOVE_NORMAL);
596 device_unbind(dev);
597 state->spi[busnum][cs].emul = NULL;
598 }
599
sandbox_sf_bind_bus_cs(struct sandbox_state * state,int busnum,int cs,const char * spec)600 static int sandbox_sf_bind_bus_cs(struct sandbox_state *state, int busnum,
601 int cs, const char *spec)
602 {
603 struct udevice *bus, *slave;
604 int ret;
605
606 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, true, &bus);
607 if (ret) {
608 printf("Invalid bus %d for spec '%s' (err=%d)\n", busnum,
609 spec, ret);
610 return ret;
611 }
612 ret = spi_find_chip_select(bus, cs, &slave);
613 if (!ret) {
614 printf("Chip select %d already exists for spec '%s'\n", cs,
615 spec);
616 return -EEXIST;
617 }
618
619 ret = device_bind_driver(bus, "spi_flash_std", spec, &slave);
620 if (ret)
621 return ret;
622
623 return sandbox_sf_bind_emul(state, busnum, cs, bus, -1, spec);
624 }
625
sandbox_spi_get_emul(struct sandbox_state * state,struct udevice * bus,struct udevice * slave,struct udevice ** emulp)626 int sandbox_spi_get_emul(struct sandbox_state *state,
627 struct udevice *bus, struct udevice *slave,
628 struct udevice **emulp)
629 {
630 struct sandbox_spi_info *info;
631 int busnum = bus->seq;
632 int cs = spi_chip_select(slave);
633 int ret;
634
635 info = &state->spi[busnum][cs];
636 if (!info->emul) {
637 /* Use the same device tree node as the SPI flash device */
638 debug("%s: busnum=%u, cs=%u: binding SPI flash emulation: ",
639 __func__, busnum, cs);
640 ret = sandbox_sf_bind_emul(state, busnum, cs, bus,
641 dev_of_offset(slave), slave->name);
642 if (ret) {
643 debug("failed (err=%d)\n", ret);
644 return ret;
645 }
646 debug("OK\n");
647 }
648 *emulp = info->emul;
649
650 return 0;
651 }
652
dm_scan_other(bool pre_reloc_only)653 int dm_scan_other(bool pre_reloc_only)
654 {
655 struct sandbox_state *state = state_get_current();
656 int busnum, cs;
657
658 if (pre_reloc_only)
659 return 0;
660 for (busnum = 0; busnum < CONFIG_SANDBOX_SPI_MAX_BUS; busnum++) {
661 for (cs = 0; cs < CONFIG_SANDBOX_SPI_MAX_CS; cs++) {
662 const char *spec = state->spi[busnum][cs].spec;
663 int ret;
664
665 if (spec) {
666 ret = sandbox_sf_bind_bus_cs(state, busnum,
667 cs, spec);
668 if (ret) {
669 debug("%s: Bind failed for bus %d, cs %d\n",
670 __func__, busnum, cs);
671 return ret;
672 }
673 debug("%s: Setting up spec '%s' for bus %d, cs %d\n",
674 __func__, spec, busnum, cs);
675 }
676 }
677 }
678
679 return 0;
680 }
681 #endif
682
683 static const struct udevice_id sandbox_sf_ids[] = {
684 { .compatible = "sandbox,spi-flash" },
685 { }
686 };
687
688 U_BOOT_DRIVER(sandbox_sf_emul) = {
689 .name = "sandbox_sf_emul",
690 .id = UCLASS_SPI_EMUL,
691 .of_match = sandbox_sf_ids,
692 .ofdata_to_platdata = sandbox_sf_ofdata_to_platdata,
693 .probe = sandbox_sf_probe,
694 .remove = sandbox_sf_remove,
695 .priv_auto_alloc_size = sizeof(struct sandbox_spi_flash),
696 .platdata_auto_alloc_size = sizeof(struct sandbox_spi_flash_plat_data),
697 .ops = &sandbox_sf_emul_ops,
698 };
699