2086 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Handles the M-Systems DiskOnChip G3 chip4 *5 * Copyright (C) 2011 Robert Jarzmik6 */7 8#include <linux/kernel.h>9#include <linux/module.h>10#include <linux/errno.h>11#include <linux/of.h>12#include <linux/platform_device.h>13#include <linux/string.h>14#include <linux/slab.h>15#include <linux/io.h>16#include <linux/delay.h>17#include <linux/mtd/mtd.h>18#include <linux/mtd/partitions.h>19#include <linux/bitmap.h>20#include <linux/bitrev.h>21#include <linux/bch.h>22 23#include <linux/debugfs.h>24#include <linux/seq_file.h>25 26#define CREATE_TRACE_POINTS27#include "docg3.h"28 29/*30 * This driver handles the DiskOnChip G3 flash memory.31 *32 * As no specification is available from M-Systems/Sandisk, this drivers lacks33 * several functions available on the chip, as :34 * - IPL write35 *36 * The bus data width (8bits versus 16bits) is not handled (if_cfg flag), and37 * the driver assumes a 16bits data bus.38 *39 * DocG3 relies on 2 ECC algorithms, which are handled in hardware :40 * - a 1 byte Hamming code stored in the OOB for each page41 * - a 7 bytes BCH code stored in the OOB for each page42 * The BCH ECC is :43 * - BCH is in GF(2^14)44 * - BCH is over data of 520 bytes (512 page + 7 page_info bytes45 * + 1 hamming byte)46 * - BCH can correct up to 4 bits (t = 4)47 * - BCH syndroms are calculated in hardware, and checked in hardware as well48 *49 */50 51static unsigned int reliable_mode;52module_param(reliable_mode, uint, 0);53MODULE_PARM_DESC(reliable_mode, "Set the docg3 mode (0=normal MLC, 1=fast, "54 "2=reliable) : MLC normal operations are in normal mode");55 56static int docg3_ooblayout_ecc(struct mtd_info *mtd, int section,57 struct mtd_oob_region *oobregion)58{59 if (section)60 return -ERANGE;61 62 /* byte 7 is Hamming ECC, byte 8-14 are BCH ECC */63 oobregion->offset = 7;64 oobregion->length = 8;65 66 return 0;67}68 69static int docg3_ooblayout_free(struct mtd_info *mtd, int section,70 struct mtd_oob_region *oobregion)71{72 if (section > 1)73 return -ERANGE;74 75 /* free bytes: byte 0 until byte 6, byte 15 */76 if (!section) {77 oobregion->offset = 0;78 oobregion->length = 7;79 } else {80 oobregion->offset = 15;81 oobregion->length = 1;82 }83 84 return 0;85}86 87static const struct mtd_ooblayout_ops nand_ooblayout_docg3_ops = {88 .ecc = docg3_ooblayout_ecc,89 .free = docg3_ooblayout_free,90};91 92static inline u8 doc_readb(struct docg3 *docg3, u16 reg)93{94 u8 val = readb(docg3->cascade->base + reg);95 96 trace_docg3_io(0, 8, reg, (int)val);97 return val;98}99 100static inline u16 doc_readw(struct docg3 *docg3, u16 reg)101{102 u16 val = readw(docg3->cascade->base + reg);103 104 trace_docg3_io(0, 16, reg, (int)val);105 return val;106}107 108static inline void doc_writeb(struct docg3 *docg3, u8 val, u16 reg)109{110 writeb(val, docg3->cascade->base + reg);111 trace_docg3_io(1, 8, reg, val);112}113 114static inline void doc_writew(struct docg3 *docg3, u16 val, u16 reg)115{116 writew(val, docg3->cascade->base + reg);117 trace_docg3_io(1, 16, reg, val);118}119 120static inline void doc_flash_command(struct docg3 *docg3, u8 cmd)121{122 doc_writeb(docg3, cmd, DOC_FLASHCOMMAND);123}124 125static inline void doc_flash_sequence(struct docg3 *docg3, u8 seq)126{127 doc_writeb(docg3, seq, DOC_FLASHSEQUENCE);128}129 130static inline void doc_flash_address(struct docg3 *docg3, u8 addr)131{132 doc_writeb(docg3, addr, DOC_FLASHADDRESS);133}134 135static char const * const part_probes[] = { "cmdlinepart", "saftlpart", NULL };136 137static int doc_register_readb(struct docg3 *docg3, int reg)138{139 u8 val;140 141 doc_writew(docg3, reg, DOC_READADDRESS);142 val = doc_readb(docg3, reg);143 doc_vdbg("Read register %04x : %02x\n", reg, val);144 return val;145}146 147static int doc_register_readw(struct docg3 *docg3, int reg)148{149 u16 val;150 151 doc_writew(docg3, reg, DOC_READADDRESS);152 val = doc_readw(docg3, reg);153 doc_vdbg("Read register %04x : %04x\n", reg, val);154 return val;155}156 157/**158 * doc_delay - delay docg3 operations159 * @docg3: the device160 * @nbNOPs: the number of NOPs to issue161 *162 * As no specification is available, the right timings between chip commands are163 * unknown. The only available piece of information are the observed nops on a164 * working docg3 chip.165 * Therefore, doc_delay relies on a busy loop of NOPs, instead of scheduler166 * friendlier msleep() functions or blocking mdelay().167 */168static void doc_delay(struct docg3 *docg3, int nbNOPs)169{170 int i;171 172 doc_vdbg("NOP x %d\n", nbNOPs);173 for (i = 0; i < nbNOPs; i++)174 doc_writeb(docg3, 0, DOC_NOP);175}176 177static int is_prot_seq_error(struct docg3 *docg3)178{179 int ctrl;180 181 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);182 return ctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR);183}184 185static int doc_is_ready(struct docg3 *docg3)186{187 int ctrl;188 189 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);190 return ctrl & DOC_CTRL_FLASHREADY;191}192 193static int doc_wait_ready(struct docg3 *docg3)194{195 int maxWaitCycles = 100;196 197 do {198 doc_delay(docg3, 4);199 cpu_relax();200 } while (!doc_is_ready(docg3) && maxWaitCycles--);201 doc_delay(docg3, 2);202 if (maxWaitCycles > 0)203 return 0;204 else205 return -EIO;206}207 208static int doc_reset_seq(struct docg3 *docg3)209{210 int ret;211 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);217 218 doc_dbg("doc_reset_seq() -> isReady=%s\n", ret ? "false" : "true");219 return ret;220}221 222/**223 * doc_read_data_area - Read data from data area224 * @docg3: the device225 * @buf: the buffer to fill in (might be NULL is dummy reads)226 * @len: the length to read227 * @first: first time read, DOC_READADDRESS should be set228 *229 * Reads bytes from flash data. Handles the single byte / even bytes reads.230 */231static void doc_read_data_area(struct docg3 *docg3, void *buf, int len,232 int first)233{234 int i, cdr, len4;235 u16 data16, *dst16;236 u8 data8, *dst8;237 238 doc_dbg("doc_read_data_area(buf=%p, len=%d)\n", buf, len);239 cdr = len & 0x1;240 len4 = len - cdr;241 242 if (first)243 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);244 dst16 = buf;245 for (i = 0; i < len4; i += 2) {246 data16 = doc_readw(docg3, DOC_IOSPACE_DATA);247 if (dst16) {248 *dst16 = data16;249 dst16++;250 }251 }252 253 if (cdr) {254 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,255 DOC_READADDRESS);256 doc_delay(docg3, 1);257 dst8 = (u8 *)dst16;258 for (i = 0; i < cdr; i++) {259 data8 = doc_readb(docg3, DOC_IOSPACE_DATA);260 if (dst8) {261 *dst8 = data8;262 dst8++;263 }264 }265 }266}267 268/**269 * doc_write_data_area - Write data into data area270 * @docg3: the device271 * @buf: the buffer to get input bytes from272 * @len: the length to write273 *274 * Writes bytes into flash data. Handles the single byte / even bytes writes.275 */276static void doc_write_data_area(struct docg3 *docg3, const void *buf, int len)277{278 int i, cdr, len4;279 u16 *src16;280 u8 *src8;281 282 doc_dbg("doc_write_data_area(buf=%p, len=%d)\n", buf, len);283 cdr = len & 0x3;284 len4 = len - cdr;285 286 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);287 src16 = (u16 *)buf;288 for (i = 0; i < len4; i += 2) {289 doc_writew(docg3, *src16, DOC_IOSPACE_DATA);290 src16++;291 }292 293 src8 = (u8 *)src16;294 for (i = 0; i < cdr; i++) {295 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,296 DOC_READADDRESS);297 doc_writeb(docg3, *src8, DOC_IOSPACE_DATA);298 src8++;299 }300}301 302/**303 * doc_set_reliable_mode - Sets the flash to normal or reliable data mode304 * @docg3: the device305 *306 * The reliable data mode is a bit slower than the fast mode, but less errors307 * occur. Entering the reliable mode cannot be done without entering the fast308 * mode first.309 *310 * In reliable mode, pages 2*n and 2*n+1 are clones. Writing to page 0 of blocks311 * (4,5) make the hardware write also to page 1 of blocks blocks(4,5). Reading312 * from page 0 of blocks (4,5) or from page 1 of blocks (4,5) gives the same313 * result, which is a logical and between bytes from page 0 and page 1 (which is314 * consistent with the fact that writing to a page is _clearing_ bits of that315 * page).316 */317static void doc_set_reliable_mode(struct docg3 *docg3)318{319 static char *strmode[] = { "normal", "fast", "reliable", "invalid" };320 321 doc_dbg("doc_set_reliable_mode(%s)\n", strmode[docg3->reliable]);322 switch (docg3->reliable) {323 case 0:324 break;325 case 1:326 doc_flash_sequence(docg3, DOC_SEQ_SET_FASTMODE);327 doc_flash_command(docg3, DOC_CMD_FAST_MODE);328 break;329 case 2: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);333 break;334 default:335 doc_err("doc_set_reliable_mode(): invalid mode\n");336 break;337 }338 doc_delay(docg3, 2);339}340 341/**342 * doc_set_asic_mode - Set the ASIC mode343 * @docg3: the device344 * @mode: the mode345 *346 * The ASIC can work in 3 modes :347 * - RESET: all registers are zeroed348 * - NORMAL: receives and handles commands349 * - POWERDOWN: minimal poweruse, flash parts shut off350 */351static void doc_set_asic_mode(struct docg3 *docg3, u8 mode)352{353 int i;354 355 for (i = 0; i < 12; i++)356 doc_readb(docg3, DOC_IOSPACE_IPL);357 358 mode |= DOC_ASICMODE_MDWREN;359 doc_dbg("doc_set_asic_mode(%02x)\n", mode);360 doc_writeb(docg3, mode, DOC_ASICMODE);361 doc_writeb(docg3, ~mode, DOC_ASICMODECONFIRM);362 doc_delay(docg3, 1);363}364 365/**366 * doc_set_device_id - Sets the devices id for cascaded G3 chips367 * @docg3: the device368 * @id: the chip to select (amongst 0, 1, 2, 3)369 *370 * There can be 4 cascaded G3 chips. This function selects the one which will371 * should be the active one.372 */373static void doc_set_device_id(struct docg3 *docg3, int id)374{375 u8 ctrl;376 377 doc_dbg("doc_set_device_id(%d)\n", id);378 doc_writeb(docg3, id, DOC_DEVICESELECT);379 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);380 381 ctrl &= ~DOC_CTRL_VIOLATION;382 ctrl |= DOC_CTRL_CE;383 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);384}385 386/**387 * doc_set_extra_page_mode - Change flash page layout388 * @docg3: the device389 *390 * Normally, the flash page is split into the data (512 bytes) and the out of391 * band data (16 bytes). For each, 4 more bytes can be accessed, where the wear392 * leveling counters are stored. To access this last area of 4 bytes, a special393 * mode must be input to the flash ASIC.394 *395 * Returns 0 if no error occurred, -EIO else.396 */397static int doc_set_extra_page_mode(struct docg3 *docg3)398{399 int fctrl;400 401 doc_dbg("doc_set_extra_page_mode()\n");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);405 406 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);407 if (fctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR))408 return -EIO;409 else410 return 0;411}412 413/**414 * doc_setup_addr_sector - Setup blocks/page/ofs address for one plane415 * @docg3: the device416 * @sector: the sector417 */418static void doc_setup_addr_sector(struct docg3 *docg3, int sector)419{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);425}426 427/**428 * doc_setup_writeaddr_sector - Setup blocks/page/ofs address for one plane429 * @docg3: the device430 * @sector: the sector431 * @ofs: the offset in the page, between 0 and (512 + 16 + 512)432 */433static void doc_setup_writeaddr_sector(struct docg3 *docg3, int sector, int ofs)434{435 ofs = ofs >> 2;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);442}443 444/**445 * doc_read_seek - Set both flash planes to the specified block, page for reading446 * @docg3: the device447 * @block0: the first plane block index448 * @block1: the second plane block index449 * @page: the page index within the block450 * @wear: if true, read will occur on the 4 extra bytes of the wear area451 * @ofs: offset in page to read452 *453 * Programs the flash even and odd planes to the specific block and page.454 * Alternatively, programs the flash to the wear area of the specified page.455 */456static int doc_read_seek(struct docg3 *docg3, int block0, int block1, int page,457 int wear, int ofs)458{459 int sector, ret = 0;460 461 doc_dbg("doc_seek(blocks=(%d,%d), page=%d, ofs=%d, wear=%d)\n",462 block0, block1, page, ofs, wear);463 464 if (!wear && (ofs < 2 * DOC_LAYOUT_PAGE_SIZE)) {465 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);466 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);467 doc_delay(docg3, 2);468 } else {469 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);470 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);471 doc_delay(docg3, 2);472 }473 474 doc_set_reliable_mode(docg3);475 if (wear)476 ret = doc_set_extra_page_mode(docg3);477 if (ret)478 goto out;479 480 doc_flash_sequence(docg3, DOC_SEQ_READ);481 sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);482 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);483 doc_setup_addr_sector(docg3, sector);484 485 sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);486 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);487 doc_setup_addr_sector(docg3, sector);488 doc_delay(docg3, 1);489 490out:491 return ret;492}493 494/**495 * doc_write_seek - Set both flash planes to the specified block, page for writing496 * @docg3: the device497 * @block0: the first plane block index498 * @block1: the second plane block index499 * @page: the page index within the block500 * @ofs: offset in page to write501 *502 * Programs the flash even and odd planes to the specific block and page.503 * Alternatively, programs the flash to the wear area of the specified page.504 */505static int doc_write_seek(struct docg3 *docg3, int block0, int block1, int page,506 int ofs)507{508 int ret = 0, sector;509 510 doc_dbg("doc_write_seek(blocks=(%d,%d), page=%d, ofs=%d)\n",511 block0, block1, page, ofs);512 513 doc_set_reliable_mode(docg3);514 515 if (ofs < 2 * DOC_LAYOUT_PAGE_SIZE) {516 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);517 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);518 doc_delay(docg3, 2);519 } else {520 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);521 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);522 doc_delay(docg3, 2);523 }524 525 doc_flash_sequence(docg3, DOC_SEQ_PAGE_SETUP);526 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);527 528 sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);529 doc_setup_writeaddr_sector(docg3, sector, ofs);530 531 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE3);532 doc_delay(docg3, 2);533 ret = doc_wait_ready(docg3);534 if (ret)535 goto out;536 537 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);538 sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);539 doc_setup_writeaddr_sector(docg3, sector, ofs);540 doc_delay(docg3, 1);541 542out:543 return ret;544}545 546 547/**548 * doc_read_page_ecc_init - Initialize hardware ECC engine549 * @docg3: the device550 * @len: the number of bytes covered by the ECC (BCH covered)551 *552 * The function does initialize the hardware ECC engine to compute the Hamming553 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).554 *555 * Return 0 if succeeded, -EIO on error556 */557static int doc_read_page_ecc_init(struct docg3 *docg3, int len)558{559 doc_writew(docg3, DOC_ECCCONF0_READ_MODE560 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE561 | (len & DOC_ECCCONF0_DATA_BYTES_MASK),562 DOC_ECCCONF0);563 doc_delay(docg3, 4);564 doc_register_readb(docg3, DOC_FLASHCONTROL);565 return doc_wait_ready(docg3);566}567 568/**569 * doc_write_page_ecc_init - Initialize hardware BCH ECC engine570 * @docg3: the device571 * @len: the number of bytes covered by the ECC (BCH covered)572 *573 * The function does initialize the hardware ECC engine to compute the Hamming574 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).575 *576 * Return 0 if succeeded, -EIO on error577 */578static int doc_write_page_ecc_init(struct docg3 *docg3, int len)579{580 doc_writew(docg3, DOC_ECCCONF0_WRITE_MODE581 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE582 | (len & DOC_ECCCONF0_DATA_BYTES_MASK),583 DOC_ECCCONF0);584 doc_delay(docg3, 4);585 doc_register_readb(docg3, DOC_FLASHCONTROL);586 return doc_wait_ready(docg3);587}588 589/**590 * doc_ecc_disable - Disable Hamming and BCH ECC hardware calculator591 * @docg3: the device592 *593 * Disables the hardware ECC generator and checker, for unchecked reads (as when594 * reading OOB only or write status byte).595 */596static void doc_ecc_disable(struct docg3 *docg3)597{598 doc_writew(docg3, DOC_ECCCONF0_READ_MODE, DOC_ECCCONF0);599 doc_delay(docg3, 4);600}601 602/**603 * doc_hamming_ecc_init - Initialize hardware Hamming ECC engine604 * @docg3: the device605 * @nb_bytes: the number of bytes covered by the ECC (Hamming covered)606 *607 * This function programs the ECC hardware to compute the hamming code on the608 * last provided N bytes to the hardware generator.609 */610static void doc_hamming_ecc_init(struct docg3 *docg3, int nb_bytes)611{612 u8 ecc_conf1;613 614 ecc_conf1 = doc_register_readb(docg3, DOC_ECCCONF1);615 ecc_conf1 &= ~DOC_ECCCONF1_HAMMING_BITS_MASK;616 ecc_conf1 |= (nb_bytes & DOC_ECCCONF1_HAMMING_BITS_MASK);617 doc_writeb(docg3, ecc_conf1, DOC_ECCCONF1);618}619 620/**621 * doc_ecc_bch_fix_data - Fix if need be read data from flash622 * @docg3: the device623 * @buf: the buffer of read data (512 + 7 + 1 bytes)624 * @hwecc: the hardware calculated ECC.625 * It's in fact recv_ecc ^ calc_ecc, where recv_ecc was read from OOB626 * area data, and calc_ecc the ECC calculated by the hardware generator.627 *628 * Checks if the received data matches the ECC, and if an error is detected,629 * tries to fix the bit flips (at most 4) in the buffer buf. As the docg3630 * understands the (data, ecc, syndroms) in an inverted order in comparison to631 * the BCH library, the function reverses the order of bits (ie. bit7 and bit0,632 * bit6 and bit 1, ...) for all ECC data.633 *634 * The hardware ecc unit produces oob_ecc ^ calc_ecc. The kernel's bch635 * algorithm is used to decode this. However the hw operates on page636 * data in a bit order that is the reverse of that of the bch alg,637 * requiring that the bits be reversed on the result. Thanks to Ivan638 * Djelic for his analysis.639 *640 * Returns number of fixed bits (0, 1, 2, 3, 4) or -EBADMSG if too many bit641 * errors were detected and cannot be fixed.642 */643static int doc_ecc_bch_fix_data(struct docg3 *docg3, void *buf, u8 *hwecc)644{645 u8 ecc[DOC_ECC_BCH_SIZE];646 int errorpos[DOC_ECC_BCH_T], i, numerrs;647 648 for (i = 0; i < DOC_ECC_BCH_SIZE; i++)649 ecc[i] = bitrev8(hwecc[i]);650 numerrs = bch_decode(docg3->cascade->bch, NULL,651 DOC_ECC_BCH_COVERED_BYTES,652 NULL, ecc, NULL, errorpos);653 BUG_ON(numerrs == -EINVAL);654 if (numerrs < 0)655 goto out;656 657 for (i = 0; i < numerrs; i++)658 errorpos[i] = (errorpos[i] & ~7) | (7 - (errorpos[i] & 7));659 for (i = 0; i < numerrs; i++)660 if (errorpos[i] < DOC_ECC_BCH_COVERED_BYTES*8)661 /* error is located in data, correct it */662 change_bit(errorpos[i], buf);663out:664 doc_dbg("doc_ecc_bch_fix_data: flipped %d bits\n", numerrs);665 return numerrs;666}667 668 669/**670 * doc_read_page_prepare - Prepares reading data from a flash page671 * @docg3: the device672 * @block0: the first plane block index on flash memory673 * @block1: the second plane block index on flash memory674 * @page: the page index in the block675 * @offset: the offset in the page (must be a multiple of 4)676 *677 * Prepares the page to be read in the flash memory :678 * - tell ASIC to map the flash pages679 * - tell ASIC to be in read mode680 *681 * After a call to this method, a call to doc_read_page_finish is mandatory,682 * to end the read cycle of the flash.683 *684 * Read data from a flash page. The length to be read must be between 0 and685 * (page_size + oob_size + wear_size), ie. 532, and a multiple of 4 (because686 * the extra bytes reading is not implemented).687 *688 * As pages are grouped by 2 (in 2 planes), reading from a page must be done689 * in two steps:690 * - one read of 512 bytes at offset 0691 * - one read of 512 bytes at offset 512 + 16692 *693 * Returns 0 if successful, -EIO if a read error occurred.694 */695static int doc_read_page_prepare(struct docg3 *docg3, int block0, int block1,696 int page, int offset)697{698 int wear_area = 0, ret = 0;699 700 doc_dbg("doc_read_page_prepare(blocks=(%d,%d), page=%d, ofsInPage=%d)\n",701 block0, block1, page, offset);702 if (offset >= DOC_LAYOUT_WEAR_OFFSET)703 wear_area = 1;704 if (!wear_area && offset > (DOC_LAYOUT_PAGE_OOB_SIZE * 2))705 return -EINVAL;706 707 doc_set_device_id(docg3, docg3->device_id);708 ret = doc_reset_seq(docg3);709 if (ret)710 goto err;711 712 /* Program the flash address block and page */713 ret = doc_read_seek(docg3, block0, block1, page, wear_area, offset);714 if (ret)715 goto err;716 717 doc_flash_command(docg3, DOC_CMD_READ_ALL_PLANES);718 doc_delay(docg3, 2);719 doc_wait_ready(docg3);720 721 doc_flash_command(docg3, DOC_CMD_SET_ADDR_READ);722 doc_delay(docg3, 1);723 if (offset >= DOC_LAYOUT_PAGE_SIZE * 2)724 offset -= 2 * DOC_LAYOUT_PAGE_SIZE;725 doc_flash_address(docg3, offset >> 2);726 doc_delay(docg3, 1);727 doc_wait_ready(docg3);728 729 doc_flash_command(docg3, DOC_CMD_READ_FLASH);730 731 return 0;732err:733 doc_writeb(docg3, 0, DOC_DATAEND);734 doc_delay(docg3, 2);735 return -EIO;736}737 738/**739 * doc_read_page_getbytes - Reads bytes from a prepared page740 * @docg3: the device741 * @len: the number of bytes to be read (must be a multiple of 4)742 * @buf: the buffer to be filled in (or NULL is forget bytes)743 * @first: 1 if first time read, DOC_READADDRESS should be set744 * @last_odd: 1 if last read ended up on an odd byte745 *746 * Reads bytes from a prepared page. There is a trickery here : if the last read747 * ended up on an odd offset in the 1024 bytes double page, ie. between the 2748 * planes, the first byte must be read apart. If a word (16bit) read was used,749 * the read would return the byte of plane 2 as low *and* high endian, which750 * will mess the read.751 *752 */753static int doc_read_page_getbytes(struct docg3 *docg3, int len, u_char *buf,754 int first, int last_odd)755{756 if (last_odd && len > 0) {757 doc_read_data_area(docg3, buf, 1, first);758 doc_read_data_area(docg3, buf ? buf + 1 : buf, len - 1, 0);759 } else {760 doc_read_data_area(docg3, buf, len, first);761 }762 doc_delay(docg3, 2);763 return len;764}765 766/**767 * doc_write_page_putbytes - Writes bytes into a prepared page768 * @docg3: the device769 * @len: the number of bytes to be written770 * @buf: the buffer of input bytes771 *772 */773static void doc_write_page_putbytes(struct docg3 *docg3, int len,774 const u_char *buf)775{776 doc_write_data_area(docg3, buf, len);777 doc_delay(docg3, 2);778}779 780/**781 * doc_get_bch_hw_ecc - Get hardware calculated BCH ECC782 * @docg3: the device783 * @hwecc: the array of 7 integers where the hardware ecc will be stored784 */785static void doc_get_bch_hw_ecc(struct docg3 *docg3, u8 *hwecc)786{787 int i;788 789 for (i = 0; i < DOC_ECC_BCH_SIZE; i++)790 hwecc[i] = doc_register_readb(docg3, DOC_BCH_HW_ECC(i));791}792 793/**794 * doc_page_finish - Ends reading/writing of a flash page795 * @docg3: the device796 */797static void doc_page_finish(struct docg3 *docg3)798{799 doc_writeb(docg3, 0, DOC_DATAEND);800 doc_delay(docg3, 2);801}802 803/**804 * doc_read_page_finish - Ends reading of a flash page805 * @docg3: the device806 *807 * As a side effect, resets the chip selector to 0. This ensures that after each808 * read operation, the floor 0 is selected. Therefore, if the systems halts, the809 * reboot will boot on floor 0, where the IPL is.810 */811static void doc_read_page_finish(struct docg3 *docg3)812{813 doc_page_finish(docg3);814 doc_set_device_id(docg3, 0);815}816 817/**818 * calc_block_sector - Calculate blocks, pages and ofs.819 *820 * @from: offset in flash821 * @block0: first plane block index calculated822 * @block1: second plane block index calculated823 * @page: page calculated824 * @ofs: offset in page825 * @reliable: 0 if docg3 in normal mode, 1 if docg3 in fast mode, 2 if docg3 in826 * reliable mode.827 *828 * The calculation is based on the reliable/normal mode. In normal mode, the 64829 * pages of a block are available. In reliable mode, as pages 2*n and 2*n+1 are830 * clones, only 32 pages per block are available.831 */832static void calc_block_sector(loff_t from, int *block0, int *block1, int *page,833 int *ofs, int reliable)834{835 uint sector, pages_biblock;836 837 pages_biblock = DOC_LAYOUT_PAGES_PER_BLOCK * DOC_LAYOUT_NBPLANES;838 if (reliable == 1 || reliable == 2)839 pages_biblock /= 2;840 841 sector = from / DOC_LAYOUT_PAGE_SIZE;842 *block0 = sector / pages_biblock * DOC_LAYOUT_NBPLANES;843 *block1 = *block0 + 1;844 *page = sector % pages_biblock;845 *page /= DOC_LAYOUT_NBPLANES;846 if (reliable == 1 || reliable == 2)847 *page *= 2;848 if (sector % 2)849 *ofs = DOC_LAYOUT_PAGE_OOB_SIZE;850 else851 *ofs = 0;852}853 854/**855 * doc_read_oob - Read out of band bytes from flash856 * @mtd: the device857 * @from: the offset from first block and first page, in bytes, aligned on page858 * size859 * @ops: the mtd oob structure860 *861 * Reads flash memory OOB area of pages.862 *863 * Returns 0 if read successful, of -EIO, -EINVAL if an error occurred864 */865static int doc_read_oob(struct mtd_info *mtd, loff_t from,866 struct mtd_oob_ops *ops)867{868 struct docg3 *docg3 = mtd->priv;869 int block0, block1, page, ret, skip, ofs = 0;870 u8 *oobbuf = ops->oobbuf;871 u8 *buf = ops->datbuf;872 size_t len, ooblen, nbdata, nboob;873 u8 hwecc[DOC_ECC_BCH_SIZE], eccconf1;874 struct mtd_ecc_stats old_stats;875 int max_bitflips = 0;876 877 if (buf)878 len = ops->len;879 else880 len = 0;881 if (oobbuf)882 ooblen = ops->ooblen;883 else884 ooblen = 0;885 886 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)887 oobbuf += ops->ooboffs;888 889 doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",890 from, ops->mode, buf, len, oobbuf, ooblen);891 if (ooblen % DOC_LAYOUT_OOB_SIZE)892 return -EINVAL;893 894 ops->oobretlen = 0;895 ops->retlen = 0;896 ret = 0;897 skip = from % DOC_LAYOUT_PAGE_SIZE;898 mutex_lock(&docg3->cascade->lock);899 old_stats = mtd->ecc_stats;900 while (ret >= 0 && (len > 0 || ooblen > 0)) {901 calc_block_sector(from - skip, &block0, &block1, &page, &ofs,902 docg3->reliable);903 nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip);904 nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE);905 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs);906 if (ret < 0)907 goto out;908 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);909 if (ret < 0)910 goto err_in_read;911 ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0);912 if (ret < skip)913 goto err_in_read;914 ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2);915 if (ret < nbdata)916 goto err_in_read;917 doc_read_page_getbytes(docg3,918 DOC_LAYOUT_PAGE_SIZE - nbdata - skip,919 NULL, 0, (skip + nbdata) % 2);920 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0);921 if (ret < nboob)922 goto err_in_read;923 doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob,924 NULL, 0, nboob % 2);925 926 doc_get_bch_hw_ecc(docg3, hwecc);927 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);928 929 if (nboob >= DOC_LAYOUT_OOB_SIZE) {930 doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf);931 doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]);932 doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8);933 doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]);934 }935 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1);936 doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc);937 938 ret = -EIO;939 if (is_prot_seq_error(docg3))940 goto err_in_read;941 ret = 0;942 if ((block0 >= DOC_LAYOUT_BLOCK_FIRST_DATA) &&943 (eccconf1 & DOC_ECCCONF1_BCH_SYNDROM_ERR) &&944 (eccconf1 & DOC_ECCCONF1_PAGE_IS_WRITTEN) &&945 (ops->mode != MTD_OPS_RAW) &&946 (nbdata == DOC_LAYOUT_PAGE_SIZE)) {947 ret = doc_ecc_bch_fix_data(docg3, buf, hwecc);948 if (ret < 0) {949 mtd->ecc_stats.failed++;950 ret = -EBADMSG;951 }952 if (ret > 0) {953 mtd->ecc_stats.corrected += ret;954 max_bitflips = max(max_bitflips, ret);955 ret = max_bitflips;956 }957 }958 959 doc_read_page_finish(docg3);960 ops->retlen += nbdata;961 ops->oobretlen += nboob;962 buf += nbdata;963 oobbuf += nboob;964 len -= nbdata;965 ooblen -= nboob;966 from += DOC_LAYOUT_PAGE_SIZE;967 skip = 0;968 }969 970out:971 if (ops->stats) {972 ops->stats->uncorrectable_errors +=973 mtd->ecc_stats.failed - old_stats.failed;974 ops->stats->corrected_bitflips +=975 mtd->ecc_stats.corrected - old_stats.corrected;976 }977 mutex_unlock(&docg3->cascade->lock);978 return ret;979err_in_read:980 doc_read_page_finish(docg3);981 goto out;982}983 984static int doc_reload_bbt(struct docg3 *docg3)985{986 int block = DOC_LAYOUT_BLOCK_BBT;987 int ret = 0, nbpages, page;988 u_char *buf = docg3->bbt;989 990 nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);991 for (page = 0; !ret && (page < nbpages); page++) {992 ret = doc_read_page_prepare(docg3, block, block + 1,993 page + DOC_LAYOUT_PAGE_BBT, 0);994 if (!ret)995 ret = doc_read_page_ecc_init(docg3,996 DOC_LAYOUT_PAGE_SIZE);997 if (!ret)998 doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE,999 buf, 1, 0);1000 buf += DOC_LAYOUT_PAGE_SIZE;1001 }1002 doc_read_page_finish(docg3);1003 return ret;1004}1005 1006/**1007 * doc_block_isbad - Checks whether a block is good or not1008 * @mtd: the device1009 * @from: the offset to find the correct block1010 *1011 * Returns 1 if block is bad, 0 if block is good1012 */1013static int doc_block_isbad(struct mtd_info *mtd, loff_t from)1014{1015 struct docg3 *docg3 = mtd->priv;1016 int block0, block1, page, ofs, is_good;1017 1018 calc_block_sector(from, &block0, &block1, &page, &ofs,1019 docg3->reliable);1020 doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n",1021 from, block0, block1, page, ofs);1022 1023 if (block0 < DOC_LAYOUT_BLOCK_FIRST_DATA)1024 return 0;1025 if (block1 > docg3->max_block)1026 return -EINVAL;1027 1028 is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7));1029 return !is_good;1030}1031 1032#if 01033/**1034 * doc_get_erase_count - Get block erase count1035 * @docg3: the device1036 * @from: the offset in which the block is.1037 *1038 * Get the number of times a block was erased. The number is the maximum of1039 * erase times between first and second plane (which should be equal normally).1040 *1041 * Returns The number of erases, or -EINVAL or -EIO on error.1042 */1043static int doc_get_erase_count(struct docg3 *docg3, loff_t from)1044{1045 u8 buf[DOC_LAYOUT_WEAR_SIZE];1046 int ret, plane1_erase_count, plane2_erase_count;1047 int block0, block1, page, ofs;1048 1049 doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from, buf);1050 if (from % DOC_LAYOUT_PAGE_SIZE)1051 return -EINVAL;1052 calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable);1053 if (block1 > docg3->max_block)1054 return -EINVAL;1055 1056 ret = doc_reset_seq(docg3);1057 if (!ret)1058 ret = doc_read_page_prepare(docg3, block0, block1, page,1059 ofs + DOC_LAYOUT_WEAR_OFFSET, 0);1060 if (!ret)1061 ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE,1062 buf, 1, 0);1063 doc_read_page_finish(docg3);1064 1065 if (ret || (buf[0] != DOC_ERASE_MARK) || (buf[2] != DOC_ERASE_MARK))1066 return -EIO;1067 plane1_erase_count = (u8)(~buf[1]) | ((u8)(~buf[4]) << 8)1068 | ((u8)(~buf[5]) << 16);1069 plane2_erase_count = (u8)(~buf[3]) | ((u8)(~buf[6]) << 8)1070 | ((u8)(~buf[7]) << 16);1071 1072 return max(plane1_erase_count, plane2_erase_count);1073}1074#endif1075 1076/**1077 * doc_get_op_status - get erase/write operation status1078 * @docg3: the device1079 *1080 * Queries the status from the chip, and returns it1081 *1082 * Returns the status (bits DOC_PLANES_STATUS_*)1083 */1084static int doc_get_op_status(struct docg3 *docg3)1085{1086 u8 status;1087 1088 doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS);1089 doc_flash_command(docg3, DOC_CMD_PLANES_STATUS);1090 doc_delay(docg3, 5);1091 1092 doc_ecc_disable(docg3);1093 doc_read_data_area(docg3, &status, 1, 1);1094 return status;1095}1096 1097/**1098 * doc_write_erase_wait_status - wait for write or erase completion1099 * @docg3: the device1100 *1101 * Wait for the chip to be ready again after erase or write operation, and check1102 * erase/write status.1103 *1104 * Returns 0 if erase successful, -EIO if erase/write issue, -ETIMEOUT if1105 * timeout1106 */1107static int doc_write_erase_wait_status(struct docg3 *docg3)1108{1109 int i, status, ret = 0;1110 1111 for (i = 0; !doc_is_ready(docg3) && i < 5; i++)1112 msleep(20);1113 if (!doc_is_ready(docg3)) {1114 doc_dbg("Timeout reached and the chip is still not ready\n");1115 ret = -EAGAIN;1116 goto out;1117 }1118 1119 status = doc_get_op_status(docg3);1120 if (status & DOC_PLANES_STATUS_FAIL) {1121 doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n",1122 status);1123 ret = -EIO;1124 }1125 1126out:1127 doc_page_finish(docg3);1128 return ret;1129}1130 1131/**1132 * doc_erase_block - Erase a couple of blocks1133 * @docg3: the device1134 * @block0: the first block to erase (leftmost plane)1135 * @block1: the second block to erase (rightmost plane)1136 *1137 * Erase both blocks, and return operation status1138 *1139 * Returns 0 if erase successful, -EIO if erase issue, -ETIMEOUT if chip not1140 * ready for too long1141 */1142static int doc_erase_block(struct docg3 *docg3, int block0, int block1)1143{1144 int ret, sector;1145 1146 doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0, block1);1147 ret = doc_reset_seq(docg3);1148 if (ret)1149 return -EIO;1150 1151 doc_set_reliable_mode(docg3);1152 doc_flash_sequence(docg3, DOC_SEQ_ERASE);1153 1154 sector = block0 << DOC_ADDR_BLOCK_SHIFT;1155 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);1156 doc_setup_addr_sector(docg3, sector);1157 sector = block1 << DOC_ADDR_BLOCK_SHIFT;1158 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);1159 doc_setup_addr_sector(docg3, sector);1160 doc_delay(docg3, 1);1161 1162 doc_flash_command(docg3, DOC_CMD_ERASECYCLE2);1163 doc_delay(docg3, 2);1164 1165 if (is_prot_seq_error(docg3)) {1166 doc_err("Erase blocks %d,%d error\n", block0, block1);1167 return -EIO;1168 }1169 1170 return doc_write_erase_wait_status(docg3);1171}1172 1173/**1174 * doc_erase - Erase a portion of the chip1175 * @mtd: the device1176 * @info: the erase info1177 *1178 * Erase a bunch of contiguous blocks, by pairs, as a "mtd" page of 1024 is1179 * split into 2 pages of 512 bytes on 2 contiguous blocks.1180 *1181 * Returns 0 if erase successful, -EINVAL if addressing error, -EIO if erase1182 * issue1183 */1184static int doc_erase(struct mtd_info *mtd, struct erase_info *info)1185{1186 struct docg3 *docg3 = mtd->priv;1187 uint64_t len;1188 int block0, block1, page, ret = 0, ofs = 0;1189 1190 doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len);1191 1192 calc_block_sector(info->addr + info->len, &block0, &block1, &page,1193 &ofs, docg3->reliable);1194 if (info->addr + info->len > mtd->size || page || ofs)1195 return -EINVAL;1196 1197 calc_block_sector(info->addr, &block0, &block1, &page, &ofs,1198 docg3->reliable);1199 mutex_lock(&docg3->cascade->lock);1200 doc_set_device_id(docg3, docg3->device_id);1201 doc_set_reliable_mode(docg3);1202 for (len = info->len; !ret && len > 0; len -= mtd->erasesize) {1203 ret = doc_erase_block(docg3, block0, block1);1204 block0 += 2;1205 block1 += 2;1206 }1207 mutex_unlock(&docg3->cascade->lock);1208 1209 return ret;1210}1211 1212/**1213 * doc_write_page - Write a single page to the chip1214 * @docg3: the device1215 * @to: the offset from first block and first page, in bytes, aligned on page1216 * size1217 * @buf: buffer to get bytes from1218 * @oob: buffer to get out of band bytes from (can be NULL if no OOB should be1219 * written)1220 * @autoecc: if 0, all 16 bytes from OOB are taken, regardless of HW Hamming or1221 * BCH computations. If 1, only bytes 0-7 and byte 15 are taken,1222 * remaining ones are filled with hardware Hamming and BCH1223 * computations. Its value is not meaningfull is oob == NULL.1224 *1225 * Write one full page (ie. 1 page split on two planes), of 512 bytes, with the1226 * OOB data. The OOB ECC is automatically computed by the hardware Hamming and1227 * BCH generator if autoecc is not null.1228 *1229 * Returns 0 if write successful, -EIO if write error, -EAGAIN if timeout1230 */1231static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf,1232 const u_char *oob, int autoecc)1233{1234 int block0, block1, page, ret, ofs = 0;1235 u8 hwecc[DOC_ECC_BCH_SIZE], hamming;1236 1237 doc_dbg("doc_write_page(to=%lld)\n", to);1238 calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable);1239 1240 doc_set_device_id(docg3, docg3->device_id);1241 ret = doc_reset_seq(docg3);1242 if (ret)1243 goto err;1244 1245 /* Program the flash address block and page */1246 ret = doc_write_seek(docg3, block0, block1, page, ofs);1247 if (ret)1248 goto err;1249 1250 doc_write_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);1251 doc_delay(docg3, 2);1252 doc_write_page_putbytes(docg3, DOC_LAYOUT_PAGE_SIZE, buf);1253 1254 if (oob && autoecc) {1255 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob);1256 doc_delay(docg3, 2);1257 oob += DOC_LAYOUT_OOB_UNUSED_OFS;1258 1259 hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY);1260 doc_delay(docg3, 2);1261 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ,1262 &hamming);1263 doc_delay(docg3, 2);1264 1265 doc_get_bch_hw_ecc(docg3, hwecc);1266 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_BCH_SZ, hwecc);1267 doc_delay(docg3, 2);1268 1269 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob);1270 }1271 if (oob && !autoecc)1272 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob);1273 1274 doc_delay(docg3, 2);1275 doc_page_finish(docg3);1276 doc_delay(docg3, 2);1277 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE2);1278 doc_delay(docg3, 2);1279 1280 /*1281 * The wait status will perform another doc_page_finish() call, but that1282 * seems to please the docg3, so leave it.1283 */1284 ret = doc_write_erase_wait_status(docg3);1285 return ret;1286err:1287 doc_read_page_finish(docg3);1288 return ret;1289}1290 1291/**1292 * doc_guess_autoecc - Guess autoecc mode from mbd_oob_ops1293 * @ops: the oob operations1294 *1295 * Returns 0 or 1 if success, -EINVAL if invalid oob mode1296 */1297static int doc_guess_autoecc(struct mtd_oob_ops *ops)1298{1299 int autoecc;1300 1301 switch (ops->mode) {1302 case MTD_OPS_PLACE_OOB:1303 case MTD_OPS_AUTO_OOB:1304 autoecc = 1;1305 break;1306 case MTD_OPS_RAW:1307 autoecc = 0;1308 break;1309 default:1310 autoecc = -EINVAL;1311 }1312 return autoecc;1313}1314 1315/**1316 * doc_fill_autooob - Fill a 16 bytes OOB from 8 non-ECC bytes1317 * @dst: the target 16 bytes OOB buffer1318 * @oobsrc: the source 8 bytes non-ECC OOB buffer1319 *1320 */1321static void doc_fill_autooob(u8 *dst, u8 *oobsrc)1322{1323 memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ);1324 dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ];1325}1326 1327/**1328 * doc_backup_oob - Backup OOB into docg3 structure1329 * @docg3: the device1330 * @to: the page offset in the chip1331 * @ops: the OOB size and buffer1332 *1333 * As the docg3 should write a page with its OOB in one pass, and some userland1334 * applications do write_oob() to setup the OOB and then write(), store the OOB1335 * into a temporary storage. This is very dangerous, as 2 concurrent1336 * applications could store an OOB, and then write their pages (which will1337 * result into one having its OOB corrupted).1338 *1339 * The only reliable way would be for userland to call doc_write_oob() with both1340 * the page data _and_ the OOB area.1341 *1342 * Returns 0 if success, -EINVAL if ops content invalid1343 */1344static int doc_backup_oob(struct docg3 *docg3, loff_t to,1345 struct mtd_oob_ops *ops)1346{1347 int ooblen = ops->ooblen, autoecc;1348 1349 if (ooblen != DOC_LAYOUT_OOB_SIZE)1350 return -EINVAL;1351 autoecc = doc_guess_autoecc(ops);1352 if (autoecc < 0)1353 return autoecc;1354 1355 docg3->oob_write_ofs = to;1356 docg3->oob_autoecc = autoecc;1357 if (ops->mode == MTD_OPS_AUTO_OOB) {1358 doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf);1359 ops->oobretlen = 8;1360 } else {1361 memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE);1362 ops->oobretlen = DOC_LAYOUT_OOB_SIZE;1363 }1364 return 0;1365}1366 1367/**1368 * doc_write_oob - Write out of band bytes to flash1369 * @mtd: the device1370 * @ofs: the offset from first block and first page, in bytes, aligned on page1371 * size1372 * @ops: the mtd oob structure1373 *1374 * Either write OOB data into a temporary buffer, for the subsequent write1375 * page. The provided OOB should be 16 bytes long. If a data buffer is provided1376 * as well, issue the page write.1377 * Or provide data without OOB, and then a all zeroed OOB will be used (ECC will1378 * still be filled in if asked for).1379 *1380 * Returns 0 is successful, EINVAL if length is not 14 bytes1381 */1382static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,1383 struct mtd_oob_ops *ops)1384{1385 struct docg3 *docg3 = mtd->priv;1386 int ret, autoecc, oobdelta;1387 u8 *oobbuf = ops->oobbuf;1388 u8 *buf = ops->datbuf;1389 size_t len, ooblen;1390 u8 oob[DOC_LAYOUT_OOB_SIZE];1391 1392 if (buf)1393 len = ops->len;1394 else1395 len = 0;1396 if (oobbuf)1397 ooblen = ops->ooblen;1398 else1399 ooblen = 0;1400 1401 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)1402 oobbuf += ops->ooboffs;1403 1404 doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",1405 ofs, ops->mode, buf, len, oobbuf, ooblen);1406 switch (ops->mode) {1407 case MTD_OPS_PLACE_OOB:1408 case MTD_OPS_RAW:1409 oobdelta = mtd->oobsize;1410 break;1411 case MTD_OPS_AUTO_OOB:1412 oobdelta = mtd->oobavail;1413 break;1414 default:1415 return -EINVAL;1416 }1417 if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % oobdelta) ||1418 (ofs % DOC_LAYOUT_PAGE_SIZE))1419 return -EINVAL;1420 if (len && ooblen &&1421 (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta))1422 return -EINVAL;1423 1424 ops->oobretlen = 0;1425 ops->retlen = 0;1426 ret = 0;1427 if (len == 0 && ooblen == 0)1428 return -EINVAL;1429 if (len == 0 && ooblen > 0)1430 return doc_backup_oob(docg3, ofs, ops);1431 1432 autoecc = doc_guess_autoecc(ops);1433 if (autoecc < 0)1434 return autoecc;1435 1436 mutex_lock(&docg3->cascade->lock);1437 while (!ret && len > 0) {1438 memset(oob, 0, sizeof(oob));1439 if (ofs == docg3->oob_write_ofs)1440 memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE);1441 else if (ooblen > 0 && ops->mode == MTD_OPS_AUTO_OOB)1442 doc_fill_autooob(oob, oobbuf);1443 else if (ooblen > 0)1444 memcpy(oob, oobbuf, DOC_LAYOUT_OOB_SIZE);1445 ret = doc_write_page(docg3, ofs, buf, oob, autoecc);1446 1447 ofs += DOC_LAYOUT_PAGE_SIZE;1448 len -= DOC_LAYOUT_PAGE_SIZE;1449 buf += DOC_LAYOUT_PAGE_SIZE;1450 if (ooblen) {1451 oobbuf += oobdelta;1452 ooblen -= oobdelta;1453 ops->oobretlen += oobdelta;1454 }1455 ops->retlen += DOC_LAYOUT_PAGE_SIZE;1456 }1457 1458 doc_set_device_id(docg3, 0);1459 mutex_unlock(&docg3->cascade->lock);1460 return ret;1461}1462 1463static struct docg3 *sysfs_dev2docg3(struct device *dev,1464 struct device_attribute *attr)1465{1466 int floor;1467 struct mtd_info **docg3_floors = dev_get_drvdata(dev);1468 1469 floor = attr->attr.name[1] - '0';1470 if (floor < 0 || floor >= DOC_MAX_NBFLOORS)1471 return NULL;1472 else1473 return docg3_floors[floor]->priv;1474}1475 1476static ssize_t dps0_is_key_locked(struct device *dev,1477 struct device_attribute *attr, char *buf)1478{1479 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);1480 int dps0;1481 1482 mutex_lock(&docg3->cascade->lock);1483 doc_set_device_id(docg3, docg3->device_id);1484 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);1485 doc_set_device_id(docg3, 0);1486 mutex_unlock(&docg3->cascade->lock);1487 1488 return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK));1489}1490 1491static ssize_t dps1_is_key_locked(struct device *dev,1492 struct device_attribute *attr, char *buf)1493{1494 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);1495 int dps1;1496 1497 mutex_lock(&docg3->cascade->lock);1498 doc_set_device_id(docg3, docg3->device_id);1499 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);1500 doc_set_device_id(docg3, 0);1501 mutex_unlock(&docg3->cascade->lock);1502 1503 return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK));1504}1505 1506static ssize_t dps0_insert_key(struct device *dev,1507 struct device_attribute *attr,1508 const char *buf, size_t count)1509{1510 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);1511 int i;1512 1513 if (count != DOC_LAYOUT_DPS_KEY_LENGTH)1514 return -EINVAL;1515 1516 mutex_lock(&docg3->cascade->lock);1517 doc_set_device_id(docg3, docg3->device_id);1518 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)1519 doc_writeb(docg3, buf[i], DOC_DPS0_KEY);1520 doc_set_device_id(docg3, 0);1521 mutex_unlock(&docg3->cascade->lock);1522 return count;1523}1524 1525static ssize_t dps1_insert_key(struct device *dev,1526 struct device_attribute *attr,1527 const char *buf, size_t count)1528{1529 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);1530 int i;1531 1532 if (count != DOC_LAYOUT_DPS_KEY_LENGTH)1533 return -EINVAL;1534 1535 mutex_lock(&docg3->cascade->lock);1536 doc_set_device_id(docg3, docg3->device_id);1537 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)1538 doc_writeb(docg3, buf[i], DOC_DPS1_KEY);1539 doc_set_device_id(docg3, 0);1540 mutex_unlock(&docg3->cascade->lock);1541 return count;1542}1543 1544#define FLOOR_SYSFS(id) { \1545 __ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \1546 __ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \1547 __ATTR(f##id##_dps0_protection_key, S_IWUSR|S_IWGRP, NULL, dps0_insert_key), \1548 __ATTR(f##id##_dps1_protection_key, S_IWUSR|S_IWGRP, NULL, dps1_insert_key), \1549}1550 1551static struct device_attribute doc_sys_attrs[DOC_MAX_NBFLOORS][4] = {1552 FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3)1553};1554 1555static int doc_register_sysfs(struct platform_device *pdev,1556 struct docg3_cascade *cascade)1557{1558 struct device *dev = &pdev->dev;1559 int floor;1560 int ret;1561 int i;1562 1563 for (floor = 0;1564 floor < DOC_MAX_NBFLOORS && cascade->floors[floor];1565 floor++) {1566 for (i = 0; i < 4; i++) {1567 ret = device_create_file(dev, &doc_sys_attrs[floor][i]);1568 if (ret)1569 goto remove_files;1570 }1571 }1572 1573 return 0;1574 1575remove_files:1576 do {1577 while (--i >= 0)1578 device_remove_file(dev, &doc_sys_attrs[floor][i]);1579 i = 4;1580 } while (--floor >= 0);1581 1582 return ret;1583}1584 1585static void doc_unregister_sysfs(struct platform_device *pdev,1586 struct docg3_cascade *cascade)1587{1588 struct device *dev = &pdev->dev;1589 int floor, i;1590 1591 for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor];1592 floor++)1593 for (i = 0; i < 4; i++)1594 device_remove_file(dev, &doc_sys_attrs[floor][i]);1595}1596 1597/*1598 * Debug sysfs entries1599 */1600static int flashcontrol_show(struct seq_file *s, void *p)1601{1602 struct docg3 *docg3 = s->private;1603 1604 u8 fctrl;1605 1606 mutex_lock(&docg3->cascade->lock);1607 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);1608 mutex_unlock(&docg3->cascade->lock);1609 1610 seq_printf(s, "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n",1611 fctrl,1612 fctrl & DOC_CTRL_VIOLATION ? "protocol violation" : "-",1613 fctrl & DOC_CTRL_CE ? "active" : "inactive",1614 fctrl & DOC_CTRL_PROTECTION_ERROR ? "protection error" : "-",1615 fctrl & DOC_CTRL_SEQUENCE_ERROR ? "sequence error" : "-",1616 fctrl & DOC_CTRL_FLASHREADY ? "ready" : "not ready");1617 1618 return 0;1619}1620DEFINE_SHOW_ATTRIBUTE(flashcontrol);1621 1622static int asic_mode_show(struct seq_file *s, void *p)1623{1624 struct docg3 *docg3 = s->private;1625 1626 int pctrl, mode;1627 1628 mutex_lock(&docg3->cascade->lock);1629 pctrl = doc_register_readb(docg3, DOC_ASICMODE);1630 mode = pctrl & 0x03;1631 mutex_unlock(&docg3->cascade->lock);1632 1633 seq_printf(s,1634 "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (",1635 pctrl,1636 pctrl & DOC_ASICMODE_RAM_WE ? 1 : 0,1637 pctrl & DOC_ASICMODE_RSTIN_RESET ? 1 : 0,1638 pctrl & DOC_ASICMODE_BDETCT_RESET ? 1 : 0,1639 pctrl & DOC_ASICMODE_MDWREN ? 1 : 0,1640 pctrl & DOC_ASICMODE_POWERDOWN ? 1 : 0,1641 mode >> 1, mode & 0x1);1642 1643 switch (mode) {1644 case DOC_ASICMODE_RESET:1645 seq_puts(s, "reset");1646 break;1647 case DOC_ASICMODE_NORMAL:1648 seq_puts(s, "normal");1649 break;1650 case DOC_ASICMODE_POWERDOWN:1651 seq_puts(s, "powerdown");1652 break;1653 }1654 seq_puts(s, ")\n");1655 return 0;1656}1657DEFINE_SHOW_ATTRIBUTE(asic_mode);1658 1659static int device_id_show(struct seq_file *s, void *p)1660{1661 struct docg3 *docg3 = s->private;1662 int id;1663 1664 mutex_lock(&docg3->cascade->lock);1665 id = doc_register_readb(docg3, DOC_DEVICESELECT);1666 mutex_unlock(&docg3->cascade->lock);1667 1668 seq_printf(s, "DeviceId = %d\n", id);1669 return 0;1670}1671DEFINE_SHOW_ATTRIBUTE(device_id);1672 1673static int protection_show(struct seq_file *s, void *p)1674{1675 struct docg3 *docg3 = s->private;1676 int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high;1677 1678 mutex_lock(&docg3->cascade->lock);1679 protect = doc_register_readb(docg3, DOC_PROTECTION);1680 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);1681 dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW);1682 dps0_high = doc_register_readw(docg3, DOC_DPS0_ADDRHIGH);1683 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);1684 dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW);1685 dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH);1686 mutex_unlock(&docg3->cascade->lock);1687 1688 seq_printf(s, "Protection = 0x%02x (", protect);1689 if (protect & DOC_PROTECT_FOUNDRY_OTP_LOCK)1690 seq_puts(s, "FOUNDRY_OTP_LOCK,");1691 if (protect & DOC_PROTECT_CUSTOMER_OTP_LOCK)1692 seq_puts(s, "CUSTOMER_OTP_LOCK,");1693 if (protect & DOC_PROTECT_LOCK_INPUT)1694 seq_puts(s, "LOCK_INPUT,");1695 if (protect & DOC_PROTECT_STICKY_LOCK)1696 seq_puts(s, "STICKY_LOCK,");1697 if (protect & DOC_PROTECT_PROTECTION_ENABLED)1698 seq_puts(s, "PROTECTION ON,");1699 if (protect & DOC_PROTECT_IPL_DOWNLOAD_LOCK)1700 seq_puts(s, "IPL_DOWNLOAD_LOCK,");1701 if (protect & DOC_PROTECT_PROTECTION_ERROR)1702 seq_puts(s, "PROTECT_ERR,");1703 else1704 seq_puts(s, "NO_PROTECT_ERR");1705 seq_puts(s, ")\n");1706 1707 seq_printf(s, "DPS0 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",1708 dps0, dps0_low, dps0_high,1709 !!(dps0 & DOC_DPS_OTP_PROTECTED),1710 !!(dps0 & DOC_DPS_READ_PROTECTED),1711 !!(dps0 & DOC_DPS_WRITE_PROTECTED),1712 !!(dps0 & DOC_DPS_HW_LOCK_ENABLED),1713 !!(dps0 & DOC_DPS_KEY_OK));1714 seq_printf(s, "DPS1 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",1715 dps1, dps1_low, dps1_high,1716 !!(dps1 & DOC_DPS_OTP_PROTECTED),1717 !!(dps1 & DOC_DPS_READ_PROTECTED),1718 !!(dps1 & DOC_DPS_WRITE_PROTECTED),1719 !!(dps1 & DOC_DPS_HW_LOCK_ENABLED),1720 !!(dps1 & DOC_DPS_KEY_OK));1721 return 0;1722}1723DEFINE_SHOW_ATTRIBUTE(protection);1724 1725static void __init doc_dbg_register(struct mtd_info *floor)1726{1727 struct dentry *root = floor->dbg.dfs_dir;1728 struct docg3 *docg3 = floor->priv;1729 1730 if (IS_ERR_OR_NULL(root)) {1731 if (IS_ENABLED(CONFIG_DEBUG_FS) &&1732 !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER))1733 dev_warn(floor->dev.parent,1734 "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n");1735 return;1736 }1737 1738 debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3,1739 &flashcontrol_fops);1740 debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3,1741 &asic_mode_fops);1742 debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3,1743 &device_id_fops);1744 debugfs_create_file("docg3_protection", S_IRUSR, root, docg3,1745 &protection_fops);1746}1747 1748/**1749 * doc_set_driver_info - Fill the mtd_info structure and docg3 structure1750 * @chip_id: The chip ID of the supported chip1751 * @mtd: The structure to fill1752 */1753static int __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)1754{1755 struct docg3 *docg3 = mtd->priv;1756 int cfg;1757 1758 cfg = doc_register_readb(docg3, DOC_CONFIGURATION);1759 docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0);1760 docg3->reliable = reliable_mode;1761 1762 switch (chip_id) {1763 case DOC_CHIPID_G3:1764 mtd->name = devm_kasprintf(docg3->dev, GFP_KERNEL, "docg3.%d",1765 docg3->device_id);1766 if (!mtd->name)1767 return -ENOMEM;1768 docg3->max_block = 2047;1769 break;1770 }1771 mtd->type = MTD_NANDFLASH;1772 mtd->flags = MTD_CAP_NANDFLASH;1773 mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE;1774 if (docg3->reliable == 2)1775 mtd->size /= 2;1776 mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES;1777 if (docg3->reliable == 2)1778 mtd->erasesize /= 2;1779 mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE;1780 mtd->oobsize = DOC_LAYOUT_OOB_SIZE;1781 mtd->_erase = doc_erase;1782 mtd->_read_oob = doc_read_oob;1783 mtd->_write_oob = doc_write_oob;1784 mtd->_block_isbad = doc_block_isbad;1785 mtd_set_ooblayout(mtd, &nand_ooblayout_docg3_ops);1786 mtd->oobavail = 8;1787 mtd->ecc_strength = DOC_ECC_BCH_T;1788 1789 return 0;1790}1791 1792/**1793 * doc_probe_device - Check if a device is available1794 * @cascade: the cascade of chips this devices will belong to1795 * @floor: the floor of the probed device1796 * @dev: the device1797 *1798 * Checks whether a device at the specified IO range, and floor is available.1799 *1800 * Returns a mtd_info struct if there is a device, ENODEV if none found, ENOMEM1801 * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is1802 * launched.1803 */1804static struct mtd_info * __init1805doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev)1806{1807 int ret, bbt_nbpages;1808 u16 chip_id, chip_id_inv;1809 struct docg3 *docg3;1810 struct mtd_info *mtd;1811 1812 ret = -ENOMEM;1813 docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL);1814 if (!docg3)1815 goto nomem1;1816 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);1817 if (!mtd)1818 goto nomem2;1819 mtd->priv = docg3;1820 mtd->dev.parent = dev;1821 bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,1822 8 * DOC_LAYOUT_PAGE_SIZE);1823 docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL);1824 if (!docg3->bbt)1825 goto nomem3;1826 1827 docg3->dev = dev;1828 docg3->device_id = floor;1829 docg3->cascade = cascade;1830 doc_set_device_id(docg3, docg3->device_id);1831 if (!floor)1832 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET);1833 doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL);1834 1835 chip_id = doc_register_readw(docg3, DOC_CHIPID);1836 chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV);1837 1838 ret = 0;1839 if (chip_id != (u16)(~chip_id_inv)) {1840 goto nomem4;1841 }1842 1843 switch (chip_id) {1844 case DOC_CHIPID_G3:1845 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n",1846 docg3->cascade->base, floor);1847 break;1848 default:1849 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id);1850 goto nomem4;1851 }1852 1853 ret = doc_set_driver_info(chip_id, mtd);1854 if (ret)1855 goto nomem4;1856 1857 doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ);1858 doc_reload_bbt(docg3);1859 return mtd;1860 1861nomem4:1862 kfree(docg3->bbt);1863nomem3:1864 kfree(mtd);1865nomem2:1866 kfree(docg3);1867nomem1:1868 return ret ? ERR_PTR(ret) : NULL;1869}1870 1871/**1872 * doc_release_device - Release a docg3 floor1873 * @mtd: the device1874 */1875static void doc_release_device(struct mtd_info *mtd)1876{1877 struct docg3 *docg3 = mtd->priv;1878 1879 mtd_device_unregister(mtd);1880 kfree(docg3->bbt);1881 kfree(docg3);1882 kfree(mtd);1883}1884 1885/**1886 * docg3_resume - Awakens docg3 floor1887 * @pdev: platfrom device1888 *1889 * Returns 0 (always successful)1890 */1891static int docg3_resume(struct platform_device *pdev)1892{1893 int i;1894 struct docg3_cascade *cascade;1895 struct mtd_info **docg3_floors, *mtd;1896 struct docg3 *docg3;1897 1898 cascade = platform_get_drvdata(pdev);1899 docg3_floors = cascade->floors;1900 mtd = docg3_floors[0];1901 docg3 = mtd->priv;1902 1903 doc_dbg("docg3_resume()\n");1904 for (i = 0; i < 12; i++)1905 doc_readb(docg3, DOC_IOSPACE_IPL);1906 return 0;1907}1908 1909/**1910 * docg3_suspend - Put in low power mode the docg3 floor1911 * @pdev: platform device1912 * @state: power state1913 *1914 * Shuts off most of docg3 circuitery to lower power consumption.1915 *1916 * Returns 0 if suspend succeeded, -EIO if chip refused suspend1917 */1918static int docg3_suspend(struct platform_device *pdev, pm_message_t state)1919{1920 int floor, i;1921 struct docg3_cascade *cascade;1922 struct mtd_info **docg3_floors, *mtd;1923 struct docg3 *docg3;1924 u8 ctrl, pwr_down;1925 1926 cascade = platform_get_drvdata(pdev);1927 docg3_floors = cascade->floors;1928 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {1929 mtd = docg3_floors[floor];1930 if (!mtd)1931 continue;1932 docg3 = mtd->priv;1933 1934 doc_writeb(docg3, floor, DOC_DEVICESELECT);1935 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);1936 ctrl &= ~DOC_CTRL_VIOLATION & ~DOC_CTRL_CE;1937 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);1938 1939 for (i = 0; i < 10; i++) {1940 usleep_range(3000, 4000);1941 pwr_down = doc_register_readb(docg3, DOC_POWERMODE);1942 if (pwr_down & DOC_POWERDOWN_READY)1943 break;1944 }1945 if (pwr_down & DOC_POWERDOWN_READY) {1946 doc_dbg("docg3_suspend(): floor %d powerdown ok\n",1947 floor);1948 } else {1949 doc_err("docg3_suspend(): floor %d powerdown failed\n",1950 floor);1951 return -EIO;1952 }1953 }1954 1955 mtd = docg3_floors[0];1956 docg3 = mtd->priv;1957 doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN);1958 return 0;1959}1960 1961/**1962 * docg3_probe - Probe the IO space for a DiskOnChip G3 chip1963 * @pdev: platform device1964 *1965 * Probes for a G3 chip at the specified IO space in the platform data1966 * ressources. The floor 0 must be available.1967 *1968 * Returns 0 on success, -ENOMEM, -ENXIO on error1969 */1970static int __init docg3_probe(struct platform_device *pdev)1971{1972 struct device *dev = &pdev->dev;1973 struct mtd_info *mtd;1974 struct resource *ress;1975 void __iomem *base;1976 int ret, floor;1977 struct docg3_cascade *cascade;1978 1979 ret = -ENXIO;1980 ress = platform_get_resource(pdev, IORESOURCE_MEM, 0);1981 if (!ress) {1982 dev_err(dev, "No I/O memory resource defined\n");1983 return ret;1984 }1985 1986 ret = -ENOMEM;1987 base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE);1988 if (!base) {1989 dev_err(dev, "devm_ioremap dev failed\n");1990 return ret;1991 }1992 1993 cascade = devm_kcalloc(dev, DOC_MAX_NBFLOORS, sizeof(*cascade),1994 GFP_KERNEL);1995 if (!cascade)1996 return ret;1997 cascade->base = base;1998 mutex_init(&cascade->lock);1999 cascade->bch = bch_init(DOC_ECC_BCH_M, DOC_ECC_BCH_T,2000 DOC_ECC_BCH_PRIMPOLY, false);2001 if (!cascade->bch)2002 return ret;2003 2004 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {2005 mtd = doc_probe_device(cascade, floor, dev);2006 if (IS_ERR(mtd)) {2007 ret = PTR_ERR(mtd);2008 goto err_probe;2009 }2010 if (!mtd) {2011 if (floor == 0)2012 goto notfound;2013 else2014 continue;2015 }2016 cascade->floors[floor] = mtd;2017 ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL,2018 0);2019 if (ret)2020 goto err_probe;2021 2022 doc_dbg_register(cascade->floors[floor]);2023 }2024 2025 ret = doc_register_sysfs(pdev, cascade);2026 if (ret)2027 goto err_probe;2028 2029 platform_set_drvdata(pdev, cascade);2030 return 0;2031 2032notfound:2033 ret = -ENODEV;2034 dev_info(dev, "No supported DiskOnChip found\n");2035err_probe:2036 bch_free(cascade->bch);2037 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)2038 if (cascade->floors[floor])2039 doc_release_device(cascade->floors[floor]);2040 return ret;2041}2042 2043/**2044 * docg3_release - Release the driver2045 * @pdev: the platform device2046 *2047 * Returns 02048 */2049static void docg3_release(struct platform_device *pdev)2050{2051 struct docg3_cascade *cascade = platform_get_drvdata(pdev);2052 struct docg3 *docg3 = cascade->floors[0]->priv;2053 int floor;2054 2055 doc_unregister_sysfs(pdev, cascade);2056 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)2057 if (cascade->floors[floor])2058 doc_release_device(cascade->floors[floor]);2059 2060 bch_free(docg3->cascade->bch);2061}2062 2063#ifdef CONFIG_OF2064static const struct of_device_id docg3_dt_ids[] = {2065 { .compatible = "m-systems,diskonchip-g3" },2066 {}2067};2068MODULE_DEVICE_TABLE(of, docg3_dt_ids);2069#endif2070 2071static struct platform_driver g3_driver = {2072 .driver = {2073 .name = "docg3",2074 .of_match_table = of_match_ptr(docg3_dt_ids),2075 },2076 .suspend = docg3_suspend,2077 .resume = docg3_resume,2078 .remove_new = docg3_release,2079};2080 2081module_platform_driver_probe(g3_driver, docg3_probe);2082 2083MODULE_LICENSE("GPL");2084MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");2085MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");2086