Index: stable/11/stand/mips/beri/boot2/boot2.c =================================================================== --- stable/11/stand/mips/beri/boot2/boot2.c (revision 329175) +++ stable/11/stand/mips/beri/boot2/boot2.c (revision 329176) @@ -1,661 +1,654 @@ /*- * Copyright (c) 2013-2014 Robert N. M. Watson * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) * ("CTSRD"), as part of the DARPA CRASH research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Copyright (c) 1998 Robert Nordier * All rights reserved. * * Redistribution and use in source and binary forms are freely * permitted provided that the above copyright notice and this * paragraph and the following disclaimer are duplicated in all * such forms. * * This software is provided "AS IS" and without any express or * implied warranties, including, without limitation, the implied * warranties of merchantability and fitness for a particular * purpose. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "paths.h" #include "rbx.h" static int beri_argc; static const char **beri_argv, **beri_envv; static uint64_t beri_memsize; #define IO_KEYBOARD 1 #define IO_SERIAL 2 #define SECOND 1 /* Circa that many ticks in a second. */ #define ARGS 0x900 #define NOPT 14 #define MEM_BASE 0x12 #define MEM_EXT 0x15 /* * XXXRW: I think this has to do with whether boot2 expects a partition * table? */ #define DRV_HARD 0x80 #define DRV_MASK 0x7f /* Default to using CFI flash. */ #define TYPE_DEFAULT BOOTINFO_DEV_TYPE_SDCARD /* Hard-coded assumption about location of JTAG-loaded kernel. */ #define DRAM_KERNEL_ADDR ((void *)mips_phys_to_cached(0x20000)) extern uint32_t _end; static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */ static const unsigned char flags[NOPT] = { RBX_DUAL, RBX_SERIAL, RBX_ASKNAME, RBX_CDROM, RBX_CONFIG, RBX_KDB, RBX_GDB, RBX_MUTE, RBX_NOINTR, RBX_PAUSE, RBX_QUIET, RBX_DFLTROOT, RBX_SINGLE, RBX_VERBOSE }; /* These must match BOOTINFO_DEV_TYPE constants. */ static const char *const dev_nm[] = {"dram", "cfi", "sdcard"}; static const u_int dev_nm_count = nitems(dev_nm); static struct dmadat __dmadat; static struct dsk { unsigned type; /* BOOTINFO_DEV_TYPE_x object type. */ uintptr_t unitptr; /* Unit number or pointer to object. */ uint8_t slice; uint8_t part; #if 0 unsigned start; int init; #endif } dsk; static char cmd[512], cmddup[512], knamebuf[1024]; static const char *kname; uint32_t opts; #if 0 static int comspeed = SIOSPD; #endif struct bootinfo bootinfo; static uint8_t ioctrl = IO_KEYBOARD; -void exit(int); void putchar(int); static void boot_fromdram(void); static void boot_fromfs(void); static void load(void); static int parse(void); static int dskread(void *, unsigned, unsigned); static int xputc(int); static int xgetc(int); #define UFS_SMALL_CGBASE #include "ufsread.c" static inline int xfsread(ufs_ino_t inode, void *buf, size_t nbyte) { if ((size_t)fsread(inode, buf, nbyte) != nbyte) { printf("Invalid %s\n", "format"); return -1; } return 0; } static inline void getstr(void) { char *s; int c; s = cmd; for (;;) { switch (c = xgetc(0)) { case 0: break; case '\177': case '\b': if (s > cmd) { s--; printf("\b \b"); } break; case '\n': case '\r': putchar('\n'); *s = 0; return; default: if (s - cmd < sizeof(cmd) - 1) *s++ = c; putchar(c); } } } int main(u_int argc, const char *argv[], const char *envv[], uint64_t memsize) { uint8_t autoboot; ufs_ino_t ino; size_t nbyte; /* Arguments from Miniboot. */ beri_argc = argc; beri_argv = argv; beri_envv = envv; beri_memsize = memsize; dmadat = &__dmadat; #if 0 /* XXXRW: more here. */ v86.ctl = V86_FLAGS; v86.efl = PSL_RESERVED_DEFAULT | PSL_I; dsk.drive = *(uint8_t *)PTOV(ARGS); #endif dsk.type = TYPE_DEFAULT; #if 0 dsk.unit = dsk.drive & DRV_MASK; dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1; #endif bootinfo.bi_version = BOOTINFO_VERSION; bootinfo.bi_size = sizeof(bootinfo); /* Process configuration file */ autoboot = 1; if ((ino = lookup(PATH_CONFIG)) || (ino = lookup(PATH_DOTCONFIG))) { nbyte = fsread(ino, cmd, sizeof(cmd) - 1); cmd[nbyte] = '\0'; } if (*cmd) { memcpy(cmddup, cmd, sizeof(cmd)); if (parse()) autoboot = 0; if (!OPT_CHECK(RBX_QUIET)) printf("%s: %s", PATH_CONFIG, cmddup); /* Do not process this command twice */ *cmd = 0; } /* * Try to exec stage 3 boot loader. If interrupted by a keypress, * or in case of failure, try to load a kernel directly instead. */ if (!kname) { kname = PATH_LOADER; if (autoboot && !keyhit(3*SECOND)) { boot_fromfs(); kname = PATH_KERNEL; } } /* Present the user with the boot2 prompt. */ for (;;) { if (!autoboot || !OPT_CHECK(RBX_QUIET)) printf("\nFreeBSD/mips boot\n" "Default: %s%ju:%s\n" "boot: ", dev_nm[dsk.type], dsk.unitptr, kname); #if 0 if (ioctrl & IO_SERIAL) sio_flush(); #endif if (!autoboot || keyhit(3*SECOND)) getstr(); else if (!autoboot || !OPT_CHECK(RBX_QUIET)) putchar('\n'); autoboot = 0; if (parse()) putchar('\a'); else load(); } -} - -/* XXX - Needed for btxld to link the boot2 binary; do not remove. */ -void -exit(int x) -{ } static void boot(void *entryp, int argc, const char *argv[], const char *envv[]) { bootinfo.bi_kernelname = (bi_ptr_t)kname; bootinfo.bi_boot2opts = opts & RBX_MASK; bootinfo.bi_boot_dev_type = dsk.type; bootinfo.bi_boot_dev_unitptr = dsk.unitptr; bootinfo.bi_memsize = beri_memsize; #if 0 /* * XXXRW: A possible future way to distinguish Miniboot passing a memory * size vs DTB..? */ if (beri_memsize <= BERI_MEMVSDTB) bootinfo.bi_memsize = beri_memsize; else bootinfo.bi_dtb = beri_memsize; #endif ((void(*)(int, const char **, const char **, void *))entryp)(argc, argv, envv, &bootinfo); } /* * Boot a kernel that has mysteriously (i.e., by JTAG) appeared in DRAM; * assume that it is already properly relocated, etc, and invoke its entry * address without question or concern. */ static void boot_fromdram(void) { void *kaddr = DRAM_KERNEL_ADDR; /* XXXRW: Something better here. */ Elf64_Ehdr *ehp = kaddr; if (!IS_ELF(*ehp)) { printf("Invalid %s\n", "format"); return; } boot((void *)ehp->e_entry, beri_argc, beri_argv, beri_envv); } static void boot_fromfs(void) { union { Elf64_Ehdr eh; } hdr; static Elf64_Phdr ep[2]; #if 0 static Elf64_Shdr es[2]; #endif caddr_t p; ufs_ino_t ino; uint64_t addr; int i, j; if (!(ino = lookup(kname))) { if (!ls) printf("No %s\n", kname); return; } if (xfsread(ino, &hdr, sizeof(hdr))) return; if (IS_ELF(hdr.eh)) { fs_off = hdr.eh.e_phoff; for (j = i = 0; i < hdr.eh.e_phnum && j < 2; i++) { if (xfsread(ino, ep + j, sizeof(ep[0]))) return; if (ep[j].p_type == PT_LOAD) j++; } for (i = 0; i < 2; i++) { p = (caddr_t)ep[i].p_paddr; fs_off = ep[i].p_offset; if (xfsread(ino, p, ep[i].p_filesz)) return; } p += roundup2(ep[1].p_memsz, PAGE_SIZE); #if 0 bootinfo.bi_symtab = VTOP(p); if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) { fs_off = hdr.eh.e_shoff + sizeof(es[0]) * (hdr.eh.e_shstrndx + 1); if (xfsread(ino, &es, sizeof(es))) return; for (i = 0; i < 2; i++) { *(Elf32_Word *)p = es[i].sh_size; p += sizeof(es[i].sh_size); fs_off = es[i].sh_offset; if (xfsread(ino, p, es[i].sh_size)) return; p += es[i].sh_size; } } #endif addr = hdr.eh.e_entry; #if 0 bootinfo.bi_esymtab = VTOP(p); #endif } else { printf("Invalid %s\n", "format"); return; } boot((void *)addr, beri_argc, beri_argv, beri_envv); } static void load(void) { switch (dsk.type) { case BOOTINFO_DEV_TYPE_DRAM: boot_fromdram(); break; default: boot_fromfs(); break; } } static int parse() { char *arg = cmd; char *ep, *p, *q; char unit; size_t len; const char *cp; #if 0 int c, i, j; #else int c, i; #endif while ((c = *arg++)) { if (c == ' ' || c == '\t' || c == '\n') continue; for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++); ep = p; if (*p) *p++ = 0; if (c == '-') { while ((c = *arg++)) { if (c == 'P') { cp = "yes"; #if 0 } else { opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL); cp = "no"; } #endif printf("Keyboard: %s\n", cp); continue; #if 0 } else if (c == 'S') { j = 0; while ((unsigned int)(i = *arg++ - '0') <= 9) j = j * 10 + i; if (j > 0 && i == -'0') { comspeed = j; break; } /* Fall through to error below ('S' not in optstr[]). */ #endif } for (i = 0; c != optstr[i]; i++) if (i == NOPT - 1) return -1; opts ^= OPT_SET(flags[i]); } ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) : OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD; #if 0 if (ioctrl & IO_SERIAL) { if (sio_init(115200 / comspeed) != 0) ioctrl &= ~IO_SERIAL; } #endif } else { /*- * Parse a device/kernel name. Format(s): * * path * deviceX:path * * NB: Utterly incomprehensible but space-efficient ARM/i386 * parsing removed in favour of larger but easier-to-read C. This * is still not great, however -- e.g., relating to unit handling. * * TODO: it would be nice if a DRAM pointer could be specified * here. * * XXXRW: Pick up pieces here. */ /* * Search for a parens; if none, then it's just a path. * Otherwise, it's a devicename. */ arg--; q = strsep(&arg, ":"); if (arg != NULL) { len = strlen(q); if (len < 2) { printf("Invalid device: name too short\n"); return (-1); } /* * First, handle one-digit unit. */ unit = q[len-1]; if (unit < '0' || unit > '9') { printf("Invalid device: invalid unit %c\n", unit); return (-1); } unit -= '0'; q[len-1] = '\0'; /* * Next, find matching device. */ for (i = 0; i < dev_nm_count; i++) { if (strcmp(q, dev_nm[i]) == 0) break; } if (i == dev_nm_count) { printf("Invalid device: no driver match\n"); return (-1); } dsk.type = i; dsk.unitptr = unit; /* Someday: also a DRAM pointer? */ } else arg = q; if ((i = ep - arg)) { if ((size_t)i >= sizeof(knamebuf)) return -1; memcpy(knamebuf, arg, i + 1); kname = knamebuf; } } arg = p; } return 0; } static int drvread(void *buf, unsigned lba, unsigned nblk) { /* XXXRW: eventually, we may want to pass 'drive' and 'unit' here. */ switch (dsk.type) { case BOOTINFO_DEV_TYPE_CFI: return (cfi_read(buf, lba, nblk)); case BOOTINFO_DEV_TYPE_SDCARD: return (altera_sdcard_read(buf, lba, nblk)); default: return (-1); } } static int dskread(void *buf, unsigned lba, unsigned nblk) { #if 0 /* * XXXRW: For now, assume no partition table around the file system; it's * just in raw flash. */ struct dos_partition *dp; struct disklabel *d; char *sec; unsigned i; uint8_t sl; if (!dsk_meta) { sec = dmadat->secbuf; dsk.start = 0; if (drvread(sec, DOSBBSECTOR, 1)) return -1; dp = (void *)(sec + DOSPARTOFF); sl = dsk.slice; if (sl < BASE_SLICE) { for (i = 0; i < NDOSPART; i++) if (dp[i].dp_typ == DOSPTYP_386BSD && (dp[i].dp_flag & 0x80 || sl < BASE_SLICE)) { sl = BASE_SLICE + i; if (dp[i].dp_flag & 0x80 || dsk.slice == COMPATIBILITY_SLICE) break; } if (dsk.slice == WHOLE_DISK_SLICE) dsk.slice = sl; } if (sl != WHOLE_DISK_SLICE) { if (sl != COMPATIBILITY_SLICE) dp += sl - BASE_SLICE; if (dp->dp_typ != DOSPTYP_386BSD) { printf("Invalid %s\n", "slice"); return -1; } dsk.start = le32toh(dp->dp_start); } if (drvread(sec, dsk.start + LABELSECTOR, 1)) return -1; d = (void *)(sec + LABELOFFSET); if (le32toh(d->d_magic) != DISKMAGIC || le32toh(d->d_magic2) != DISKMAGIC) { if (dsk.part != RAW_PART) { printf("Invalid %s\n", "label"); return -1; } } else { if (!dsk.init) { if (le16toh(d->d_type) == DTYPE_SCSI) dsk.type = TYPE_DA; dsk.init++; } if (dsk.part >= le16toh(d->d_npartitions) || !(le32toh(d->d_partitions[dsk.part].p_size))) { printf("Invalid %s\n", "partition"); return -1; } dsk.start += le32toh(d->d_partitions[dsk.part].p_offset); dsk.start -= le32toh(d->d_partitions[RAW_PART].p_offset); } } return drvread(buf, dsk.start + lba, nblk); #else return drvread(buf, lba, nblk); #endif } void putchar(int c) { if (c == '\n') xputc('\r'); xputc(c); } static int xputc(int c) { if (ioctrl & IO_KEYBOARD) putc(c); #if 0 if (ioctrl & IO_SERIAL) sio_putc(c); #endif return c; } static int xgetc(int fn) { if (OPT_CHECK(RBX_NOINTR)) return 0; for (;;) { if (ioctrl & IO_KEYBOARD && keyhit(0)) return fn ? 1 : getc(); #if 0 if (ioctrl & IO_SERIAL && sio_ischar()) return fn ? 1 : sio_getc(); #endif if (fn) return 0; } } Index: stable/11/stand/mips/beri/common/sdcard.c =================================================================== --- stable/11/stand/mips/beri/common/sdcard.c (revision 329175) +++ stable/11/stand/mips/beri/common/sdcard.c (revision 329176) @@ -1,334 +1,333 @@ /*- * Copyright (c) 2012-2014 Robert N. M. Watson * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) * ("CTSRD"), as part of the DARPA CRASH research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include -#include -#include +#include /* * Altera University Program SD Card micro-driver for boot2 and loader. * * XXXRW: It might be nice to add 'unit' arguments to all APIs to allow * multiple instances to be addressed. */ /* Constants lifted from altera_sdcard.h -- possibly we should share headers? */ #define ALTERA_SDCARD_OFF_RXTX_BUFFER 0 /* 512-byte I/O buffer */ #define ALTERA_SDCARD_OFF_CID 512 /* 16-byte Card ID number */ #define ALTERA_SDCARD_OFF_CSD 528 /* 16-byte Card Specific Data */ #define ALTERA_SDCARD_OFF_OCR 544 /* Operating Conditions Reg */ #define ALTERA_SDCARD_OFF_SR 548 /* SD Card Status Register */ #define ALTERA_SDCARD_OFF_RCA 552 /* Relative Card Address Reg */ #define ALTERA_SDCARD_OFF_CMD_ARG 556 /* Command Argument Register */ #define ALTERA_SDCARD_OFF_CMD 560 /* Command Register */ #define ALTERA_SDCARD_OFF_ASR 564 /* Auxiliary Status Register */ #define ALTERA_SDCARD_OFF_RR1 568 /* Response R1 */ #define ALTERA_SDCARD_SECTORSIZE 512 #define ALTERA_SDCARD_CMD_SEND_RCA 0x03 /* Retrieve card RCA. */ #define ALTERA_SDCARD_CMD_SEND_CSD 0x09 /* Retrieve CSD register. */ #define ALTERA_SDCARD_CMD_SEND_CID 0x0A /* Retrieve CID register. */ #define ALTERA_SDCARD_CMD_READ_BLOCK 0x11 /* Read block from disk. */ #define ALTERA_SDCARD_CMD_WRITE_BLOCK 0x18 /* Write block to disk. */ #define ALTERA_SDCARD_ASR_CMDVALID 0x0001 #define ALTERA_SDCARD_ASR_CARDPRESENT 0x0002 #define ALTERA_SDCARD_ASR_CMDINPROGRESS 0x0004 #define ALTERA_SDCARD_ASR_SRVALID 0x0008 #define ALTERA_SDCARD_ASR_CMDTIMEOUT 0x0010 #define ALTERA_SDCARD_ASR_CMDDATAERROR 0x0020 #define ALTERA_SDCARD_RR1_INITPROCRUNNING 0x0100 #define ALTERA_SDCARD_RR1_ERASEINTERRUPTED 0x0200 #define ALTERA_SDCARD_RR1_ILLEGALCOMMAND 0x0400 #define ALTERA_SDCARD_RR1_COMMANDCRCFAILED 0x0800 #define ALTERA_SDCARD_RR1_ADDRESSMISALIGNED 0x1000 #define ALTERA_SDCARD_RR1_ADDRBLOCKRANGE 0x2000 #define ALTERA_SDCARD_CSD_STRUCTURE_BYTE 15 #define ALTERA_SDCARD_CSD_STRUCTURE_MASK 0xc0 /* 2 bits */ #define ALTERA_SDCARD_CSD_STRUCTURE_RSHIFT 6 #define ALTERA_SDCARD_CSD_SIZE 16 #define ALTERA_SDCARD_CSD_READ_BL_LEN_BYTE 10 #define ALTERA_SDCARD_CSD_READ_BL_LEN_MASK 0x0f /* 4 bits */ #define ALTERA_SDCARD_CSD_C_SIZE_BYTE0 7 #define ALTERA_SDCARD_CSD_C_SIZE_MASK0 0xc0 /* top 2 bits */ #define ALTERA_SDCARD_CSD_C_SIZE_RSHIFT0 6 #define ALTERA_SDCARD_CSD_C_SIZE_BYTE1 8 #define ALTERA_SDCARD_CSD_C_SIZE_MASK1 0xff /* 8 bits */ #define ALTERA_SDCARD_CSD_C_SIZE_LSHIFT1 2 #define ALTERA_SDCARD_CSD_C_SIZE_BYTE2 9 #define ALTERA_SDCARD_CSD_C_SIZE_MASK2 0x03 /* bottom 2 bits */ #define ALTERA_SDCARD_CSD_C_SIZE_LSHIFT2 10 #define ALTERA_SDCARD_CSD_C_SIZE_MULT_BYTE0 5 #define ALTERA_SDCARD_CSD_C_SIZE_MULT_MASK0 0x80 /* top 1 bit */ #define ALTERA_SDCARD_CSD_C_SIZE_MULT_RSHIFT0 7 #define ALTERA_SDCARD_CSD_C_SIZE_MULT_BYTE1 6 #define ALTERA_SDCARD_CSD_C_SIZE_MULT_MASK1 0x03 /* bottom 2 bits */ #define ALTERA_SDCARD_CSD_C_SIZE_MULT_LSHIFT1 1 /* * Not all RR1 values are "errors" per se -- check only for the ones that are * when performing error handling. */ #define ALTERA_SDCARD_RR1_ERRORMASK \ (ALTERA_SDCARD_RR1_ERASEINTERRUPTED | ALTERA_SDCARD_RR1_ILLEGALCOMMAND | \ ALTERA_SDCARD_RR1_COMMANDCRCFAILED | ALTERA_SDCARD_RR1_ADDRESSMISALIGNED |\ ALTERA_SDCARD_RR1_ADDRBLOCKRANGE) extern uint8_t __cheri_sdcard_vaddr__[]; #define ALTERA_SDCARD_PTR(type, offset) \ (volatile type *)(&__cheri_sdcard_vaddr__[(offset)]) static __inline uint16_t altera_sdcard_read_uint16(u_int offset) { volatile uint16_t *p; p = ALTERA_SDCARD_PTR(uint16_t, offset); return (le16toh(*p)); } static __inline void altera_sdcard_write_uint16(u_int offset, uint16_t v) { volatile uint16_t *p; p = ALTERA_SDCARD_PTR(uint16_t, offset); *p = htole16(v); } static __inline void altera_sdcard_write_uint32(u_int offset, uint32_t v) { volatile uint32_t *p; p = ALTERA_SDCARD_PTR(uint32_t, offset); *p = htole32(v); } static __inline uint16_t altera_sdcard_read_asr(void) { return (altera_sdcard_read_uint16(ALTERA_SDCARD_OFF_ASR)); } static __inline uint16_t altera_sdcard_read_rr1(void) { return (altera_sdcard_read_uint16(ALTERA_SDCARD_OFF_RR1)); } static __inline void altera_sdcard_write_cmd(uint16_t cmd) { altera_sdcard_write_uint16(ALTERA_SDCARD_OFF_CMD, cmd); } static __inline void altera_sdcard_write_cmd_arg(uint32_t cmd_arg) { altera_sdcard_write_uint32(ALTERA_SDCARD_OFF_CMD_ARG, cmd_arg); } /* NB: Use 16-bit aligned buffer due to hardware features, so 16-bit type. */ static __inline void altera_sdcard_read_csd(uint16_t *csdp) { volatile uint16_t *hw_csdp; u_int i; hw_csdp = ALTERA_SDCARD_PTR(uint16_t, ALTERA_SDCARD_OFF_CSD); for (i = 0; i < ALTERA_SDCARD_CSD_SIZE / sizeof(uint16_t); i++) csdp[i] = hw_csdp[i]; } /* * Private interface: load exactly one block of size ALTERA_SDCARD_SECTORSIZE * from block #lba. */ static int altera_sdcard_read_block(void *buf, unsigned lba) { volatile uint32_t *rxtxp; uint32_t *bufp; uint16_t asr, rr1; int i; if (!(altera_sdcard_read_asr() & ALTERA_SDCARD_ASR_CARDPRESENT)) { printf("SD Card: card not present\n"); return (-1); } bufp = (uint32_t *)buf; rxtxp = ALTERA_SDCARD_PTR(uint32_t, ALTERA_SDCARD_OFF_RXTX_BUFFER); /* * Issue read block command. */ altera_sdcard_write_cmd_arg(lba * ALTERA_SDCARD_SECTORSIZE); altera_sdcard_write_cmd(ALTERA_SDCARD_CMD_READ_BLOCK); /* * Wait for device to signal completion of command. */ while ((asr = altera_sdcard_read_asr()) & ALTERA_SDCARD_ASR_CMDINPROGRESS); /* * Due to hardware bugs/features, interpretting this field is messy. */ rr1 = altera_sdcard_read_rr1(); rr1 &= ~ALTERA_SDCARD_RR1_COMMANDCRCFAILED; /* HW bug. */ if (asr & ALTERA_SDCARD_ASR_CMDTIMEOUT) { printf("SD Card: timeout\n"); return (-1); } if ((asr & ALTERA_SDCARD_ASR_CMDDATAERROR) && (rr1 & ALTERA_SDCARD_RR1_ERRORMASK)) { printf("SD Card: asr %u rr1 %u\n", asr, rr1); return (-1); } /* * We can't use a regular memcpy() due to byte-enable bugs in the * Altera IP core: instead copy in 32-bit units. */ for (i = 0; i < ALTERA_SDCARD_SECTORSIZE/sizeof(uint32_t); i++) bufp[i] = rxtxp[i]; return (0); } /* * Public interface: load 'nblk' blocks from block #lba into *buf. */ int altera_sdcard_read(void *buf, unsigned lba, unsigned nblk) { uint8_t *bufp = buf; int i; for (i = 0; i < nblk; i++) { if (altera_sdcard_read_block(bufp + i * ALTERA_SDCARD_SECTORSIZE, lba + i) < 0) { printf("SD Card: block read %u failed\n", i); return (-1); } } return (0); } /* * Public interface: query (current) media size. */ uint64_t altera_sdcard_get_mediasize(void) { uint64_t mediasize; uint64_t c_size, c_size_mult, read_bl_len; uint16_t csd16[ALTERA_SDCARD_CSD_SIZE/sizeof(uint16_t)]; uint8_t *csd8p = (uint8_t *)&csd16; uint8_t byte0, byte1, byte2; altera_sdcard_read_csd(csd16); /* Provide 16-bit alignment. */ read_bl_len = csd8p[ALTERA_SDCARD_CSD_READ_BL_LEN_BYTE]; read_bl_len &= ALTERA_SDCARD_CSD_READ_BL_LEN_MASK; byte0 = csd8p[ALTERA_SDCARD_CSD_C_SIZE_BYTE0]; byte0 &= ALTERA_SDCARD_CSD_C_SIZE_MASK0; byte1 = csd8p[ALTERA_SDCARD_CSD_C_SIZE_BYTE1]; byte2 = csd8p[ALTERA_SDCARD_CSD_C_SIZE_BYTE2]; byte2 &= ALTERA_SDCARD_CSD_C_SIZE_MASK2; c_size = (byte0 >> ALTERA_SDCARD_CSD_C_SIZE_RSHIFT0) | (byte1 << ALTERA_SDCARD_CSD_C_SIZE_LSHIFT1) | (byte2 << ALTERA_SDCARD_CSD_C_SIZE_LSHIFT2); byte0 = csd8p[ALTERA_SDCARD_CSD_C_SIZE_MULT_BYTE0]; byte0 &= ALTERA_SDCARD_CSD_C_SIZE_MULT_MASK0; byte1 = csd8p[ALTERA_SDCARD_CSD_C_SIZE_MULT_BYTE1]; byte1 &= ALTERA_SDCARD_CSD_C_SIZE_MULT_MASK1; c_size_mult = (byte0 >> ALTERA_SDCARD_CSD_C_SIZE_MULT_RSHIFT0) | (byte1 << ALTERA_SDCARD_CSD_C_SIZE_MULT_LSHIFT1); mediasize = (c_size + 1) * (1 << (c_size_mult + 2)) * (1 << read_bl_len); return (mediasize); } /* * Public interface: is media present / supported? */ int altera_sdcard_get_present(void) { uint16_t csd16[ALTERA_SDCARD_CSD_SIZE/sizeof(uint16_t)]; uint8_t *csd8p = (uint8_t *)&csd16; uint8_t csd_structure; /* First: does status bit think it is there? */ if (!(altera_sdcard_read_asr() & ALTERA_SDCARD_ASR_CARDPRESENT)) { printf("SD Card: not present\n"); return (0); } /* Second: do we understand the CSD structure version? */ altera_sdcard_read_csd(csd16); /* Provide 16-bit alignment. */ csd_structure = csd8p[ALTERA_SDCARD_CSD_STRUCTURE_BYTE]; csd_structure &= ALTERA_SDCARD_CSD_STRUCTURE_MASK; csd_structure >>= ALTERA_SDCARD_CSD_STRUCTURE_RSHIFT; if (csd_structure != 0) { printf("SD Card: unrecognised csd %u\n", csd_structure); return (0); } return (1); } /* * Public interface: query sector size. */ uint64_t altera_sdcard_get_sectorsize(void) { return (ALTERA_SDCARD_SECTORSIZE); } Index: stable/11 =================================================================== --- stable/11 (revision 329175) +++ stable/11 (revision 329176) Property changes on: stable/11 ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head:r327705,328447