Lines Matching refs:docg3
27 #include "docg3.h"
53 MODULE_PARM_DESC(reliable_mode, "Set the docg3 mode (0=normal MLC, 1=fast, "
92 static inline u8 doc_readb(struct docg3 *docg3, u16 reg)
94 u8 val = readb(docg3->cascade->base + reg);
100 static inline u16 doc_readw(struct docg3 *docg3, u16 reg)
102 u16 val = readw(docg3->cascade->base + reg);
108 static inline void doc_writeb(struct docg3 *docg3, u8 val, u16 reg)
110 writeb(val, docg3->cascade->base + reg);
114 static inline void doc_writew(struct docg3 *docg3, u16 val, u16 reg)
116 writew(val, docg3->cascade->base + reg);
120 static inline void doc_flash_command(struct docg3 *docg3, u8 cmd)
122 doc_writeb(docg3, cmd, DOC_FLASHCOMMAND);
125 static inline void doc_flash_sequence(struct docg3 *docg3, u8 seq)
127 doc_writeb(docg3, seq, DOC_FLASHSEQUENCE);
130 static inline void doc_flash_address(struct docg3 *docg3, u8 addr)
132 doc_writeb(docg3, addr, DOC_FLASHADDRESS);
137 static int doc_register_readb(struct docg3 *docg3, int reg)
141 doc_writew(docg3, reg, DOC_READADDRESS);
142 val = doc_readb(docg3, reg);
147 static int doc_register_readw(struct docg3 *docg3, int reg)
151 doc_writew(docg3, reg, DOC_READADDRESS);
152 val = doc_readw(docg3, reg);
158 * doc_delay - delay docg3 operations
159 * @docg3: the device
164 * working docg3 chip.
168 static void doc_delay(struct docg3 *docg3, int nbNOPs)
174 doc_writeb(docg3, 0, DOC_NOP);
177 static int is_prot_seq_error(struct docg3 *docg3)
181 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
185 static int doc_is_ready(struct docg3 *docg3)
189 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
193 static int doc_wait_ready(struct docg3 *docg3)
198 doc_delay(docg3, 4);
200 } while (!doc_is_ready(docg3) && maxWaitCycles--);
201 doc_delay(docg3, 2);
208 static int doc_reset_seq(struct docg3 *docg3)
212 doc_writeb(docg3, 0x10, DOC_FLASHCONTROL);
213 doc_flash_sequence(docg3, DOC_SEQ_RESET);
214 doc_flash_command(docg3, DOC_CMD_RESET);
215 doc_delay(docg3, 2);
216 ret = doc_wait_ready(docg3);
224 * @docg3: the device
231 static void doc_read_data_area(struct docg3 *docg3, void *buf, int len,
243 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
246 data16 = doc_readw(docg3, DOC_IOSPACE_DATA);
254 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
256 doc_delay(docg3, 1);
259 data8 = doc_readb(docg3, DOC_IOSPACE_DATA);
270 * @docg3: the device
276 static void doc_write_data_area(struct docg3 *docg3, const void *buf, int len)
286 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
289 doc_writew(docg3, *src16, DOC_IOSPACE_DATA);
295 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
297 doc_writeb(docg3, *src8, DOC_IOSPACE_DATA);
304 * @docg3: the device
317 static void doc_set_reliable_mode(struct docg3 *docg3)
321 doc_dbg("doc_set_reliable_mode(%s)\n", strmode[docg3->reliable]);
322 switch (docg3->reliable) {
326 doc_flash_sequence(docg3, DOC_SEQ_SET_FASTMODE);
327 doc_flash_command(docg3, DOC_CMD_FAST_MODE);
330 doc_flash_sequence(docg3, DOC_SEQ_SET_RELIABLEMODE);
331 doc_flash_command(docg3, DOC_CMD_FAST_MODE);
332 doc_flash_command(docg3, DOC_CMD_RELIABLE_MODE);
338 doc_delay(docg3, 2);
343 * @docg3: the device
351 static void doc_set_asic_mode(struct docg3 *docg3, u8 mode)
356 doc_readb(docg3, DOC_IOSPACE_IPL);
360 doc_writeb(docg3, mode, DOC_ASICMODE);
361 doc_writeb(docg3, ~mode, DOC_ASICMODECONFIRM);
362 doc_delay(docg3, 1);
367 * @docg3: the device
373 static void doc_set_device_id(struct docg3 *docg3, int id)
378 doc_writeb(docg3, id, DOC_DEVICESELECT);
379 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
383 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
388 * @docg3: the device
397 static int doc_set_extra_page_mode(struct docg3 *docg3)
402 doc_flash_sequence(docg3, DOC_SEQ_PAGE_SIZE_532);
403 doc_flash_command(docg3, DOC_CMD_PAGE_SIZE_532);
404 doc_delay(docg3, 2);
406 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
415 * @docg3: the device
418 static void doc_setup_addr_sector(struct docg3 *docg3, int sector)
420 doc_delay(docg3, 1);
421 doc_flash_address(docg3, sector & 0xff);
422 doc_flash_address(docg3, (sector >> 8) & 0xff);
423 doc_flash_address(docg3, (sector >> 16) & 0xff);
424 doc_delay(docg3, 1);
429 * @docg3: the device
433 static void doc_setup_writeaddr_sector(struct docg3 *docg3, int sector, int ofs)
436 doc_delay(docg3, 1);
437 doc_flash_address(docg3, ofs & 0xff);
438 doc_flash_address(docg3, sector & 0xff);
439 doc_flash_address(docg3, (sector >> 8) & 0xff);
440 doc_flash_address(docg3, (sector >> 16) & 0xff);
441 doc_delay(docg3, 1);
446 * @docg3: the device
456 static int doc_read_seek(struct docg3 *docg3, int block0, int block1, int page,
465 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
466 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
467 doc_delay(docg3, 2);
469 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
470 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
471 doc_delay(docg3, 2);
474 doc_set_reliable_mode(docg3);
476 ret = doc_set_extra_page_mode(docg3);
480 doc_flash_sequence(docg3, DOC_SEQ_READ);
482 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
483 doc_setup_addr_sector(docg3, sector);
486 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
487 doc_setup_addr_sector(docg3, sector);
488 doc_delay(docg3, 1);
496 * @docg3: the device
505 static int doc_write_seek(struct docg3 *docg3, int block0, int block1, int page,
513 doc_set_reliable_mode(docg3);
516 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
517 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
518 doc_delay(docg3, 2);
520 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
521 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
522 doc_delay(docg3, 2);
525 doc_flash_sequence(docg3, DOC_SEQ_PAGE_SETUP);
526 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
529 doc_setup_writeaddr_sector(docg3, sector, ofs);
531 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE3);
532 doc_delay(docg3, 2);
533 ret = doc_wait_ready(docg3);
537 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
539 doc_setup_writeaddr_sector(docg3, sector, ofs);
540 doc_delay(docg3, 1);
549 * @docg3: the device
557 static int doc_read_page_ecc_init(struct docg3 *docg3, int len)
559 doc_writew(docg3, DOC_ECCCONF0_READ_MODE
563 doc_delay(docg3, 4);
564 doc_register_readb(docg3, DOC_FLASHCONTROL);
565 return doc_wait_ready(docg3);
570 * @docg3: the device
578 static int doc_write_page_ecc_init(struct docg3 *docg3, int len)
580 doc_writew(docg3, DOC_ECCCONF0_WRITE_MODE
584 doc_delay(docg3, 4);
585 doc_register_readb(docg3, DOC_FLASHCONTROL);
586 return doc_wait_ready(docg3);
591 * @docg3: the device
596 static void doc_ecc_disable(struct docg3 *docg3)
598 doc_writew(docg3, DOC_ECCCONF0_READ_MODE, DOC_ECCCONF0);
599 doc_delay(docg3, 4);
604 * @docg3: the device
610 static void doc_hamming_ecc_init(struct docg3 *docg3, int nb_bytes)
614 ecc_conf1 = doc_register_readb(docg3, DOC_ECCCONF1);
617 doc_writeb(docg3, ecc_conf1, DOC_ECCCONF1);
622 * @docg3: the device
629 * tries to fix the bit flips (at most 4) in the buffer buf. As the docg3
643 static int doc_ecc_bch_fix_data(struct docg3 *docg3, void *buf, u8 *hwecc)
650 numerrs = bch_decode(docg3->cascade->bch, NULL,
671 * @docg3: the device
695 static int doc_read_page_prepare(struct docg3 *docg3, int block0, int block1,
707 doc_set_device_id(docg3, docg3->device_id);
708 ret = doc_reset_seq(docg3);
713 ret = doc_read_seek(docg3, block0, block1, page, wear_area, offset);
717 doc_flash_command(docg3, DOC_CMD_READ_ALL_PLANES);
718 doc_delay(docg3, 2);
719 doc_wait_ready(docg3);
721 doc_flash_command(docg3, DOC_CMD_SET_ADDR_READ);
722 doc_delay(docg3, 1);
725 doc_flash_address(docg3, offset >> 2);
726 doc_delay(docg3, 1);
727 doc_wait_ready(docg3);
729 doc_flash_command(docg3, DOC_CMD_READ_FLASH);
733 doc_writeb(docg3, 0, DOC_DATAEND);
734 doc_delay(docg3, 2);
740 * @docg3: the device
753 static int doc_read_page_getbytes(struct docg3 *docg3, int len, u_char *buf,
757 doc_read_data_area(docg3, buf, 1, first);
758 doc_read_data_area(docg3, buf ? buf + 1 : buf, len - 1, 0);
760 doc_read_data_area(docg3, buf, len, first);
762 doc_delay(docg3, 2);
768 * @docg3: the device
773 static void doc_write_page_putbytes(struct docg3 *docg3, int len,
776 doc_write_data_area(docg3, buf, len);
777 doc_delay(docg3, 2);
782 * @docg3: the device
785 static void doc_get_bch_hw_ecc(struct docg3 *docg3, u8 *hwecc)
790 hwecc[i] = doc_register_readb(docg3, DOC_BCH_HW_ECC(i));
795 * @docg3: the device
797 static void doc_page_finish(struct docg3 *docg3)
799 doc_writeb(docg3, 0, DOC_DATAEND);
800 doc_delay(docg3, 2);
805 * @docg3: the device
811 static void doc_read_page_finish(struct docg3 *docg3)
813 doc_page_finish(docg3);
814 doc_set_device_id(docg3, 0);
825 * @reliable: 0 if docg3 in normal mode, 1 if docg3 in fast mode, 2 if docg3 in
868 struct docg3 *docg3 = mtd->priv;
897 mutex_lock(&docg3->cascade->lock);
900 docg3->reliable);
903 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs);
906 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
909 ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0);
912 ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2);
915 doc_read_page_getbytes(docg3,
918 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0);
921 doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob,
924 doc_get_bch_hw_ecc(docg3, hwecc);
925 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);
937 if (is_prot_seq_error(docg3))
945 ret = doc_ecc_bch_fix_data(docg3, buf, hwecc);
957 doc_read_page_finish(docg3);
969 mutex_unlock(&docg3->cascade->lock);
972 doc_read_page_finish(docg3);
976 static int doc_reload_bbt(struct docg3 *docg3)
980 u_char *buf = docg3->bbt;
982 nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);
984 ret = doc_read_page_prepare(docg3, block, block + 1,
987 ret = doc_read_page_ecc_init(docg3,
990 doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE,
994 doc_read_page_finish(docg3);
1007 struct docg3 *docg3 = mtd->priv;
1011 docg3->reliable);
1017 if (block1 > docg3->max_block)
1020 is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7));
1027 * @docg3: the device
1035 static int doc_get_erase_count(struct docg3 *docg3, loff_t from)
1044 calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable);
1045 if (block1 > docg3->max_block)
1048 ret = doc_reset_seq(docg3);
1050 ret = doc_read_page_prepare(docg3, block0, block1, page,
1053 ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE,
1055 doc_read_page_finish(docg3);
1070 * @docg3: the device
1076 static int doc_get_op_status(struct docg3 *docg3)
1080 doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS);
1081 doc_flash_command(docg3, DOC_CMD_PLANES_STATUS);
1082 doc_delay(docg3, 5);
1084 doc_ecc_disable(docg3);
1085 doc_read_data_area(docg3, &status, 1, 1);
1091 * @docg3: the device
1099 static int doc_write_erase_wait_status(struct docg3 *docg3)
1103 for (i = 0; !doc_is_ready(docg3) && i < 5; i++)
1105 if (!doc_is_ready(docg3)) {
1111 status = doc_get_op_status(docg3);
1119 doc_page_finish(docg3);
1125 * @docg3: the device
1134 static int doc_erase_block(struct docg3 *docg3, int block0, int block1)
1139 ret = doc_reset_seq(docg3);
1143 doc_set_reliable_mode(docg3);
1144 doc_flash_sequence(docg3, DOC_SEQ_ERASE);
1147 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1148 doc_setup_addr_sector(docg3, sector);
1150 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1151 doc_setup_addr_sector(docg3, sector);
1152 doc_delay(docg3, 1);
1154 doc_flash_command(docg3, DOC_CMD_ERASECYCLE2);
1155 doc_delay(docg3, 2);
1157 if (is_prot_seq_error(docg3)) {
1162 return doc_write_erase_wait_status(docg3);
1178 struct docg3 *docg3 = mtd->priv;
1185 &ofs, docg3->reliable);
1190 docg3->reliable);
1191 mutex_lock(&docg3->cascade->lock);
1192 doc_set_device_id(docg3, docg3->device_id);
1193 doc_set_reliable_mode(docg3);
1195 ret = doc_erase_block(docg3, block0, block1);
1199 mutex_unlock(&docg3->cascade->lock);
1206 * @docg3: the device
1223 static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf,
1230 calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable);
1232 doc_set_device_id(docg3, docg3->device_id);
1233 ret = doc_reset_seq(docg3);
1238 ret = doc_write_seek(docg3, block0, block1, page, ofs);
1242 doc_write_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
1243 doc_delay(docg3, 2);
1244 doc_write_page_putbytes(docg3, DOC_LAYOUT_PAGE_SIZE, buf);
1247 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob);
1248 doc_delay(docg3, 2);
1251 hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY);
1252 doc_delay(docg3, 2);
1253 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ,
1255 doc_delay(docg3, 2);
1257 doc_get_bch_hw_ecc(docg3, hwecc);
1258 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_BCH_SZ, hwecc);
1259 doc_delay(docg3, 2);
1261 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob);
1264 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob);
1266 doc_delay(docg3, 2);
1267 doc_page_finish(docg3);
1268 doc_delay(docg3, 2);
1269 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE2);
1270 doc_delay(docg3, 2);
1274 * seems to please the docg3, so leave it.
1276 ret = doc_write_erase_wait_status(docg3);
1279 doc_read_page_finish(docg3);
1320 * doc_backup_oob - Backup OOB into docg3 structure
1321 * @docg3: the device
1325 * As the docg3 should write a page with its OOB in one pass, and some userland
1336 static int doc_backup_oob(struct docg3 *docg3, loff_t to,
1347 docg3->oob_write_ofs = to;
1348 docg3->oob_autoecc = autoecc;
1350 doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf);
1353 memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE);
1377 struct docg3 *docg3 = mtd->priv;
1422 return doc_backup_oob(docg3, ofs, ops);
1428 mutex_lock(&docg3->cascade->lock);
1431 if (ofs == docg3->oob_write_ofs)
1432 memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE);
1437 ret = doc_write_page(docg3, ofs, buf, oob, autoecc);
1450 doc_set_device_id(docg3, 0);
1451 mutex_unlock(&docg3->cascade->lock);
1455 static struct docg3 *sysfs_dev2docg3(struct device *dev,
1471 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1474 mutex_lock(&docg3->cascade->lock);
1475 doc_set_device_id(docg3, docg3->device_id);
1476 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1477 doc_set_device_id(docg3, 0);
1478 mutex_unlock(&docg3->cascade->lock);
1486 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1489 mutex_lock(&docg3->cascade->lock);
1490 doc_set_device_id(docg3, docg3->device_id);
1491 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1492 doc_set_device_id(docg3, 0);
1493 mutex_unlock(&docg3->cascade->lock);
1502 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1508 mutex_lock(&docg3->cascade->lock);
1509 doc_set_device_id(docg3, docg3->device_id);
1511 doc_writeb(docg3, buf[i], DOC_DPS0_KEY);
1512 doc_set_device_id(docg3, 0);
1513 mutex_unlock(&docg3->cascade->lock);
1521 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1527 mutex_lock(&docg3->cascade->lock);
1528 doc_set_device_id(docg3, docg3->device_id);
1530 doc_writeb(docg3, buf[i], DOC_DPS1_KEY);
1531 doc_set_device_id(docg3, 0);
1532 mutex_unlock(&docg3->cascade->lock);
1594 struct docg3 *docg3 = (struct docg3 *)s->private;
1598 mutex_lock(&docg3->cascade->lock);
1599 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1600 mutex_unlock(&docg3->cascade->lock);
1616 struct docg3 *docg3 = (struct docg3 *)s->private;
1620 mutex_lock(&docg3->cascade->lock);
1621 pctrl = doc_register_readb(docg3, DOC_ASICMODE);
1623 mutex_unlock(&docg3->cascade->lock);
1653 struct docg3 *docg3 = (struct docg3 *)s->private;
1656 mutex_lock(&docg3->cascade->lock);
1657 id = doc_register_readb(docg3, DOC_DEVICESELECT);
1658 mutex_unlock(&docg3->cascade->lock);
1667 struct docg3 *docg3 = (struct docg3 *)s->private;
1670 mutex_lock(&docg3->cascade->lock);
1671 protect = doc_register_readb(docg3, DOC_PROTECTION);
1672 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1673 dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW);
1674 dps0_high = doc_register_readw(docg3, DOC_DPS0_ADDRHIGH);
1675 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1676 dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW);
1677 dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH);
1678 mutex_unlock(&docg3->cascade->lock);
1720 struct docg3 *docg3 = floor->priv;
1730 debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3,
1732 debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3,
1734 debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3,
1736 debugfs_create_file("docg3_protection", S_IRUSR, root, docg3,
1741 * doc_set_driver_info - Fill the mtd_info structure and docg3 structure
1747 struct docg3 *docg3 = mtd->priv;
1750 cfg = doc_register_readb(docg3, DOC_CONFIGURATION);
1751 docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0);
1752 docg3->reliable = reliable_mode;
1756 mtd->name = devm_kasprintf(docg3->dev, GFP_KERNEL, "docg3.%d",
1757 docg3->device_id);
1760 docg3->max_block = 2047;
1765 mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE;
1766 if (docg3->reliable == 2)
1769 if (docg3->reliable == 2)
1802 struct docg3 *docg3;
1806 docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL);
1807 if (!docg3)
1812 mtd->priv = docg3;
1814 bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,
1816 docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL);
1817 if (!docg3->bbt)
1820 docg3->dev = dev;
1821 docg3->device_id = floor;
1822 docg3->cascade = cascade;
1823 doc_set_device_id(docg3, docg3->device_id);
1825 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET);
1826 doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL);
1828 chip_id = doc_register_readw(docg3, DOC_CHIPID);
1829 chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV);
1839 docg3->cascade->base, floor);
1850 doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1851 doc_reload_bbt(docg3);
1855 kfree(docg3->bbt);
1859 kfree(docg3);
1865 * doc_release_device - Release a docg3 floor
1870 struct docg3 *docg3 = mtd->priv;
1873 kfree(docg3->bbt);
1874 kfree(docg3);
1879 * docg3_resume - Awakens docg3 floor
1889 struct docg3 *docg3;
1894 docg3 = mtd->priv;
1898 doc_readb(docg3, DOC_IOSPACE_IPL);
1903 * docg3_suspend - Put in low power mode the docg3 floor
1907 * Shuts off most of docg3 circuitery to lower power consumption.
1916 struct docg3 *docg3;
1925 docg3 = mtd->priv;
1927 doc_writeb(docg3, floor, DOC_DEVICESELECT);
1928 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1930 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
1934 pwr_down = doc_register_readb(docg3, DOC_POWERMODE);
1949 docg3 = mtd->priv;
1950 doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN);
2045 struct docg3 *docg3 = cascade->floors[0]->priv;
2053 bch_free(docg3->cascade->bch);
2067 .name = "docg3",