Lines Matching defs:chip
132 struct nand_chip *chip = &sc->sc_chip;
141 aprint_error("NAND chip is write protected!\n");
145 if (nand_scan_media(self, chip)) {
149 nand_flash_if.erasesize = chip->nc_block_size;
150 nand_flash_if.page_size = chip->nc_page_size;
151 nand_flash_if.writesize = chip->nc_page_size;
154 chip->nc_oob_cache = kmem_alloc(chip->nc_spare_size, KM_SLEEP);
155 chip->nc_page_cache = kmem_alloc(chip->nc_page_size, KM_SLEEP);
180 kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
181 kmem_free(chip->nc_page_cache, chip->nc_page_size);
189 struct nand_chip *chip = &sc->sc_chip;
201 faa.partinfo.part_size = chip->nc_size -
228 struct nand_chip *chip = &sc->sc_chip;
230 flash_attach_mtdparts(&nand_flash_if, parent, chip->nc_size,
238 struct nand_chip *chip = &sc->sc_chip;
251 kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
252 kmem_free(chip->nc_page_cache, chip->nc_page_size);
253 kmem_free(chip->nc_ecc_cache, chip->nc_ecc->necc_size);
329 nand_quirks(device_t self, struct nand_chip *chip)
332 switch (chip->nc_manf_id) {
334 if (chip->nc_dev_id == 0x00) {
337 /* chip->nc_quirks |= NC_QUIRK_NO_READ_START */
346 nand_fill_chip_structure_legacy(device_t self, struct nand_chip *chip)
348 switch (chip->nc_manf_id) {
350 return nand_read_parameters_micron(self, chip);
352 return nand_read_parameters_samsung(self, chip);
354 return nand_read_parameters_toshiba(self, chip);
363 * scan media to determine the chip's properties
367 nand_scan_media(device_t self, struct nand_chip *chip)
396 chip->nc_isonfi = false;
400 nand_read_id(self, &chip->nc_manf_id, &chip->nc_dev_id);
402 if (nand_fill_chip_structure_legacy(self, chip)) {
404 "can't read device parameters for legacy chip\n");
408 chip->nc_isonfi = true;
412 nand_read_id(self, &chip->nc_manf_id, &chip->nc_dev_id);
414 if (nand_fill_chip_structure(self, chip)) {
423 chip->nc_manf_id,
424 nand_midtoname(chip->nc_manf_id),
425 chip->nc_dev_id);
430 chip->nc_page_size, chip->nc_spare_size, chip->nc_block_size);
435 chip->nc_lun_blocks, chip->nc_num_luns,
436 chip->nc_size / 1024 / 1024);
440 chip->nc_addr_cycles_column, chip->nc_addr_cycles_row,
441 (chip->nc_flags & NC_BUSWIDTH_16) ? "x16" : "x8");
443 ecc = chip->nc_ecc = &sc->nand_if->ecc;
449 switch (chip->nc_spare_size) {
466 panic("OOB size %" PRIu32 " is unexpected", chip->nc_spare_size);
469 ecc->necc_steps = chip->nc_page_size / ecc->necc_block_size;
473 if (ecc->necc_offset + ecc->necc_size > chip->nc_spare_size) {
479 chip->nc_ecc_cache = kmem_zalloc(ecc->necc_size, KM_SLEEP);
485 if (chip->nc_page_size > 512)
486 chip->nc_badmarker_offs = 0;
488 chip->nc_badmarker_offs = 5;
491 chip->nc_page_shift = ffs(chip->nc_page_size) - 1;
492 chip->nc_page_mask = ~(chip->nc_page_size - 1);
494 chip->nc_block_shift = ffs(chip->nc_block_size) - 1;
495 chip->nc_block_mask = ~(chip->nc_block_size - 1);
498 /* nand_quirks(self, chip); */
556 nand_fill_chip_structure(device_t self, struct nand_chip *chip)
576 chip->nc_page_size = le32toh(params.param_pagesize);
577 chip->nc_block_size =
578 le32toh(params.param_blocksize) * chip->nc_page_size;
579 chip->nc_spare_size = le16toh(params.param_sparesize);
580 chip->nc_lun_blocks = le32toh(params.param_lunsize);
581 chip->nc_num_luns = params.param_numluns;
583 chip->nc_size =
584 chip->nc_block_size * chip->nc_lun_blocks * chip->nc_num_luns;
587 chip->nc_addr_cycles_row = params.param_addr_cycles & 0x07;
589 chip->nc_addr_cycles_column = (params.param_addr_cycles & ~0x07) >> 4;
593 chip->nc_flags |= NC_BUSWIDTH_16;
597 chip->nc_flags |= NC_EXTENDED_PARAM;
614 struct nand_chip *chip = &sc->sc_chip;
621 row >>= chip->nc_page_shift;
624 if (chip->nc_flags & NC_BUSWIDTH_16)
626 for (i = 0; i < chip->nc_addr_cycles_column; i++, column >>= 8)
630 for (i = 0; i < chip->nc_addr_cycles_row; i++, row >>= 8)
638 struct nand_chip *chip = &sc->sc_chip;
642 row >>= chip->nc_page_shift;
645 for (i = 0; i < chip->nc_addr_cycles_row; i++, row >>= 8)
685 struct nand_chip *chip = &sc->sc_chip;
692 bs = chip->nc_ecc->necc_block_size;
693 cs = chip->nc_ecc->necc_code_size;
696 if (chip->nc_flags & NC_BUSWIDTH_16) {
697 for (b = 0, e = 0; b < chip->nc_page_size; b += bs, e += cs) {
701 chip->nc_ecc_cache + e);
704 for (b = 0, e = 0; b < chip->nc_page_size; b += bs, e += cs) {
708 chip->nc_ecc_cache + e);
714 nand_dump_data("page", data, chip->nc_page_size);
717 nand_read_oob(self, offset, chip->nc_oob_cache);
718 ecc = chip->nc_oob_cache + chip->nc_ecc->necc_offset;
722 printf("dumping ecc %d\n--------------\n", chip->nc_ecc->necc_steps);
723 for (e = 0; e < chip->nc_ecc->necc_steps; e++) {
730 printf("%.2hhx", chip->nc_ecc_cache[e+b]);
737 for (b = 0, e = 0; b < chip->nc_page_size; b += bs, e += cs) {
739 chip->nc_ecc_cache + e);
773 struct nand_chip *chip = &sc->sc_chip;
783 bs = chip->nc_ecc->necc_block_size;
784 cs = chip->nc_ecc->necc_code_size;
785 ecc = chip->nc_oob_cache + chip->nc_ecc->necc_offset;
789 if (chip->nc_flags & NC_BUSWIDTH_16) {
790 for (b = 0, e = 0; b < chip->nc_page_size; b += bs, e += cs) {
796 nand_write_buf_2(self, chip->nc_oob_cache,
797 chip->nc_spare_size);
799 for (b = 0, e = 0; b < chip->nc_page_size; b += bs, e += cs) {
805 nand_write_buf_1(self, chip->nc_oob_cache,
806 chip->nc_spare_size);
815 printf("dumping ecc %d\n--------------\n", chip->nc_ecc->necc_steps);
816 for (e = 0; e < chip->nc_ecc->necc_steps; e++) {
841 struct nand_chip *chip = &sc->sc_chip;
843 nand_prepare_read(self, page, chip->nc_page_size);
845 if (chip->nc_flags & NC_BUSWIDTH_16)
846 nand_read_buf_2(self, oob, chip->nc_spare_size);
848 nand_read_buf_1(self, oob, chip->nc_spare_size);
852 nand_dump_data("oob", oob, chip->nc_spare_size);
862 struct nand_chip *chip = &sc->sc_chip;
866 nand_address_column(self, offset, chip->nc_page_size);
871 if (chip->nc_flags & NC_BUSWIDTH_16)
872 nand_write_buf_2(self, oob, chip->nc_spare_size);
874 nand_write_buf_1(self, oob, chip->nc_spare_size);
888 struct nand_chip *chip = &sc->sc_chip;
893 block = offset / chip->nc_block_size;
897 blockoffset = offset & chip->nc_block_mask;
903 nand_read_oob(self, blockoffset, chip->nc_oob_cache);
905 chip->nc_oob_cache[chip->nc_badmarker_offs] = 0x00;
906 chip->nc_oob_cache[chip->nc_badmarker_offs + 1] = 0x00;
908 nand_write_oob(self, blockoffset, chip->nc_oob_cache);
915 struct nand_chip *chip = &sc->sc_chip;
923 block = offset / chip->nc_block_size;
924 first_page = block * chip->nc_block_size;
925 last_page = (block + 1) * chip->nc_block_size
926 - chip->nc_page_size;
930 nand_prepare_read(self, page, chip->nc_page_size);
932 if (chip->nc_flags & NC_BUSWIDTH_16) {
952 struct nand_chip *chip = &sc->sc_chip;
956 block = offset & chip->nc_block_mask;
959 if (chip->nc_flags & NC_BUSWIDTH_16) {
963 chip->nc_page_size + (chip->nc_badmarker_offs & 0xfe));
967 if (chip->nc_badmarker_offs & 0x01)
975 chip->nc_page_size + chip->nc_badmarker_offs);
990 struct nand_chip *chip = &sc->sc_chip;
993 block = offset / chip->nc_block_size;
1076 struct nand_chip *chip = &sc->sc_chip;
1083 first = offset & chip->nc_page_mask;
1084 firstoff = offset & ~chip->nc_page_mask;
1086 last = (offset + len) & chip->nc_page_mask;
1102 error = nand_read_page(self, addr, chip->nc_page_cache);
1107 memcpy(chip->nc_page_cache + firstoff, buf, len);
1109 error = nand_program_page(self, addr, chip->nc_page_cache);
1132 addr, chip->nc_page_cache);
1137 memcpy(chip->nc_page_cache + firstoff,
1138 bufp, chip->nc_page_size - firstoff);
1142 addr, chip->nc_page_cache);
1147 bufp += chip->nc_page_size - firstoff;
1148 left -= chip->nc_page_size - firstoff;
1149 *retlen += chip->nc_page_size - firstoff;
1153 addr, chip->nc_page_cache);
1158 memcpy(chip->nc_page_cache, bufp, left);
1161 addr, chip->nc_page_cache);
1167 KASSERT(left < chip->nc_page_size);
1171 if (left > chip->nc_page_size) {
1175 KASSERT(left > chip->nc_page_size);
1182 bufp += chip->nc_page_size;
1183 left -= chip->nc_page_size;
1184 *retlen += chip->nc_page_size;
1187 addr += chip->nc_page_size;
1202 struct nand_chip *chip = &sc->sc_chip;
1208 if ((offset + len) > chip->nc_size) {
1212 (uintmax_t)chip->nc_size));
1216 if (len % chip->nc_page_size != 0 ||
1217 offset % chip->nc_page_size != 0) {
1222 pages = len / chip->nc_page_size;
1245 addr += chip->nc_page_size;
1246 bufp += chip->nc_page_size;
1247 *retlen += chip->nc_page_size;
1264 struct nand_chip *chip = &sc->sc_chip;
1271 first = offset & chip->nc_page_mask;
1272 firstoff = offset & ~chip->nc_page_mask;
1273 last = (offset + len) & chip->nc_page_mask;
1274 count = (last - first) / chip->nc_page_size + 1;
1283 error = nand_read_page(self, addr, chip->nc_page_cache);
1288 memcpy(bufp, chip->nc_page_cache + firstoff, len);
1295 error = nand_read_page(self, addr, chip->nc_page_cache);
1301 memcpy(bufp, chip->nc_page_cache + firstoff,
1302 chip->nc_page_size - firstoff);
1304 bufp += chip->nc_page_size - firstoff;
1305 left -= chip->nc_page_size - firstoff;
1306 *retlen += chip->nc_page_size - firstoff;
1309 memcpy(bufp, chip->nc_page_cache, left);
1311 KASSERT(left < chip->nc_page_size);
1314 memcpy(bufp, chip->nc_page_cache, chip->nc_page_size);
1316 bufp += chip->nc_page_size;
1317 left -= chip->nc_page_size;
1318 *retlen += chip->nc_page_size;
1321 addr += chip->nc_page_size;
1335 struct nand_chip *chip = &sc->sc_chip;
1346 if (__predict_false((offset + len) > chip->nc_size)) {
1349 len, (uintmax_t)chip->nc_size));
1359 if (len < chip->nc_page_size)
1363 if (len % chip->nc_page_size != 0 ||
1364 offset % chip->nc_page_size != 0) {
1371 pages = len / chip->nc_page_size;
1385 bufp += chip->nc_page_size;
1386 addr += chip->nc_page_size;
1387 *retlen += chip->nc_page_size;
1399 struct nand_chip *chip = &sc->sc_chip;
1402 if (ofs > chip->nc_size) {
1405 (uintmax_t)chip->nc_size));
1409 if (ofs % chip->nc_block_size != 0) {
1412 (uintmax_t)ofs, (uintmax_t)chip->nc_block_size));
1429 struct nand_chip *chip = &sc->sc_chip;
1431 if (ofs > chip->nc_size) {
1434 (uintmax_t)chip->nc_size));
1438 if (ofs % chip->nc_block_size != 0) {
1440 (uintmax_t)ofs, (uintmax_t)chip->nc_block_size);
1455 struct nand_chip *chip = &sc->sc_chip;
1459 if (ei->ei_addr < 0 || ei->ei_len < chip->nc_block_size)
1462 if (ei->ei_addr + ei->ei_len > chip->nc_size) {
1468 if (ei->ei_addr % chip->nc_block_size != 0) {
1473 (uintmax_t)chip->nc_block_size);
1477 if (ei->ei_len % chip->nc_block_size != 0) {
1482 (uintmax_t)chip->nc_block_size);
1502 addr += chip->nc_block_size;
Indexes created Tue Sep 23 14:10:03 GMT 2025