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