dm: spi: Update sandbox SPI emulation driver to use ofnode
[platform/kernel/u-boot.git] / drivers / mtd / spi / sandbox.c
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
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  */
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
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
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
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  */
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 */
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
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
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
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
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
558 int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
559                          struct udevice *bus, ofnode node, 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_ofnode(bus, drv, str, NULL, node, &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
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
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, ofnode_null(),
624                                     spec);
625 }
626
627 int sandbox_spi_get_emul(struct sandbox_state *state,
628                          struct udevice *bus, struct udevice *slave,
629                          struct udevice **emulp)
630 {
631         struct sandbox_spi_info *info;
632         int busnum = bus->seq;
633         int cs = spi_chip_select(slave);
634         int ret;
635
636         info = &state->spi[busnum][cs];
637         if (!info->emul) {
638                 /* Use the same device tree node as the SPI flash device */
639                 debug("%s: busnum=%u, cs=%u: binding SPI flash emulation: ",
640                       __func__, busnum, cs);
641                 ret = sandbox_sf_bind_emul(state, busnum, cs, bus,
642                                            dev_ofnode(slave), slave->name);
643                 if (ret) {
644                         debug("failed (err=%d)\n", ret);
645                         return ret;
646                 }
647                 debug("OK\n");
648         }
649         *emulp = info->emul;
650
651         return 0;
652 }
653
654 int dm_scan_other(bool pre_reloc_only)
655 {
656         struct sandbox_state *state = state_get_current();
657         int busnum, cs;
658
659         if (pre_reloc_only)
660                 return 0;
661         for (busnum = 0; busnum < CONFIG_SANDBOX_SPI_MAX_BUS; busnum++) {
662                 for (cs = 0; cs < CONFIG_SANDBOX_SPI_MAX_CS; cs++) {
663                         const char *spec = state->spi[busnum][cs].spec;
664                         int ret;
665
666                         if (spec) {
667                                 ret = sandbox_sf_bind_bus_cs(state, busnum,
668                                                              cs, spec);
669                                 if (ret) {
670                                         debug("%s: Bind failed for bus %d, cs %d\n",
671                                               __func__, busnum, cs);
672                                         return ret;
673                                 }
674                                 debug("%s:  Setting up spec '%s' for bus %d, cs %d\n",
675                                       __func__, spec, busnum, cs);
676                         }
677                 }
678         }
679
680         return 0;
681 }
682 #endif
683
684 static const struct udevice_id sandbox_sf_ids[] = {
685         { .compatible = "sandbox,spi-flash" },
686         { }
687 };
688
689 U_BOOT_DRIVER(sandbox_sf_emul) = {
690         .name           = "sandbox_sf_emul",
691         .id             = UCLASS_SPI_EMUL,
692         .of_match       = sandbox_sf_ids,
693         .ofdata_to_platdata = sandbox_sf_ofdata_to_platdata,
694         .probe          = sandbox_sf_probe,
695         .remove         = sandbox_sf_remove,
696         .priv_auto_alloc_size = sizeof(struct sandbox_spi_flash),
697         .platdata_auto_alloc_size = sizeof(struct sandbox_spi_flash_plat_data),
698         .ops            = &sandbox_sf_emul_ops,
699 };