1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Handles the M-Systems DiskOnChip G3 chip 4 * 5 * Copyright (C) 2011 Robert Jarzmik 6 */ 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_POINTS 27#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 lacks 33 * several functions available on the chip, as : 34 * - IPL write 35 * 36 * The bus data width (8bits versus 16bits) is not handled (if_cfg flag), and 37 * 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 page 41 * - a 7 bytes BCH code stored in the OOB for each page 42 * The BCH ECC is : 43 * - BCH is in GF(2^14) 44 * - BCH is over data of 520 bytes (512 page + 7 page_info bytes 45 * + 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 well 48 * 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 operations 159 * @docg3: the device 160 * @nbNOPs: the number of NOPs to issue 161 * 162 * As no specification is available, the right timings between chip commands are 163 * unknown. The only available piece of information are the observed nops on a 164 * working docg3 chip. 165 * Therefore, doc_delay relies on a busy loop of NOPs, instead of scheduler 166 * 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 else 205 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 area 224 * @docg3: the device 225 * @buf: the buffer to fill in (might be NULL is dummy reads) 226 * @len: the length to read 227 * @first: first time read, DOC_READADDRESS should be set 228 * 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 area 270 * @docg3: the device 271 * @buf: the buffer to get input bytes from 272 * @len: the length to write 273 * 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_data_mode - Sets the flash to normal or reliable data mode 304 * @docg3: the device 305 * 306 * The reliable data mode is a bit slower than the fast mode, but less errors 307 * occur. Entering the reliable mode cannot be done without entering the fast 308 * mode first. 309 * 310 * In reliable mode, pages 2*n and 2*n+1 are clones. Writing to page 0 of blocks 311 * (4,5) make the hardware write also to page 1 of blocks blocks(4,5). Reading 312 * from page 0 of blocks (4,5) or from page 1 of blocks (4,5) gives the same 313 * result, which is a logical and between bytes from page 0 and page 1 (which is 314 * consistent with the fact that writing to a page is _clearing_ bits of that 315 * 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 mode 343 * @docg3: the device 344 * @mode: the mode 345 * 346 * The ASIC can work in 3 modes : 347 * - RESET: all registers are zeroed 348 * - NORMAL: receives and handles commands 349 * - POWERDOWN: minimal poweruse, flash parts shut off 350 */ 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 chips 367 * @docg3: the device 368 * @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 will 371 * 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 layout 388 * @docg3: the device 389 * 390 * Normally, the flash page is split into the data (512 bytes) and the out of 391 * band data (16 bytes). For each, 4 more bytes can be accessed, where the wear 392 * leveling counters are stored. To access this last area of 4 bytes, a special 393 * 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 else 410 return 0; 411} 412 413/** 414 * doc_setup_addr_sector - Setup blocks/page/ofs address for one plane 415 * @docg3: the device 416 * @sector: the sector 417 */ 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 plane 429 * @docg3: the device 430 * @sector: the sector 431 * @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_seek - Set both flash planes to the specified block, page for reading 446 * @docg3: the device 447 * @block0: the first plane block index 448 * @block1: the second plane block index 449 * @page: the page index within the block 450 * @wear: if true, read will occur on the 4 extra bytes of the wear area 451 * @ofs: offset in page to read 452 * 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 writing 496 * @docg3: the device 497 * @block0: the first plane block index 498 * @block1: the second plane block index 499 * @page: the page index within the block 500 * @ofs: offset in page to write 501 * 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 engine 549 * @docg3: the device 550 * @len: the number of bytes covered by the ECC (BCH covered) 551 * 552 * The function does initialize the hardware ECC engine to compute the Hamming 553 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes). 554 * 555 * Return 0 if succeeded, -EIO on error 556 */ 557static int doc_read_page_ecc_init(struct docg3 *docg3, int len) 558{ 559 doc_writew(docg3, DOC_ECCCONF0_READ_MODE 560 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE 561 | (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 engine 570 * @docg3: the device 571 * @len: the number of bytes covered by the ECC (BCH covered) 572 * 573 * The function does initialize the hardware ECC engine to compute the Hamming 574 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes). 575 * 576 * Return 0 if succeeded, -EIO on error 577 */ 578static int doc_write_page_ecc_init(struct docg3 *docg3, int len) 579{ 580 doc_writew(docg3, DOC_ECCCONF0_WRITE_MODE 581 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE 582 | (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 calculator 591 * @docg3: the device 592 * 593 * Disables the hardware ECC generator and checker, for unchecked reads (as when 594 * 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 engine 604 * @docg3: the device 605 * @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 the 608 * 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 flash 622 * @docg3: the device 623 * @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 OOB 626 * 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 docg3 630 * understands the (data, ecc, syndroms) in an inverted order in comparison to 631 * 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 bch 635 * algorithm is used to decode this. However the hw operates on page 636 * 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 Ivan 638 * Djelic for his analysis. 639 * 640 * Returns number of fixed bits (0, 1, 2, 3, 4) or -EBADMSG if too many bit 641 * 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 page 671 * @docg3: the device 672 * @block0: the first plane block index on flash memory 673 * @block1: the second plane block index on flash memory 674 * @page: the page index in the block 675 * @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 pages 679 * - tell ASIC to be in read mode 680 * 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 and 685 * (page_size + oob_size + wear_size), ie. 532, and a multiple of 4 (because 686 * the extra bytes reading is not implemented). 687 * 688 * As pages are grouped by 2 (in 2 planes), reading from a page must be done 689 * in two steps: 690 * - one read of 512 bytes at offset 0 691 * - one read of 512 bytes at offset 512 + 16 692 * 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 page 740 * @docg3: the device 741 * @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 set 744 * @last_odd: 1 if last read ended up on an odd byte 745 * 746 * Reads bytes from a prepared page. There is a trickery here : if the last read 747 * ended up on an odd offset in the 1024 bytes double page, ie. between the 2 748 * 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, which 750 * 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 page 768 * @docg3: the device 769 * @len: the number of bytes to be written 770 * @buf: the buffer of input bytes 771 * 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 ECC 782 * @docg3: the device 783 * @hwecc: the array of 7 integers where the hardware ecc will be stored 784 */ 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 page 795 * @docg3: the device 796 */ 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 page 805 * @docg3: the device 806 * 807 * As a side effect, resets the chip selector to 0. This ensures that after each 808 * read operation, the floor 0 is selected. Therefore, if the systems halts, the 809 * 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 flash 821 * @block0: first plane block index calculated 822 * @block1: second plane block index calculated 823 * @page: page calculated 824 * @ofs: offset in page 825 * @reliable: 0 if docg3 in normal mode, 1 if docg3 in fast mode, 2 if docg3 in 826 * reliable mode. 827 * 828 * The calculation is based on the reliable/normal mode. In normal mode, the 64 829 * pages of a block are available. In reliable mode, as pages 2*n and 2*n+1 are 830 * 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 else 851 *ofs = 0; 852} 853 854/** 855 * doc_read_oob - Read out of band bytes from flash 856 * @mtd: the device 857 * @from: the offset from first block and first page, in bytes, aligned on page 858 * size 859 * @ops: the mtd oob structure 860 * 861 * Reads flash memory OOB area of pages. 862 * 863 * Returns 0 if read successful, of -EIO, -EINVAL if an error occurred 864 */ 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 int max_bitflips = 0; 875 876 if (buf) 877 len = ops->len; 878 else 879 len = 0; 880 if (oobbuf) 881 ooblen = ops->ooblen; 882 else 883 ooblen = 0; 884 885 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB) 886 oobbuf += ops->ooboffs; 887 888 doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n", 889 from, ops->mode, buf, len, oobbuf, ooblen); 890 if (ooblen % DOC_LAYOUT_OOB_SIZE) 891 return -EINVAL; 892 893 ops->oobretlen = 0; 894 ops->retlen = 0; 895 ret = 0; 896 skip = from % DOC_LAYOUT_PAGE_SIZE; 897 mutex_lock(&docg3->cascade->lock); 898 while (ret >= 0 && (len > 0 || ooblen > 0)) { 899 calc_block_sector(from - skip, &block0, &block1, &page, &ofs, 900 docg3->reliable); 901 nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip); 902 nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE); 903 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs); 904 if (ret < 0) 905 goto out; 906 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES); 907 if (ret < 0) 908 goto err_in_read; 909 ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0); 910 if (ret < skip) 911 goto err_in_read; 912 ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2); 913 if (ret < nbdata) 914 goto err_in_read; 915 doc_read_page_getbytes(docg3, 916 DOC_LAYOUT_PAGE_SIZE - nbdata - skip, 917 NULL, 0, (skip + nbdata) % 2); 918 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0); 919 if (ret < nboob) 920 goto err_in_read; 921 doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob, 922 NULL, 0, nboob % 2); 923 924 doc_get_bch_hw_ecc(docg3, hwecc); 925 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1); 926 927 if (nboob >= DOC_LAYOUT_OOB_SIZE) { 928 doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf); 929 doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]); 930 doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8); 931 doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]); 932 } 933 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1); 934 doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc); 935 936 ret = -EIO; 937 if (is_prot_seq_error(docg3)) 938 goto err_in_read; 939 ret = 0; 940 if ((block0 >= DOC_LAYOUT_BLOCK_FIRST_DATA) && 941 (eccconf1 & DOC_ECCCONF1_BCH_SYNDROM_ERR) && 942 (eccconf1 & DOC_ECCCONF1_PAGE_IS_WRITTEN) && 943 (ops->mode != MTD_OPS_RAW) && 944 (nbdata == DOC_LAYOUT_PAGE_SIZE)) { 945 ret = doc_ecc_bch_fix_data(docg3, buf, hwecc); 946 if (ret < 0) { 947 mtd->ecc_stats.failed++; 948 ret = -EBADMSG; 949 } 950 if (ret > 0) { 951 mtd->ecc_stats.corrected += ret; 952 max_bitflips = max(max_bitflips, ret); 953 ret = max_bitflips; 954 } 955 } 956 957 doc_read_page_finish(docg3); 958 ops->retlen += nbdata; 959 ops->oobretlen += nboob; 960 buf += nbdata; 961 oobbuf += nboob; 962 len -= nbdata; 963 ooblen -= nboob; 964 from += DOC_LAYOUT_PAGE_SIZE; 965 skip = 0; 966 } 967 968out: 969 mutex_unlock(&docg3->cascade->lock); 970 return ret; 971err_in_read: 972 doc_read_page_finish(docg3); 973 goto out; 974} 975 976static int doc_reload_bbt(struct docg3 *docg3) 977{ 978 int block = DOC_LAYOUT_BLOCK_BBT; 979 int ret = 0, nbpages, page; 980 u_char *buf = docg3->bbt; 981 982 nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE); 983 for (page = 0; !ret && (page < nbpages); page++) { 984 ret = doc_read_page_prepare(docg3, block, block + 1, 985 page + DOC_LAYOUT_PAGE_BBT, 0); 986 if (!ret) 987 ret = doc_read_page_ecc_init(docg3, 988 DOC_LAYOUT_PAGE_SIZE); 989 if (!ret) 990 doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE, 991 buf, 1, 0); 992 buf += DOC_LAYOUT_PAGE_SIZE; 993 } 994 doc_read_page_finish(docg3); 995 return ret; 996} 997 998/** 999 * doc_block_isbad - Checks whether a block is good or not 1000 * @mtd: the device 1001 * @from: the offset to find the correct block 1002 * 1003 * Returns 1 if block is bad, 0 if block is good 1004 */ 1005static int doc_block_isbad(struct mtd_info *mtd, loff_t from) 1006{ 1007 struct docg3 *docg3 = mtd->priv; 1008 int block0, block1, page, ofs, is_good; 1009 1010 calc_block_sector(from, &block0, &block1, &page, &ofs, 1011 docg3->reliable); 1012 doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n", 1013 from, block0, block1, page, ofs); 1014 1015 if (block0 < DOC_LAYOUT_BLOCK_FIRST_DATA) 1016 return 0; 1017 if (block1 > docg3->max_block) 1018 return -EINVAL; 1019 1020 is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7)); 1021 return !is_good; 1022} 1023 1024#if 0 1025/** 1026 * doc_get_erase_count - Get block erase count 1027 * @docg3: the device 1028 * @from: the offset in which the block is. 1029 * 1030 * Get the number of times a block was erased. The number is the maximum of 1031 * erase times between first and second plane (which should be equal normally). 1032 * 1033 * Returns The number of erases, or -EINVAL or -EIO on error. 1034 */ 1035static int doc_get_erase_count(struct docg3 *docg3, loff_t from) 1036{ 1037 u8 buf[DOC_LAYOUT_WEAR_SIZE]; 1038 int ret, plane1_erase_count, plane2_erase_count; 1039 int block0, block1, page, ofs; 1040 1041 doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from, buf); 1042 if (from % DOC_LAYOUT_PAGE_SIZE) 1043 return -EINVAL; 1044 calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable); 1045 if (block1 > docg3->max_block) 1046 return -EINVAL; 1047 1048 ret = doc_reset_seq(docg3); 1049 if (!ret) 1050 ret = doc_read_page_prepare(docg3, block0, block1, page, 1051 ofs + DOC_LAYOUT_WEAR_OFFSET, 0); 1052 if (!ret) 1053 ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE, 1054 buf, 1, 0); 1055 doc_read_page_finish(docg3); 1056 1057 if (ret || (buf[0] != DOC_ERASE_MARK) || (buf[2] != DOC_ERASE_MARK)) 1058 return -EIO; 1059 plane1_erase_count = (u8)(~buf[1]) | ((u8)(~buf[4]) << 8) 1060 | ((u8)(~buf[5]) << 16); 1061 plane2_erase_count = (u8)(~buf[3]) | ((u8)(~buf[6]) << 8) 1062 | ((u8)(~buf[7]) << 16); 1063 1064 return max(plane1_erase_count, plane2_erase_count); 1065} 1066#endif 1067 1068/** 1069 * doc_get_op_status - get erase/write operation status 1070 * @docg3: the device 1071 * 1072 * Queries the status from the chip, and returns it 1073 * 1074 * Returns the status (bits DOC_PLANES_STATUS_*) 1075 */ 1076static int doc_get_op_status(struct docg3 *docg3) 1077{ 1078 u8 status; 1079 1080 doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS); 1081 doc_flash_command(docg3, DOC_CMD_PLANES_STATUS); 1082 doc_delay(docg3, 5); 1083 1084 doc_ecc_disable(docg3); 1085 doc_read_data_area(docg3, &status, 1, 1); 1086 return status; 1087} 1088 1089/** 1090 * doc_write_erase_wait_status - wait for write or erase completion 1091 * @docg3: the device 1092 * 1093 * Wait for the chip to be ready again after erase or write operation, and check 1094 * erase/write status. 1095 * 1096 * Returns 0 if erase successful, -EIO if erase/write issue, -ETIMEOUT if 1097 * timeout 1098 */ 1099static int doc_write_erase_wait_status(struct docg3 *docg3) 1100{ 1101 int i, status, ret = 0; 1102 1103 for (i = 0; !doc_is_ready(docg3) && i < 5; i++) 1104 msleep(20); 1105 if (!doc_is_ready(docg3)) { 1106 doc_dbg("Timeout reached and the chip is still not ready\n"); 1107 ret = -EAGAIN; 1108 goto out; 1109 } 1110 1111 status = doc_get_op_status(docg3); 1112 if (status & DOC_PLANES_STATUS_FAIL) { 1113 doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n", 1114 status); 1115 ret = -EIO; 1116 } 1117 1118out: 1119 doc_page_finish(docg3); 1120 return ret; 1121} 1122 1123/** 1124 * doc_erase_block - Erase a couple of blocks 1125 * @docg3: the device 1126 * @block0: the first block to erase (leftmost plane) 1127 * @block1: the second block to erase (rightmost plane) 1128 * 1129 * Erase both blocks, and return operation status 1130 * 1131 * Returns 0 if erase successful, -EIO if erase issue, -ETIMEOUT if chip not 1132 * ready for too long 1133 */ 1134static int doc_erase_block(struct docg3 *docg3, int block0, int block1) 1135{ 1136 int ret, sector; 1137 1138 doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0, block1); 1139 ret = doc_reset_seq(docg3); 1140 if (ret) 1141 return -EIO; 1142 1143 doc_set_reliable_mode(docg3); 1144 doc_flash_sequence(docg3, DOC_SEQ_ERASE); 1145 1146 sector = block0 << DOC_ADDR_BLOCK_SHIFT; 1147 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR); 1148 doc_setup_addr_sector(docg3, sector); 1149 sector = block1 << DOC_ADDR_BLOCK_SHIFT; 1150 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR); 1151 doc_setup_addr_sector(docg3, sector); 1152 doc_delay(docg3, 1); 1153 1154 doc_flash_command(docg3, DOC_CMD_ERASECYCLE2); 1155 doc_delay(docg3, 2); 1156 1157 if (is_prot_seq_error(docg3)) { 1158 doc_err("Erase blocks %d,%d error\n", block0, block1); 1159 return -EIO; 1160 } 1161 1162 return doc_write_erase_wait_status(docg3); 1163} 1164 1165/** 1166 * doc_erase - Erase a portion of the chip 1167 * @mtd: the device 1168 * @info: the erase info 1169 * 1170 * Erase a bunch of contiguous blocks, by pairs, as a "mtd" page of 1024 is 1171 * split into 2 pages of 512 bytes on 2 contiguous blocks. 1172 * 1173 * Returns 0 if erase successful, -EINVAL if addressing error, -EIO if erase 1174 * issue 1175 */ 1176static int doc_erase(struct mtd_info *mtd, struct erase_info *info) 1177{ 1178 struct docg3 *docg3 = mtd->priv; 1179 uint64_t len; 1180 int block0, block1, page, ret = 0, ofs = 0; 1181 1182 doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len); 1183 1184 calc_block_sector(info->addr + info->len, &block0, &block1, &page, 1185 &ofs, docg3->reliable); 1186 if (info->addr + info->len > mtd->size || page || ofs) 1187 return -EINVAL; 1188 1189 calc_block_sector(info->addr, &block0, &block1, &page, &ofs, 1190 docg3->reliable); 1191 mutex_lock(&docg3->cascade->lock); 1192 doc_set_device_id(docg3, docg3->device_id); 1193 doc_set_reliable_mode(docg3); 1194 for (len = info->len; !ret && len > 0; len -= mtd->erasesize) { 1195 ret = doc_erase_block(docg3, block0, block1); 1196 block0 += 2; 1197 block1 += 2; 1198 } 1199 mutex_unlock(&docg3->cascade->lock); 1200 1201 return ret; 1202} 1203 1204/** 1205 * doc_write_page - Write a single page to the chip 1206 * @docg3: the device 1207 * @to: the offset from first block and first page, in bytes, aligned on page 1208 * size 1209 * @buf: buffer to get bytes from 1210 * @oob: buffer to get out of band bytes from (can be NULL if no OOB should be 1211 * written) 1212 * @autoecc: if 0, all 16 bytes from OOB are taken, regardless of HW Hamming or 1213 * BCH computations. If 1, only bytes 0-7 and byte 15 are taken, 1214 * remaining ones are filled with hardware Hamming and BCH 1215 * computations. Its value is not meaningfull is oob == NULL. 1216 * 1217 * Write one full page (ie. 1 page split on two planes), of 512 bytes, with the 1218 * OOB data. The OOB ECC is automatically computed by the hardware Hamming and 1219 * BCH generator if autoecc is not null. 1220 * 1221 * Returns 0 if write successful, -EIO if write error, -EAGAIN if timeout 1222 */ 1223static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf, 1224 const u_char *oob, int autoecc) 1225{ 1226 int block0, block1, page, ret, ofs = 0; 1227 u8 hwecc[DOC_ECC_BCH_SIZE], hamming; 1228 1229 doc_dbg("doc_write_page(to=%lld)\n", to); 1230 calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable); 1231 1232 doc_set_device_id(docg3, docg3->device_id); 1233 ret = doc_reset_seq(docg3); 1234 if (ret) 1235 goto err; 1236 1237 /* Program the flash address block and page */ 1238 ret = doc_write_seek(docg3, block0, block1, page, ofs); 1239 if (ret) 1240 goto err; 1241 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); 1245 1246 if (oob && autoecc) { 1247 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob); 1248 doc_delay(docg3, 2); 1249 oob += DOC_LAYOUT_OOB_UNUSED_OFS; 1250 1251 hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY); 1252 doc_delay(docg3, 2); 1253 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ, 1254 &hamming); 1255 doc_delay(docg3, 2); 1256 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); 1260 1261 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob); 1262 } 1263 if (oob && !autoecc) 1264 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob); 1265 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); 1271 1272 /* 1273 * The wait status will perform another doc_page_finish() call, but that 1274 * seems to please the docg3, so leave it. 1275 */ 1276 ret = doc_write_erase_wait_status(docg3); 1277 return ret; 1278err: 1279 doc_read_page_finish(docg3); 1280 return ret; 1281} 1282 1283/** 1284 * doc_guess_autoecc - Guess autoecc mode from mbd_oob_ops 1285 * @ops: the oob operations 1286 * 1287 * Returns 0 or 1 if success, -EINVAL if invalid oob mode 1288 */ 1289static int doc_guess_autoecc(struct mtd_oob_ops *ops) 1290{ 1291 int autoecc; 1292 1293 switch (ops->mode) { 1294 case MTD_OPS_PLACE_OOB: 1295 case MTD_OPS_AUTO_OOB: 1296 autoecc = 1; 1297 break; 1298 case MTD_OPS_RAW: 1299 autoecc = 0; 1300 break; 1301 default: 1302 autoecc = -EINVAL; 1303 } 1304 return autoecc; 1305} 1306 1307/** 1308 * doc_fill_autooob - Fill a 16 bytes OOB from 8 non-ECC bytes 1309 * @dst: the target 16 bytes OOB buffer 1310 * @oobsrc: the source 8 bytes non-ECC OOB buffer 1311 * 1312 */ 1313static void doc_fill_autooob(u8 *dst, u8 *oobsrc) 1314{ 1315 memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ); 1316 dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ]; 1317} 1318 1319/** 1320 * doc_backup_oob - Backup OOB into docg3 structure 1321 * @docg3: the device 1322 * @to: the page offset in the chip 1323 * @ops: the OOB size and buffer 1324 * 1325 * As the docg3 should write a page with its OOB in one pass, and some userland 1326 * applications do write_oob() to setup the OOB and then write(), store the OOB 1327 * into a temporary storage. This is very dangerous, as 2 concurrent 1328 * applications could store an OOB, and then write their pages (which will 1329 * result into one having its OOB corrupted). 1330 * 1331 * The only reliable way would be for userland to call doc_write_oob() with both 1332 * the page data _and_ the OOB area. 1333 * 1334 * Returns 0 if success, -EINVAL if ops content invalid 1335 */ 1336static int doc_backup_oob(struct docg3 *docg3, loff_t to, 1337 struct mtd_oob_ops *ops) 1338{ 1339 int ooblen = ops->ooblen, autoecc; 1340 1341 if (ooblen != DOC_LAYOUT_OOB_SIZE) 1342 return -EINVAL; 1343 autoecc = doc_guess_autoecc(ops); 1344 if (autoecc < 0) 1345 return autoecc; 1346 1347 docg3->oob_write_ofs = to; 1348 docg3->oob_autoecc = autoecc; 1349 if (ops->mode == MTD_OPS_AUTO_OOB) { 1350 doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf); 1351 ops->oobretlen = 8; 1352 } else { 1353 memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE); 1354 ops->oobretlen = DOC_LAYOUT_OOB_SIZE; 1355 } 1356 return 0; 1357} 1358 1359/** 1360 * doc_write_oob - Write out of band bytes to flash 1361 * @mtd: the device 1362 * @ofs: the offset from first block and first page, in bytes, aligned on page 1363 * size 1364 * @ops: the mtd oob structure 1365 * 1366 * Either write OOB data into a temporary buffer, for the subsequent write 1367 * page. The provided OOB should be 16 bytes long. If a data buffer is provided 1368 * as well, issue the page write. 1369 * Or provide data without OOB, and then a all zeroed OOB will be used (ECC will 1370 * still be filled in if asked for). 1371 * 1372 * Returns 0 is successful, EINVAL if length is not 14 bytes 1373 */ 1374static int doc_write_oob(struct mtd_info *mtd, loff_t ofs, 1375 struct mtd_oob_ops *ops) 1376{ 1377 struct docg3 *docg3 = mtd->priv; 1378 int ret, autoecc, oobdelta; 1379 u8 *oobbuf = ops->oobbuf; 1380 u8 *buf = ops->datbuf; 1381 size_t len, ooblen; 1382 u8 oob[DOC_LAYOUT_OOB_SIZE]; 1383 1384 if (buf) 1385 len = ops->len; 1386 else 1387 len = 0; 1388 if (oobbuf) 1389 ooblen = ops->ooblen; 1390 else 1391 ooblen = 0; 1392 1393 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB) 1394 oobbuf += ops->ooboffs; 1395 1396 doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n", 1397 ofs, ops->mode, buf, len, oobbuf, ooblen); 1398 switch (ops->mode) { 1399 case MTD_OPS_PLACE_OOB: 1400 case MTD_OPS_RAW: 1401 oobdelta = mtd->oobsize; 1402 break; 1403 case MTD_OPS_AUTO_OOB: 1404 oobdelta = mtd->oobavail; 1405 break; 1406 default: 1407 return -EINVAL; 1408 } 1409 if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % oobdelta) || 1410 (ofs % DOC_LAYOUT_PAGE_SIZE)) 1411 return -EINVAL; 1412 if (len && ooblen && 1413 (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta)) 1414 return -EINVAL; 1415 1416 ops->oobretlen = 0; 1417 ops->retlen = 0; 1418 ret = 0; 1419 if (len == 0 && ooblen == 0) 1420 return -EINVAL; 1421 if (len == 0 && ooblen > 0) 1422 return doc_backup_oob(docg3, ofs, ops); 1423 1424 autoecc = doc_guess_autoecc(ops); 1425 if (autoecc < 0) 1426 return autoecc; 1427 1428 mutex_lock(&docg3->cascade->lock); 1429 while (!ret && len > 0) { 1430 memset(oob, 0, sizeof(oob)); 1431 if (ofs == docg3->oob_write_ofs) 1432 memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE); 1433 else if (ooblen > 0 && ops->mode == MTD_OPS_AUTO_OOB) 1434 doc_fill_autooob(oob, oobbuf); 1435 else if (ooblen > 0) 1436 memcpy(oob, oobbuf, DOC_LAYOUT_OOB_SIZE); 1437 ret = doc_write_page(docg3, ofs, buf, oob, autoecc); 1438 1439 ofs += DOC_LAYOUT_PAGE_SIZE; 1440 len -= DOC_LAYOUT_PAGE_SIZE; 1441 buf += DOC_LAYOUT_PAGE_SIZE; 1442 if (ooblen) { 1443 oobbuf += oobdelta; 1444 ooblen -= oobdelta; 1445 ops->oobretlen += oobdelta; 1446 } 1447 ops->retlen += DOC_LAYOUT_PAGE_SIZE; 1448 } 1449 1450 doc_set_device_id(docg3, 0); 1451 mutex_unlock(&docg3->cascade->lock); 1452 return ret; 1453} 1454 1455static struct docg3 *sysfs_dev2docg3(struct device *dev, 1456 struct device_attribute *attr) 1457{ 1458 int floor; 1459 struct mtd_info **docg3_floors = dev_get_drvdata(dev); 1460 1461 floor = attr->attr.name[1] - '0'; 1462 if (floor < 0 || floor >= DOC_MAX_NBFLOORS) 1463 return NULL; 1464 else 1465 return docg3_floors[floor]->priv; 1466} 1467 1468static ssize_t dps0_is_key_locked(struct device *dev, 1469 struct device_attribute *attr, char *buf) 1470{ 1471 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1472 int dps0; 1473 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); 1479 1480 return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK)); 1481} 1482 1483static ssize_t dps1_is_key_locked(struct device *dev, 1484 struct device_attribute *attr, char *buf) 1485{ 1486 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1487 int dps1; 1488 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); 1494 1495 return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK)); 1496} 1497 1498static ssize_t dps0_insert_key(struct device *dev, 1499 struct device_attribute *attr, 1500 const char *buf, size_t count) 1501{ 1502 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1503 int i; 1504 1505 if (count != DOC_LAYOUT_DPS_KEY_LENGTH) 1506 return -EINVAL; 1507 1508 mutex_lock(&docg3->cascade->lock); 1509 doc_set_device_id(docg3, docg3->device_id); 1510 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++) 1511 doc_writeb(docg3, buf[i], DOC_DPS0_KEY); 1512 doc_set_device_id(docg3, 0); 1513 mutex_unlock(&docg3->cascade->lock); 1514 return count; 1515} 1516 1517static ssize_t dps1_insert_key(struct device *dev, 1518 struct device_attribute *attr, 1519 const char *buf, size_t count) 1520{ 1521 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1522 int i; 1523 1524 if (count != DOC_LAYOUT_DPS_KEY_LENGTH) 1525 return -EINVAL; 1526 1527 mutex_lock(&docg3->cascade->lock); 1528 doc_set_device_id(docg3, docg3->device_id); 1529 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++) 1530 doc_writeb(docg3, buf[i], DOC_DPS1_KEY); 1531 doc_set_device_id(docg3, 0); 1532 mutex_unlock(&docg3->cascade->lock); 1533 return count; 1534} 1535 1536#define FLOOR_SYSFS(id) { \ 1537 __ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \ 1538 __ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \ 1539 __ATTR(f##id##_dps0_protection_key, S_IWUSR|S_IWGRP, NULL, dps0_insert_key), \ 1540 __ATTR(f##id##_dps1_protection_key, S_IWUSR|S_IWGRP, NULL, dps1_insert_key), \ 1541} 1542 1543static struct device_attribute doc_sys_attrs[DOC_MAX_NBFLOORS][4] = { 1544 FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3) 1545}; 1546 1547static int doc_register_sysfs(struct platform_device *pdev, 1548 struct docg3_cascade *cascade) 1549{ 1550 struct device *dev = &pdev->dev; 1551 int floor; 1552 int ret; 1553 int i; 1554 1555 for (floor = 0; 1556 floor < DOC_MAX_NBFLOORS && cascade->floors[floor]; 1557 floor++) { 1558 for (i = 0; i < 4; i++) { 1559 ret = device_create_file(dev, &doc_sys_attrs[floor][i]); 1560 if (ret) 1561 goto remove_files; 1562 } 1563 } 1564 1565 return 0; 1566 1567remove_files: 1568 do { 1569 while (--i >= 0) 1570 device_remove_file(dev, &doc_sys_attrs[floor][i]); 1571 i = 4; 1572 } while (--floor >= 0); 1573 1574 return ret; 1575} 1576 1577static void doc_unregister_sysfs(struct platform_device *pdev, 1578 struct docg3_cascade *cascade) 1579{ 1580 struct device *dev = &pdev->dev; 1581 int floor, i; 1582 1583 for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor]; 1584 floor++) 1585 for (i = 0; i < 4; i++) 1586 device_remove_file(dev, &doc_sys_attrs[floor][i]); 1587} 1588 1589/* 1590 * Debug sysfs entries 1591 */ 1592static int flashcontrol_show(struct seq_file *s, void *p) 1593{ 1594 struct docg3 *docg3 = (struct docg3 *)s->private; 1595 1596 u8 fctrl; 1597 1598 mutex_lock(&docg3->cascade->lock); 1599 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL); 1600 mutex_unlock(&docg3->cascade->lock); 1601 1602 seq_printf(s, "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n", 1603 fctrl, 1604 fctrl & DOC_CTRL_VIOLATION ? "protocol violation" : "-", 1605 fctrl & DOC_CTRL_CE ? "active" : "inactive", 1606 fctrl & DOC_CTRL_PROTECTION_ERROR ? "protection error" : "-", 1607 fctrl & DOC_CTRL_SEQUENCE_ERROR ? "sequence error" : "-", 1608 fctrl & DOC_CTRL_FLASHREADY ? "ready" : "not ready"); 1609 1610 return 0; 1611} 1612DEFINE_SHOW_ATTRIBUTE(flashcontrol); 1613 1614static int asic_mode_show(struct seq_file *s, void *p) 1615{ 1616 struct docg3 *docg3 = (struct docg3 *)s->private; 1617 1618 int pctrl, mode; 1619 1620 mutex_lock(&docg3->cascade->lock); 1621 pctrl = doc_register_readb(docg3, DOC_ASICMODE); 1622 mode = pctrl & 0x03; 1623 mutex_unlock(&docg3->cascade->lock); 1624 1625 seq_printf(s, 1626 "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (", 1627 pctrl, 1628 pctrl & DOC_ASICMODE_RAM_WE ? 1 : 0, 1629 pctrl & DOC_ASICMODE_RSTIN_RESET ? 1 : 0, 1630 pctrl & DOC_ASICMODE_BDETCT_RESET ? 1 : 0, 1631 pctrl & DOC_ASICMODE_MDWREN ? 1 : 0, 1632 pctrl & DOC_ASICMODE_POWERDOWN ? 1 : 0, 1633 mode >> 1, mode & 0x1); 1634 1635 switch (mode) { 1636 case DOC_ASICMODE_RESET: 1637 seq_puts(s, "reset"); 1638 break; 1639 case DOC_ASICMODE_NORMAL: 1640 seq_puts(s, "normal"); 1641 break; 1642 case DOC_ASICMODE_POWERDOWN: 1643 seq_puts(s, "powerdown"); 1644 break; 1645 } 1646 seq_puts(s, ")\n"); 1647 return 0; 1648} 1649DEFINE_SHOW_ATTRIBUTE(asic_mode); 1650 1651static int device_id_show(struct seq_file *s, void *p) 1652{ 1653 struct docg3 *docg3 = (struct docg3 *)s->private; 1654 int id; 1655 1656 mutex_lock(&docg3->cascade->lock); 1657 id = doc_register_readb(docg3, DOC_DEVICESELECT); 1658 mutex_unlock(&docg3->cascade->lock); 1659 1660 seq_printf(s, "DeviceId = %d\n", id); 1661 return 0; 1662} 1663DEFINE_SHOW_ATTRIBUTE(device_id); 1664 1665static int protection_show(struct seq_file *s, void *p) 1666{ 1667 struct docg3 *docg3 = (struct docg3 *)s->private; 1668 int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high; 1669 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); 1679 1680 seq_printf(s, "Protection = 0x%02x (", protect); 1681 if (protect & DOC_PROTECT_FOUNDRY_OTP_LOCK) 1682 seq_puts(s, "FOUNDRY_OTP_LOCK,"); 1683 if (protect & DOC_PROTECT_CUSTOMER_OTP_LOCK) 1684 seq_puts(s, "CUSTOMER_OTP_LOCK,"); 1685 if (protect & DOC_PROTECT_LOCK_INPUT) 1686 seq_puts(s, "LOCK_INPUT,"); 1687 if (protect & DOC_PROTECT_STICKY_LOCK) 1688 seq_puts(s, "STICKY_LOCK,"); 1689 if (protect & DOC_PROTECT_PROTECTION_ENABLED) 1690 seq_puts(s, "PROTECTION ON,"); 1691 if (protect & DOC_PROTECT_IPL_DOWNLOAD_LOCK) 1692 seq_puts(s, "IPL_DOWNLOAD_LOCK,"); 1693 if (protect & DOC_PROTECT_PROTECTION_ERROR) 1694 seq_puts(s, "PROTECT_ERR,"); 1695 else 1696 seq_puts(s, "NO_PROTECT_ERR"); 1697 seq_puts(s, ")\n"); 1698 1699 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", 1700 dps0, dps0_low, dps0_high, 1701 !!(dps0 & DOC_DPS_OTP_PROTECTED), 1702 !!(dps0 & DOC_DPS_READ_PROTECTED), 1703 !!(dps0 & DOC_DPS_WRITE_PROTECTED), 1704 !!(dps0 & DOC_DPS_HW_LOCK_ENABLED), 1705 !!(dps0 & DOC_DPS_KEY_OK)); 1706 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", 1707 dps1, dps1_low, dps1_high, 1708 !!(dps1 & DOC_DPS_OTP_PROTECTED), 1709 !!(dps1 & DOC_DPS_READ_PROTECTED), 1710 !!(dps1 & DOC_DPS_WRITE_PROTECTED), 1711 !!(dps1 & DOC_DPS_HW_LOCK_ENABLED), 1712 !!(dps1 & DOC_DPS_KEY_OK)); 1713 return 0; 1714} 1715DEFINE_SHOW_ATTRIBUTE(protection); 1716 1717static void __init doc_dbg_register(struct mtd_info *floor) 1718{ 1719 struct dentry *root = floor->dbg.dfs_dir; 1720 struct docg3 *docg3 = floor->priv; 1721 1722 if (IS_ERR_OR_NULL(root)) { 1723 if (IS_ENABLED(CONFIG_DEBUG_FS) && 1724 !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) 1725 dev_warn(floor->dev.parent, 1726 "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n"); 1727 return; 1728 } 1729 1730 debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3, 1731 &flashcontrol_fops); 1732 debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3, 1733 &asic_mode_fops); 1734 debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3, 1735 &device_id_fops); 1736 debugfs_create_file("docg3_protection", S_IRUSR, root, docg3, 1737 &protection_fops); 1738} 1739 1740/** 1741 * doc_set_driver_info - Fill the mtd_info structure and docg3 structure 1742 * @chip_id: The chip ID of the supported chip 1743 * @mtd: The structure to fill 1744 */ 1745static int __init doc_set_driver_info(int chip_id, struct mtd_info *mtd) 1746{ 1747 struct docg3 *docg3 = mtd->priv; 1748 int cfg; 1749 1750 cfg = doc_register_readb(docg3, DOC_CONFIGURATION); 1751 docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0); 1752 docg3->reliable = reliable_mode; 1753 1754 switch (chip_id) { 1755 case DOC_CHIPID_G3: 1756 mtd->name = devm_kasprintf(docg3->dev, GFP_KERNEL, "docg3.%d", 1757 docg3->device_id); 1758 if (!mtd->name) 1759 return -ENOMEM; 1760 docg3->max_block = 2047; 1761 break; 1762 } 1763 mtd->type = MTD_NANDFLASH; 1764 mtd->flags = MTD_CAP_NANDFLASH; 1765 mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE; 1766 if (docg3->reliable == 2) 1767 mtd->size /= 2; 1768 mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES; 1769 if (docg3->reliable == 2) 1770 mtd->erasesize /= 2; 1771 mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE; 1772 mtd->oobsize = DOC_LAYOUT_OOB_SIZE; 1773 mtd->_erase = doc_erase; 1774 mtd->_read_oob = doc_read_oob; 1775 mtd->_write_oob = doc_write_oob; 1776 mtd->_block_isbad = doc_block_isbad; 1777 mtd_set_ooblayout(mtd, &nand_ooblayout_docg3_ops); 1778 mtd->oobavail = 8; 1779 mtd->ecc_strength = DOC_ECC_BCH_T; 1780 1781 return 0; 1782} 1783 1784/** 1785 * doc_probe_device - Check if a device is available 1786 * @base: the io space where the device is probed 1787 * @floor: the floor of the probed device 1788 * @dev: the device 1789 * @cascade: the cascade of chips this devices will belong to 1790 * 1791 * Checks whether a device at the specified IO range, and floor is available. 1792 * 1793 * Returns a mtd_info struct if there is a device, ENODEV if none found, ENOMEM 1794 * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is 1795 * launched. 1796 */ 1797static struct mtd_info * __init 1798doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev) 1799{ 1800 int ret, bbt_nbpages; 1801 u16 chip_id, chip_id_inv; 1802 struct docg3 *docg3; 1803 struct mtd_info *mtd; 1804 1805 ret = -ENOMEM; 1806 docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL); 1807 if (!docg3) 1808 goto nomem1; 1809 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); 1810 if (!mtd) 1811 goto nomem2; 1812 mtd->priv = docg3; 1813 mtd->dev.parent = dev; 1814 bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1, 1815 8 * DOC_LAYOUT_PAGE_SIZE); 1816 docg3->bbt = kcalloc(DOC_LAYOUT_PAGE_SIZE, bbt_nbpages, GFP_KERNEL); 1817 if (!docg3->bbt) 1818 goto nomem3; 1819 1820 docg3->dev = dev; 1821 docg3->device_id = floor; 1822 docg3->cascade = cascade; 1823 doc_set_device_id(docg3, docg3->device_id); 1824 if (!floor) 1825 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET); 1826 doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL); 1827 1828 chip_id = doc_register_readw(docg3, DOC_CHIPID); 1829 chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV); 1830 1831 ret = 0; 1832 if (chip_id != (u16)(~chip_id_inv)) { 1833 goto nomem4; 1834 } 1835 1836 switch (chip_id) { 1837 case DOC_CHIPID_G3: 1838 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n", 1839 docg3->cascade->base, floor); 1840 break; 1841 default: 1842 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id); 1843 goto nomem4; 1844 } 1845 1846 ret = doc_set_driver_info(chip_id, mtd); 1847 if (ret) 1848 goto nomem4; 1849 1850 doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ); 1851 doc_reload_bbt(docg3); 1852 return mtd; 1853 1854nomem4: 1855 kfree(docg3->bbt); 1856nomem3: 1857 kfree(mtd); 1858nomem2: 1859 kfree(docg3); 1860nomem1: 1861 return ret ? ERR_PTR(ret) : NULL; 1862} 1863 1864/** 1865 * doc_release_device - Release a docg3 floor 1866 * @mtd: the device 1867 */ 1868static void doc_release_device(struct mtd_info *mtd) 1869{ 1870 struct docg3 *docg3 = mtd->priv; 1871 1872 mtd_device_unregister(mtd); 1873 kfree(docg3->bbt); 1874 kfree(docg3); 1875 kfree(mtd); 1876} 1877 1878/** 1879 * docg3_resume - Awakens docg3 floor 1880 * @pdev: platfrom device 1881 * 1882 * Returns 0 (always successful) 1883 */ 1884static int docg3_resume(struct platform_device *pdev) 1885{ 1886 int i; 1887 struct docg3_cascade *cascade; 1888 struct mtd_info **docg3_floors, *mtd; 1889 struct docg3 *docg3; 1890 1891 cascade = platform_get_drvdata(pdev); 1892 docg3_floors = cascade->floors; 1893 mtd = docg3_floors[0]; 1894 docg3 = mtd->priv; 1895 1896 doc_dbg("docg3_resume()\n"); 1897 for (i = 0; i < 12; i++) 1898 doc_readb(docg3, DOC_IOSPACE_IPL); 1899 return 0; 1900} 1901 1902/** 1903 * docg3_suspend - Put in low power mode the docg3 floor 1904 * @pdev: platform device 1905 * @state: power state 1906 * 1907 * Shuts off most of docg3 circuitery to lower power consumption. 1908 * 1909 * Returns 0 if suspend succeeded, -EIO if chip refused suspend 1910 */ 1911static int docg3_suspend(struct platform_device *pdev, pm_message_t state) 1912{ 1913 int floor, i; 1914 struct docg3_cascade *cascade; 1915 struct mtd_info **docg3_floors, *mtd; 1916 struct docg3 *docg3; 1917 u8 ctrl, pwr_down; 1918 1919 cascade = platform_get_drvdata(pdev); 1920 docg3_floors = cascade->floors; 1921 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) { 1922 mtd = docg3_floors[floor]; 1923 if (!mtd) 1924 continue; 1925 docg3 = mtd->priv; 1926 1927 doc_writeb(docg3, floor, DOC_DEVICESELECT); 1928 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL); 1929 ctrl &= ~DOC_CTRL_VIOLATION & ~DOC_CTRL_CE; 1930 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL); 1931 1932 for (i = 0; i < 10; i++) { 1933 usleep_range(3000, 4000); 1934 pwr_down = doc_register_readb(docg3, DOC_POWERMODE); 1935 if (pwr_down & DOC_POWERDOWN_READY) 1936 break; 1937 } 1938 if (pwr_down & DOC_POWERDOWN_READY) { 1939 doc_dbg("docg3_suspend(): floor %d powerdown ok\n", 1940 floor); 1941 } else { 1942 doc_err("docg3_suspend(): floor %d powerdown failed\n", 1943 floor); 1944 return -EIO; 1945 } 1946 } 1947 1948 mtd = docg3_floors[0]; 1949 docg3 = mtd->priv; 1950 doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN); 1951 return 0; 1952} 1953 1954/** 1955 * doc_probe - Probe the IO space for a DiskOnChip G3 chip 1956 * @pdev: platform device 1957 * 1958 * Probes for a G3 chip at the specified IO space in the platform data 1959 * ressources. The floor 0 must be available. 1960 * 1961 * Returns 0 on success, -ENOMEM, -ENXIO on error 1962 */ 1963static int __init docg3_probe(struct platform_device *pdev) 1964{ 1965 struct device *dev = &pdev->dev; 1966 struct mtd_info *mtd; 1967 struct resource *ress; 1968 void __iomem *base; 1969 int ret, floor; 1970 struct docg3_cascade *cascade; 1971 1972 ret = -ENXIO; 1973 ress = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1974 if (!ress) { 1975 dev_err(dev, "No I/O memory resource defined\n"); 1976 return ret; 1977 } 1978 1979 ret = -ENOMEM; 1980 base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE); 1981 if (!base) { 1982 dev_err(dev, "devm_ioremap dev failed\n"); 1983 return ret; 1984 } 1985 1986 cascade = devm_kcalloc(dev, DOC_MAX_NBFLOORS, sizeof(*cascade), 1987 GFP_KERNEL); 1988 if (!cascade) 1989 return ret; 1990 cascade->base = base; 1991 mutex_init(&cascade->lock); 1992 cascade->bch = bch_init(DOC_ECC_BCH_M, DOC_ECC_BCH_T, 1993 DOC_ECC_BCH_PRIMPOLY, false); 1994 if (!cascade->bch) 1995 return ret; 1996 1997 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) { 1998 mtd = doc_probe_device(cascade, floor, dev); 1999 if (IS_ERR(mtd)) { 2000 ret = PTR_ERR(mtd); 2001 goto err_probe; 2002 } 2003 if (!mtd) { 2004 if (floor == 0) 2005 goto notfound; 2006 else 2007 continue; 2008 } 2009 cascade->floors[floor] = mtd; 2010 ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL, 2011 0); 2012 if (ret) 2013 goto err_probe; 2014 2015 doc_dbg_register(cascade->floors[floor]); 2016 } 2017 2018 ret = doc_register_sysfs(pdev, cascade); 2019 if (ret) 2020 goto err_probe; 2021 2022 platform_set_drvdata(pdev, cascade); 2023 return 0; 2024 2025notfound: 2026 ret = -ENODEV; 2027 dev_info(dev, "No supported DiskOnChip found\n"); 2028err_probe: 2029 bch_free(cascade->bch); 2030 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) 2031 if (cascade->floors[floor]) 2032 doc_release_device(cascade->floors[floor]); 2033 return ret; 2034} 2035 2036/** 2037 * docg3_release - Release the driver 2038 * @pdev: the platform device 2039 * 2040 * Returns 0 2041 */ 2042static int docg3_release(struct platform_device *pdev) 2043{ 2044 struct docg3_cascade *cascade = platform_get_drvdata(pdev); 2045 struct docg3 *docg3 = cascade->floors[0]->priv; 2046 int floor; 2047 2048 doc_unregister_sysfs(pdev, cascade); 2049 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) 2050 if (cascade->floors[floor]) 2051 doc_release_device(cascade->floors[floor]); 2052 2053 bch_free(docg3->cascade->bch); 2054 return 0; 2055} 2056 2057#ifdef CONFIG_OF 2058static const struct of_device_id docg3_dt_ids[] = { 2059 { .compatible = "m-systems,diskonchip-g3" }, 2060 {} 2061}; 2062MODULE_DEVICE_TABLE(of, docg3_dt_ids); 2063#endif 2064 2065static struct platform_driver g3_driver = { 2066 .driver = { 2067 .name = "docg3", 2068 .of_match_table = of_match_ptr(docg3_dt_ids), 2069 }, 2070 .suspend = docg3_suspend, 2071 .resume = docg3_resume, 2072 .remove = docg3_release, 2073}; 2074 2075module_platform_driver_probe(g3_driver, docg3_probe); 2076 2077MODULE_LICENSE("GPL"); 2078MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>"); 2079MODULE_DESCRIPTION("MTD driver for DiskOnChip G3"); 2080