/* $NetBSD: cfi.c,v 1.9 2019/02/06 04:20:40 mrg Exp $ */ /*- * Copyright (c) 2011 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Cliff Neighbors. * * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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. */ #include "opt_flash.h" #include "opt_nor.h" #include "opt_cfi.h" #include __KERNEL_RCSID(0, "$NetBSD: cfi.c,v 1.9 2019/02/06 04:20:40 mrg Exp $"); #include #include #include #include #include #include #include #include #include static int cfi_scan_media(device_t self, struct nor_chip *chip); static void cfi_init(device_t); static void cfi_select(device_t, bool); static void cfi_read_1(device_t, flash_off_t, uint8_t *); static void cfi_read_2(device_t, flash_off_t, uint16_t *); static void cfi_read_4(device_t, flash_off_t, uint32_t *); static void cfi_read_buf_1(device_t, flash_off_t, uint8_t *, size_t); static void cfi_read_buf_2(device_t, flash_off_t, uint16_t *, size_t); static void cfi_read_buf_4(device_t, flash_off_t, uint32_t *, size_t); static void cfi_write_1(device_t, flash_off_t, uint8_t); static void cfi_write_2(device_t, flash_off_t, uint16_t); static void cfi_write_4(device_t, flash_off_t, uint32_t); static void cfi_write_buf_1(device_t, flash_off_t, const uint8_t *, size_t); static void cfi_write_buf_2(device_t, flash_off_t, const uint16_t *, size_t); static void cfi_write_buf_4(device_t, flash_off_t, const uint32_t *, size_t); static uint8_t cfi_read_qry(struct cfi * const, bus_size_t); static bool cfi_jedec_id(struct cfi * const); static bool cfi_emulate(struct cfi * const); static const struct cfi_jedec_tab * cfi_jedec_search(struct cfi *); static void cfi_jedec_fill(struct cfi * const, const struct cfi_jedec_tab *); #if defined(CFI_DEBUG_JEDEC) || defined(CFI_DEBUG_QRY) static void cfi_hexdump(flash_off_t, void * const, u_int, u_int); #endif #define LOG2_64K 16 #define LOG2_128K 17 #define LOG2_256K 18 #define LOG2_512K 19 #define LOG2_1M 20 #define LOG2_2M 21 #define LOG2_4M 22 #define LOG2_8M 23 #define LOG2_16M 24 #define LOG2_32M 25 #define LOG2_64M 26 #define LOG2_128M 27 #define LOG2_256M 28 #define LOG2_512M 29 #define LOG2_1G 30 #define LOG2_2G 31 const struct cfi_jedec_tab cfi_jedec_tab[] = { { .jt_name = "Pm39LV512", .jt_mid = 0x9d, .jt_did = 0x1b, .jt_id_pri = 0, /* XXX */ .jt_id_alt = 0, /* XXX */ .jt_device_size = LOG2_64K, .jt_interface_code_desc = CFI_IFCODE_X8, .jt_erase_blk_regions = 1, .jt_erase_blk_info = { { 4096/256, (64/4)-1 }, }, .jt_write_word_time_typ = 40, .jt_write_nbyte_time_typ = 0, .jt_erase_blk_time_typ = 55, .jt_erase_chip_time_typ = 55, .jt_write_word_time_max = 1, .jt_write_nbyte_time_max = 0, .jt_erase_blk_time_max = 1, .jt_erase_chip_time_max = 1, }, { .jt_name = "Pm39LV010", .jt_mid = 0x9d, .jt_did = 0x1c, .jt_id_pri = 0, /* XXX */ .jt_id_alt = 0, /* XXX */ .jt_device_size = LOG2_128K, .jt_interface_code_desc = CFI_IFCODE_X8, .jt_erase_blk_regions = 1, .jt_erase_blk_info = { { 4096/256, (128/4)-1 }, }, .jt_write_word_time_typ = 40, .jt_write_nbyte_time_typ = 0, .jt_erase_blk_time_typ = 55, .jt_erase_chip_time_typ = 55, .jt_write_word_time_max = 1, .jt_write_nbyte_time_max = 0, .jt_erase_blk_time_max = 1, .jt_erase_chip_time_max = 1, }, }; const struct nor_interface nor_interface_cfi = { .scan_media = cfi_scan_media, .init = cfi_init, .select = cfi_select, .read_1 = cfi_read_1, .read_2 = cfi_read_2, .read_4 = cfi_read_4, .read_buf_1 = cfi_read_buf_1, .read_buf_2 = cfi_read_buf_2, .read_buf_4 = cfi_read_buf_4, .write_1 = cfi_write_1, .write_2 = cfi_write_2, .write_4 = cfi_write_4, .write_buf_1 = cfi_write_buf_1, .write_buf_2 = cfi_write_buf_2, .write_buf_4 = cfi_write_buf_4, .read_page = NULL, /* cmdset */ .program_page = NULL, /* cmdset */ .busy = NULL, .private = NULL, .access_width = -1, .part_info = NULL, .part_num = -1, }; /* only data[7..0] are used regardless of chip width */ #define cfi_unpack_1(n) ((n) & 0xff) /* construct uint16_t */ #define cfi_unpack_2(b0, b1) \ ((cfi_unpack_1(b1) << 8) | cfi_unpack_1(b0)) /* construct uint32_t */ #define cfi_unpack_4(b0, b1, b2, b3) \ ((cfi_unpack_1(b3) << 24) | \ (cfi_unpack_1(b2) << 16) | \ (cfi_unpack_1(b1) << 8) | \ (cfi_unpack_1(b0))) #define cfi_unpack_qry(qryp, data) \ do { \ (qryp)->qry[0] = cfi_unpack_1(data[0x10]); \ (qryp)->qry[1] = cfi_unpack_1(data[0x11]); \ (qryp)->qry[2] = cfi_unpack_1(data[0x12]); \ (qryp)->id_pri = cfi_unpack_2(data[0x13], data[0x14]); \ (qryp)->addr_pri = cfi_unpack_2(data[0x15], data[0x16]); \ (qryp)->id_alt = cfi_unpack_2(data[0x17], data[0x18]); \ (qryp)->addr_alt = cfi_unpack_2(data[0x19], data[0x1a]); \ (qryp)->vcc_min = cfi_unpack_1(data[0x1b]); \ (qryp)->vcc_max = cfi_unpack_1(data[0x1c]); \ (qryp)->vpp_min = cfi_unpack_1(data[0x1d]); \ (qryp)->vpp_max = cfi_unpack_1(data[0x1e]); \ (qryp)->write_word_time_typ = cfi_unpack_1(data[0x1f]); \ (qryp)->write_nbyte_time_typ = cfi_unpack_1(data[0x20]); \ (qryp)->erase_blk_time_typ = cfi_unpack_1(data[0x21]); \ (qryp)->erase_chip_time_typ = cfi_unpack_1(data[0x22]); \ (qryp)->write_word_time_max = cfi_unpack_1(data[0x23]); \ (qryp)->write_nbyte_time_max = cfi_unpack_1(data[0x24]); \ (qryp)->erase_blk_time_max = cfi_unpack_1(data[0x25]); \ (qryp)->erase_chip_time_max = cfi_unpack_1(data[0x26]); \ (qryp)->device_size = cfi_unpack_1(data[0x27]); \ (qryp)->interface_code_desc = \ cfi_unpack_2(data[0x28], data[0x29]); \ (qryp)->write_nbyte_size_max = \ cfi_unpack_2(data[0x2a], data[0x2b]); \ (qryp)->erase_blk_regions = cfi_unpack_1(data[0x2c]); \ u_int _i = 0x2d; \ const u_int _n = (qryp)->erase_blk_regions; \ KASSERT(_n <= 4); \ for (u_int _r = 0; _r < _n; _r++, _i+=4) { \ (qryp)->erase_blk_info[_r].y = \ cfi_unpack_2(data[_i+0], data[_i+1]); \ (qryp)->erase_blk_info[_r].z = \ cfi_unpack_2(data[_i+2], data[_i+3]); \ } \ } while (0) #define cfi_unpack_pri_0002(qryp, data) \ do { \ (qryp)->pri.cmd_0002.pri[0] = cfi_unpack_1(data[0x00]); \ (qryp)->pri.cmd_0002.pri[1] = cfi_unpack_1(data[0x01]); \ (qryp)->pri.cmd_0002.pri[2] = cfi_unpack_1(data[0x02]); \ (qryp)->pri.cmd_0002.version_maj = cfi_unpack_1(data[0x03]); \ (qryp)->pri.cmd_0002.version_min = cfi_unpack_1(data[0x04]); \ (qryp)->pri.cmd_0002.asupt = cfi_unpack_1(data[0x05]); \ (qryp)->pri.cmd_0002.erase_susp = cfi_unpack_1(data[0x06]); \ (qryp)->pri.cmd_0002.sector_prot = cfi_unpack_1(data[0x07]); \ (qryp)->pri.cmd_0002.tmp_sector_unprot = \ cfi_unpack_1(data[0x08]); \ (qryp)->pri.cmd_0002.sector_prot_scheme = \ cfi_unpack_1(data[0x09]); \ (qryp)->pri.cmd_0002.simul_op = cfi_unpack_1(data[0x0a]); \ (qryp)->pri.cmd_0002.burst_mode_type = cfi_unpack_1(data[0x0b]);\ (qryp)->pri.cmd_0002.page_mode_type = cfi_unpack_1(data[0x0c]); \ (qryp)->pri.cmd_0002.acc_min = cfi_unpack_1(data[0x0d]); \ (qryp)->pri.cmd_0002.acc_max = cfi_unpack_1(data[0x0e]); \ (qryp)->pri.cmd_0002.wp_prot = cfi_unpack_1(data[0x0f]); \ /* XXX 1.3 stops here */ \ (qryp)->pri.cmd_0002.prog_susp = cfi_unpack_1(data[0x10]); \ (qryp)->pri.cmd_0002.unlock_bypass = cfi_unpack_1(data[0x11]); \ (qryp)->pri.cmd_0002.sss_size = cfi_unpack_1(data[0x12]); \ (qryp)->pri.cmd_0002.soft_feat = cfi_unpack_1(data[0x13]); \ (qryp)->pri.cmd_0002.page_size = cfi_unpack_1(data[0x14]); \ (qryp)->pri.cmd_0002.erase_susp_time_max = \ cfi_unpack_1(data[0x15]); \ (qryp)->pri.cmd_0002.prog_susp_time_max = \ cfi_unpack_1(data[0x16]); \ (qryp)->pri.cmd_0002.embhwrst_time_max = \ cfi_unpack_1(data[0x38]); \ (qryp)->pri.cmd_0002.hwrst_time_max = \ cfi_unpack_1(data[0x39]); \ } while (0) #define CFI_QRY_UNPACK_COMMON(cfi, data, type) \ do { \ struct cfi_query_data * const qryp = &cfi->cfi_qry_data; \ \ memset(qryp, 0, sizeof(*qryp)); \ cfi_unpack_qry(qryp, data); \ \ switch (qryp->id_pri) { \ case 0x0002: \ if ((cfi_unpack_1(data[qryp->addr_pri + 0]) == 'P') && \ (cfi_unpack_1(data[qryp->addr_pri + 1]) == 'R') && \ (cfi_unpack_1(data[qryp->addr_pri + 2]) == 'I')) { \ type *pri_data = &data[qryp->addr_pri]; \ cfi_unpack_pri_0002(qryp, pri_data); \ break; \ } \ } \ } while (0) #ifdef CFI_DEBUG_QRY # define CFI_DUMP_QRY(off, p, sz, stride) \ do { \ printf("%s: QRY data\n", __func__); \ cfi_hexdump(off, p, sz, stride); \ } while (0) #else # define CFI_DUMP_QRY(off, p, sz, stride) #endif #ifdef CFI_DEBUG_JEDEC # define CFI_DUMP_JEDEC(off, p, sz, stride) \ do { \ printf("%s: JEDEC data\n", __func__); \ cfi_hexdump(off, p, sz, stride); \ } while (0) #else # define CFI_DUMP_JEDEC(off, p, sz, stride) #endif static void cfi_chip_query_1(struct cfi * const cfi) { uint8_t data[0x80]; bus_space_read_region_1(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_QRY(0, data, sizeof(data), 1); CFI_QRY_UNPACK_COMMON(cfi, data, uint8_t); } static void cfi_chip_query_2(struct cfi * const cfi) { uint16_t data[0x80]; bus_space_read_region_2(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_QRY(0, data, sizeof(data), 2); CFI_QRY_UNPACK_COMMON(cfi, data, uint16_t); } static void cfi_chip_query_4(struct cfi * const cfi) { uint32_t data[0x80]; bus_space_read_region_4(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_QRY(0, data, sizeof(data), 4); CFI_QRY_UNPACK_COMMON(cfi, data, uint32_t); } static void cfi_chip_query_8(struct cfi * const cfi) { #ifdef NOTYET uint64_t data[0x80]; bus_space_read_region_8(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_QRY(0, data, sizeof(data), 8); CFI_QRY_UNPACK_COMMON(cfi, data, uint64_t); #endif } /* * cfi_chip_query - detect a CFI chip * * fill in the struct cfi as we discover what's there */ static bool cfi_chip_query(struct cfi * const cfi) { const bus_size_t cfi_query_offset[] = { CFI_QUERY_MODE_ADDR, CFI_QUERY_MODE_ALT_ADDR }; KASSERT(cfi != NULL); KASSERT(cfi->cfi_bst != NULL); for (int j=0; j < __arraycount(cfi_query_offset); j++) { cfi_reset_default(cfi); cfi_cmd(cfi, cfi_query_offset[j], CFI_QUERY_DATA); if (cfi_read_qry(cfi, 0x10) == 'Q' && cfi_read_qry(cfi, 0x11) == 'R' && cfi_read_qry(cfi, 0x12) == 'Y') { switch(cfi->cfi_portwidth) { case 0: cfi_chip_query_1(cfi); break; case 1: cfi_chip_query_2(cfi); break; case 2: cfi_chip_query_4(cfi); break; case 3: cfi_chip_query_8(cfi); break; default: panic("%s: bad portwidth %d\n", __func__, cfi->cfi_portwidth); } switch (cfi->cfi_qry_data.id_pri) { case 0x0002: cfi->cfi_unlock_addr1 = CFI_AMD_UNLOCK_ADDR1; cfi->cfi_unlock_addr2 = CFI_AMD_UNLOCK_ADDR2; break; default: DPRINTF(("%s: unsupported CFI cmdset %#04x\n", __func__, cfi->cfi_qry_data.id_pri)); return false; } cfi->cfi_emulated = false; return true; } } return false; } /* * cfi_probe - search for a CFI NOR trying various port & chip widths * * - gather CFI QRY and PRI data * - gather JEDEC ID data * - if cfi_chip_query() fails, emulate CFI using table data if possible, * otherwise fail. * * NOTE: * striped NOR chips design not supported yet */ bool cfi_probe(struct cfi * const cfi) { bool found; KASSERT(cfi != NULL); /* XXX set default unlock address for cfi_jedec_id() */ cfi->cfi_unlock_addr1 = CFI_AMD_UNLOCK_ADDR1; cfi->cfi_unlock_addr2 = CFI_AMD_UNLOCK_ADDR2; for (u_int pw = 0; pw < 3; pw++) { for (u_int cw = 0; cw <= pw; cw++) { cfi->cfi_portwidth = pw; cfi->cfi_chipwidth = cw; found = cfi_chip_query(cfi); cfi_jedec_id(cfi); if (! found) found = cfi_emulate(cfi); if (found) goto exit_qry; } } exit_qry: cfi_reset_default(cfi); /* exit QRY mode */ return found; } bool cfi_identify(struct cfi * const cfi) { const bus_space_tag_t bst = cfi->cfi_bst; const bus_space_handle_t bsh = cfi->cfi_bsh; KASSERT(cfi != NULL); KASSERT(bst != NULL); memset(cfi, 0, sizeof(struct cfi)); /* XXX clean slate */ cfi->cfi_bst = bst; /* restore bus space */ cfi->cfi_bsh = bsh; /* " " " */ return cfi_probe(cfi); } static int cfi_scan_media(device_t self, struct nor_chip *chip) { struct nor_softc *sc = device_private(self); KASSERT(sc != NULL); KASSERT(sc->sc_nor_if != NULL); struct cfi * const cfi = (struct cfi * const)sc->sc_nor_if->private; KASSERT(cfi != NULL); sc->sc_nor_if->access_width = cfi->cfi_portwidth; chip->nc_manf_id = cfi->cfi_id_data.id_mid; chip->nc_dev_id = cfi->cfi_id_data.id_did[0]; /* XXX 3 words */ chip->nc_size = 1 << cfi->cfi_qry_data.device_size; /* size of line for Read Buf command */ chip->nc_line_size = 1 << cfi->cfi_qry_data.pri.cmd_0002.page_size; /* * size of erase block * XXX depends on erase region */ chip->nc_num_luns = 1; chip->nc_lun_blocks = cfi->cfi_qry_data.erase_blk_info[0].y + 1; chip->nc_block_size = cfi->cfi_qry_data.erase_blk_info[0].z ? cfi->cfi_qry_data.erase_blk_info[0].z * 256 : 128; switch (cfi->cfi_qry_data.id_pri) { case 0x0002: cfi_0002_init(sc, cfi, chip); break; } return 0; } void cfi_init(device_t self) { /* nothing */ } static void cfi_select(device_t self, bool select) { /* nothing */ } static void cfi_read_1(device_t self, flash_off_t offset, uint8_t *datap) { } static void cfi_read_2(device_t self, flash_off_t offset, uint16_t *datap) { } static void cfi_read_4(device_t self, flash_off_t offset, uint32_t *datap) { } static void cfi_read_buf_1(device_t self, flash_off_t offset, uint8_t *datap, size_t size) { } static void cfi_read_buf_2(device_t self, flash_off_t offset, uint16_t *datap, size_t size) { } static void cfi_read_buf_4(device_t self, flash_off_t offset, uint32_t *datap, size_t size) { } static void cfi_write_1(device_t self, flash_off_t offset, uint8_t data) { } static void cfi_write_2(device_t self, flash_off_t offset, uint16_t data) { } static void cfi_write_4(device_t self, flash_off_t offset, uint32_t data) { } static void cfi_write_buf_1(device_t self, flash_off_t offset, const uint8_t *datap, size_t size) { } static void cfi_write_buf_2(device_t self, flash_off_t offset, const uint16_t *datap, size_t size) { } static void cfi_write_buf_4(device_t self, flash_off_t offset, const uint32_t *datap, size_t size) { } /* * cfi_cmd - write a CFI command word. * * The offset 'off' is given for 64-bit port width and will be scaled * down to the actual port width of the chip. * The command word will be constructed out of 'val' regarding port- and * chip width. */ void cfi_cmd(struct cfi * const cfi, bus_size_t off, uint32_t val) { const bus_space_tag_t bst = cfi->cfi_bst; bus_space_handle_t bsh = cfi->cfi_bsh; uint64_t cmd; int cw, pw; off >>= 3 - cfi->cfi_portwidth; pw = 1 << cfi->cfi_portwidth; cw = 1 << cfi->cfi_chipwidth; cmd = 0; while (pw > 0) { cmd <<= cw << 3; cmd += val; pw -= cw; } DPRINTF(("%s: %p %x %x %" PRIx64 "\n", __func__, bst, bsh, off, cmd)); switch (cfi->cfi_portwidth) { case 0: bus_space_write_1(bst, bsh, off, cmd); break; case 1: bus_space_write_2(bst, bsh, off, cmd); break; case 2: bus_space_write_4(bst, bsh, off, cmd); break; #ifdef NOTYET case 3: bus_space_write_8(bst, bsh, off, cmd); break; #endif default: panic("%s: bad portwidth %d bytes\n", __func__, 1 << cfi->cfi_portwidth); } } static uint8_t cfi_read_qry(struct cfi * const cfi, bus_size_t off) { const bus_space_tag_t bst = cfi->cfi_bst; bus_space_handle_t bsh = cfi->cfi_bsh; uint8_t data; off <<= cfi->cfi_portwidth; switch (cfi->cfi_portwidth) { case 0: data = bus_space_read_1(bst, bsh, off); break; case 1: data = bus_space_read_2(bst, bsh, off); break; case 2: data = bus_space_read_4(bst, bsh, off); break; case 3: data = bus_space_read_8(bst, bsh, off); break; default: data = ~0; break; } return data; } /* * cfi_reset_default - when we don't know which command will work, use both */ void cfi_reset_default(struct cfi * const cfi) { cfi_cmd(cfi, CFI_ADDR_ANY, CFI_RESET_DATA); cfi_cmd(cfi, CFI_ADDR_ANY, CFI_ALT_RESET_DATA); } /* * cfi_reset_std - use standard reset command */ void cfi_reset_std(struct cfi * const cfi) { cfi_cmd(cfi, CFI_ADDR_ANY, CFI_RESET_DATA); } /* * cfi_reset_alt - use "alternate" reset command */ void cfi_reset_alt(struct cfi * const cfi) { cfi_cmd(cfi, CFI_ADDR_ANY, CFI_ALT_RESET_DATA); } static void cfi_jedec_id_1(struct cfi * const cfi) { struct cfi_jedec_id_data *idp = &cfi->cfi_id_data; uint8_t data[0x10]; bus_space_read_region_1(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_JEDEC(0, data, sizeof(data), 1); idp->id_mid = (uint16_t)data[0]; idp->id_did[0] = (uint16_t)data[1]; idp->id_did[1] = (uint16_t)data[0xe]; idp->id_did[2] = (uint16_t)data[0xf]; idp->id_prot_state = (uint16_t)data[2]; idp->id_indicators = (uint16_t)data[3]; /* software bits, upper and lower */ idp->id_swb_lo = data[0xc]; idp->id_swb_hi = data[0xd]; } static void cfi_jedec_id_2(struct cfi * const cfi) { struct cfi_jedec_id_data *idp = &cfi->cfi_id_data; uint16_t data[0x10]; bus_space_read_region_2(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_JEDEC(0, data, sizeof(data), 1); idp->id_mid = data[0]; idp->id_did[0] = data[1]; idp->id_did[1] = data[0xe]; idp->id_did[2] = data[0xf]; idp->id_prot_state = data[2]; idp->id_indicators = data[3]; /* software bits, upper and lower * - undefined on S29GL-P * - defined on S29GL-S */ idp->id_swb_lo = data[0xc]; idp->id_swb_hi = data[0xd]; } static void cfi_jedec_id_4(struct cfi * const cfi) { struct cfi_jedec_id_data *idp = &cfi->cfi_id_data; uint32_t data[0x10]; bus_space_read_region_4(cfi->cfi_bst, cfi->cfi_bsh, 0, data, __arraycount(data)); CFI_DUMP_JEDEC(0, data, sizeof(data), 1); idp->id_mid = data[0] & 0xffff; idp->id_did[0] = data[1] & 0xffff; idp->id_did[1] = data[0xe] & 0xffff; idp->id_did[2] = data[0xf] & 0xffff; idp->id_prot_state = data[2] & 0xffff; idp->id_indicators = data[3] & 0xffff; /* software bits, upper and lower * - undefined on S29GL-P * - defined on S29GL-S */ idp->id_swb_lo = data[0xc] & 0xffff; idp->id_swb_hi = data[0xd] & 0xffff; } /* * cfi_jedec_id - get JEDEC ID info */ static bool cfi_jedec_id(struct cfi * const cfi) { DPRINTF(("%s\n", __func__)); cfi_reset_default(cfi); cfi_cmd(cfi, cfi->cfi_unlock_addr1, 0xaa); cfi_cmd(cfi, cfi->cfi_unlock_addr2, 0x55); cfi_cmd(cfi, cfi->cfi_unlock_addr1, 0x90); switch(cfi->cfi_portwidth) { case 0: cfi_jedec_id_1(cfi); break; case 1: cfi_jedec_id_2(cfi); break; case 2: cfi_jedec_id_4(cfi); break; #ifdef NOTYET case 3: cfi_jedec_id_8(cfi); break; #endif default: panic("%s: bad portwidth %d bytes\n", __func__, 1 << cfi->cfi_portwidth); } return true; } static bool cfi_emulate(struct cfi * const cfi) { bool found = false; const struct cfi_jedec_tab *jt = cfi_jedec_search(cfi); if (jt != NULL) { found = true; cfi->cfi_emulated = true; cfi_jedec_fill(cfi, jt); } return found; } /* * cfi_jedec_search - search cfi_jedec_tab[] for entry matching given JEDEC IDs */ static const struct cfi_jedec_tab * cfi_jedec_search(struct cfi *cfi) { struct cfi_jedec_id_data *idp = &cfi->cfi_id_data; for (u_int i=0; i < __arraycount(cfi_jedec_tab); i++) { const struct cfi_jedec_tab *jt = &cfi_jedec_tab[i]; if ((jt->jt_mid == idp->id_mid) && (jt->jt_did == idp->id_did[0])) { return jt; } } return NULL; } /* * cfi_jedec_fill - fill in cfi with info from table entry */ static void cfi_jedec_fill(struct cfi *cfi, const struct cfi_jedec_tab *jt) { cfi->cfi_name = jt->jt_name; struct cfi_query_data *qryp = &cfi->cfi_qry_data; memset(qryp, 0, sizeof(*qryp)); qryp->id_pri = jt->jt_id_pri; qryp->id_alt = jt->jt_id_alt; qryp->interface_code_desc = jt->jt_interface_code_desc; qryp->write_word_time_typ = jt->jt_write_word_time_typ; qryp->write_nbyte_time_typ = jt->jt_write_nbyte_time_typ; qryp->erase_blk_time_typ = jt->jt_erase_blk_time_typ; qryp->erase_chip_time_typ = jt->jt_erase_chip_time_typ; qryp->write_word_time_max = jt->jt_write_word_time_max; qryp->write_nbyte_time_max = jt->jt_write_nbyte_time_max; qryp->erase_blk_time_max = jt->jt_erase_blk_time_max; qryp->erase_chip_time_max = jt->jt_erase_chip_time_max; qryp->device_size = jt->jt_device_size; qryp->interface_code_desc = jt->jt_interface_code_desc; qryp->write_nbyte_size_max = jt->jt_write_nbyte_size_max; qryp->erase_blk_regions = jt->jt_erase_blk_regions; for (u_int i=0; i < 4; i++) qryp->erase_blk_info[i] = jt->jt_erase_blk_info[i]; } void cfi_print(device_t self, struct cfi * const cfi) { char pbuf[sizeof("XXXX MB")]; struct cfi_query_data * const qryp = &cfi->cfi_qry_data; format_bytes(pbuf, sizeof(pbuf), 1 << qryp->device_size); if (cfi->cfi_emulated) { aprint_normal_dev(self, "%s NOR flash %s %s\n", cfi->cfi_name, pbuf, cfi_interface_desc_str(qryp->interface_code_desc)); } else { aprint_normal_dev(self, "CFI NOR flash %s %s\n", pbuf, cfi_interface_desc_str(qryp->interface_code_desc)); } #ifdef NOR_VERBOSE aprint_normal_dev(self, "manufacturer id %#x, device id %#x %#x %#x\n", cfi->cfi_id_data.id_mid, cfi->cfi_id_data.id_did[0], cfi->cfi_id_data.id_did[1], cfi->cfi_id_data.id_did[2]); aprint_normal_dev(self, "x%u device operating in %u-bit mode\n", 8 << cfi->cfi_portwidth, 8 << cfi->cfi_chipwidth); aprint_normal_dev(self, "sw bits lo=%#x hi=%#x\n", cfi->cfi_id_data.id_swb_lo, cfi->cfi_id_data.id_swb_hi); aprint_normal_dev(self, "max multibyte write size %d\n", 1 << qryp->write_nbyte_size_max); aprint_normal_dev(self, "%d Erase Block Region(s)\n", qryp->erase_blk_regions); for (u_int r=0; r < qryp->erase_blk_regions; r++) { size_t sz = qryp->erase_blk_info[r].z ? qryp->erase_blk_info[r].z * 256 : 128; format_bytes(pbuf, sizeof(pbuf), sz); aprint_normal(" %d: %d blocks, size %s\n", r, qryp->erase_blk_info[r].y + 1, pbuf); } #endif switch (cfi->cfi_qry_data.id_pri) { case 0x0002: cfi_0002_print(self, cfi); break; } } #if defined(CFI_DEBUG_JEDEC) || defined(CFI_DEBUG_QRY) void cfi_hexdump(flash_off_t offset, void * const v, u_int count, u_int stride) { uint8_t * const data = v; for(int n=0; n < count; n+=16) { int i; printf("%08llx: ", (offset + n) / stride); for(i=n; i < n+16; i++) printf("%02x ", data[i]); printf("\t"); for(i=n; i < n+16; i++) { u_int c = (int)data[i]; if (c >= 0x20 && c < 0x7f) printf("%c", c); else printf("%c", '.'); } printf("\n"); } } #endif