1 /* 2 * Flash memory interface rev.5 driver for the Intel 3 * Flash chips used on the NetWinder. 4 * 5 * 20/08/2000 RMK use __ioremap to map flash into virtual memory 6 * make a few more places use "volatile" 7 * 22/05/2001 RMK - Lock read against write 8 * - merge printk level changes (with mods) from Alan Cox. 9 * - use *ppos as the file position, not file->f_pos. 10 * - fix check for out of range pos and r/w size 11 * 12 * Please note that we are tampering with the only flash chip in the 13 * machine, which contains the bootup code. We therefore have the 14 * power to convert these machines into doorstops... 15 */ 16 17 #include <linux/module.h> 18 #include <linux/types.h> 19 #include <linux/fs.h> 20 #include <linux/errno.h> 21 #include <linux/mm.h> 22 #include <linux/delay.h> 23 #include <linux/proc_fs.h> 24 #include <linux/sched.h> 25 #include <linux/miscdevice.h> 26 #include <linux/spinlock.h> 27 #include <linux/rwsem.h> 28 #include <linux/init.h> 29 #include <linux/smp_lock.h> 30 #include <linux/mutex.h> 31 32 #include <asm/hardware/dec21285.h> 33 #include <asm/io.h> 34 #include <asm/leds.h> 35 #include <asm/mach-types.h> 36 #include <asm/system.h> 37 #include <asm/uaccess.h> 38 39 /*****************************************************************************/ 40 #include <asm/nwflash.h> 41 42 #define NWFLASH_VERSION "6.4" 43 44 static void kick_open(void); 45 static int get_flash_id(void); 46 static int erase_block(int nBlock); 47 static int write_block(unsigned long p, const char __user *buf, int count); 48 49 #define KFLASH_SIZE 1024*1024 //1 Meg 50 #define KFLASH_SIZE4 4*1024*1024 //4 Meg 51 #define KFLASH_ID 0x89A6 //Intel flash 52 #define KFLASH_ID4 0xB0D4 //Intel flash 4Meg 53 54 static int flashdebug; //if set - we will display progress msgs 55 56 static int gbWriteEnable; 57 static int gbWriteBase64Enable; 58 static volatile unsigned char *FLASH_BASE; 59 static int gbFlashSize = KFLASH_SIZE; 60 static DEFINE_MUTEX(nwflash_mutex); 61 62 extern spinlock_t gpio_lock; 63 64 static int get_flash_id(void) 65 { 66 volatile unsigned int c1, c2; 67 68 /* 69 * try to get flash chip ID 70 */ 71 kick_open(); 72 c2 = inb(0x80); 73 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0x90; 74 udelay(15); 75 c1 = *(volatile unsigned char *) FLASH_BASE; 76 c2 = inb(0x80); 77 78 /* 79 * on 4 Meg flash the second byte is actually at offset 2... 80 */ 81 if (c1 == 0xB0) 82 c2 = *(volatile unsigned char *) (FLASH_BASE + 2); 83 else 84 c2 = *(volatile unsigned char *) (FLASH_BASE + 1); 85 86 c2 += (c1 << 8); 87 88 /* 89 * set it back to read mode 90 */ 91 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0xFF; 92 93 if (c2 == KFLASH_ID4) 94 gbFlashSize = KFLASH_SIZE4; 95 96 return c2; 97 } 98 99 static int flash_ioctl(struct inode *inodep, struct file *filep, unsigned int cmd, unsigned long arg) 100 { 101 switch (cmd) { 102 case CMD_WRITE_DISABLE: 103 gbWriteBase64Enable = 0; 104 gbWriteEnable = 0; 105 break; 106 107 case CMD_WRITE_ENABLE: 108 gbWriteEnable = 1; 109 break; 110 111 case CMD_WRITE_BASE64K_ENABLE: 112 gbWriteBase64Enable = 1; 113 break; 114 115 default: 116 gbWriteBase64Enable = 0; 117 gbWriteEnable = 0; 118 return -EINVAL; 119 } 120 return 0; 121 } 122 123 static ssize_t flash_read(struct file *file, char __user *buf, size_t size, 124 loff_t *ppos) 125 { 126 unsigned long p = *ppos; 127 unsigned int count = size; 128 int ret = 0; 129 130 if (flashdebug) 131 printk(KERN_DEBUG "flash_read: flash_read: offset=0x%lX, " 132 "buffer=%p, count=0x%X.\n", p, buf, count); 133 134 if (count) 135 ret = -ENXIO; 136 137 if (p < gbFlashSize) { 138 if (count > gbFlashSize - p) 139 count = gbFlashSize - p; 140 141 /* 142 * We now lock against reads and writes. --rmk 143 */ 144 if (mutex_lock_interruptible(&nwflash_mutex)) 145 return -ERESTARTSYS; 146 147 ret = copy_to_user(buf, (void *)(FLASH_BASE + p), count); 148 if (ret == 0) { 149 ret = count; 150 *ppos += count; 151 } else 152 ret = -EFAULT; 153 mutex_unlock(&nwflash_mutex); 154 } 155 return ret; 156 } 157 158 static ssize_t flash_write(struct file *file, const char __user *buf, 159 size_t size, loff_t * ppos) 160 { 161 unsigned long p = *ppos; 162 unsigned int count = size; 163 int written; 164 int nBlock, temp, rc; 165 int i, j; 166 167 if (flashdebug) 168 printk("flash_write: offset=0x%lX, buffer=0x%p, count=0x%X.\n", 169 p, buf, count); 170 171 if (!gbWriteEnable) 172 return -EINVAL; 173 174 if (p < 64 * 1024 && (!gbWriteBase64Enable)) 175 return -EINVAL; 176 177 /* 178 * check for out of range pos or count 179 */ 180 if (p >= gbFlashSize) 181 return count ? -ENXIO : 0; 182 183 if (count > gbFlashSize - p) 184 count = gbFlashSize - p; 185 186 if (!access_ok(VERIFY_READ, buf, count)) 187 return -EFAULT; 188 189 /* 190 * We now lock against reads and writes. --rmk 191 */ 192 if (mutex_lock_interruptible(&nwflash_mutex)) 193 return -ERESTARTSYS; 194 195 written = 0; 196 197 leds_event(led_claim); 198 leds_event(led_green_on); 199 200 nBlock = (int) p >> 16; //block # of 64K bytes 201 202 /* 203 * # of 64K blocks to erase and write 204 */ 205 temp = ((int) (p + count) >> 16) - nBlock + 1; 206 207 /* 208 * write ends at exactly 64k boundary? 209 */ 210 if (((int) (p + count) & 0xFFFF) == 0) 211 temp -= 1; 212 213 if (flashdebug) 214 printk(KERN_DEBUG "flash_write: writing %d block(s) " 215 "starting at %d.\n", temp, nBlock); 216 217 for (; temp; temp--, nBlock++) { 218 if (flashdebug) 219 printk(KERN_DEBUG "flash_write: erasing block %d.\n", nBlock); 220 221 /* 222 * first we have to erase the block(s), where we will write... 223 */ 224 i = 0; 225 j = 0; 226 RetryBlock: 227 do { 228 rc = erase_block(nBlock); 229 i++; 230 } while (rc && i < 10); 231 232 if (rc) { 233 printk(KERN_ERR "flash_write: erase error %x\n", rc); 234 break; 235 } 236 if (flashdebug) 237 printk(KERN_DEBUG "flash_write: writing offset %lX, " 238 "from buf %p, bytes left %X.\n", p, buf, 239 count - written); 240 241 /* 242 * write_block will limit write to space left in this block 243 */ 244 rc = write_block(p, buf, count - written); 245 j++; 246 247 /* 248 * if somehow write verify failed? Can't happen?? 249 */ 250 if (!rc) { 251 /* 252 * retry up to 10 times 253 */ 254 if (j < 10) 255 goto RetryBlock; 256 else 257 /* 258 * else quit with error... 259 */ 260 rc = -1; 261 262 } 263 if (rc < 0) { 264 printk(KERN_ERR "flash_write: write error %X\n", rc); 265 break; 266 } 267 p += rc; 268 buf += rc; 269 written += rc; 270 *ppos += rc; 271 272 if (flashdebug) 273 printk(KERN_DEBUG "flash_write: written 0x%X bytes OK.\n", written); 274 } 275 276 /* 277 * restore reg on exit 278 */ 279 leds_event(led_release); 280 281 mutex_unlock(&nwflash_mutex); 282 283 return written; 284 } 285 286 287 /* 288 * The memory devices use the full 32/64 bits of the offset, and so we cannot 289 * check against negative addresses: they are ok. The return value is weird, 290 * though, in that case (0). 291 * 292 * also note that seeking relative to the "end of file" isn't supported: 293 * it has no meaning, so it returns -EINVAL. 294 */ 295 static loff_t flash_llseek(struct file *file, loff_t offset, int orig) 296 { 297 loff_t ret; 298 299 lock_kernel(); 300 if (flashdebug) 301 printk(KERN_DEBUG "flash_llseek: offset=0x%X, orig=0x%X.\n", 302 (unsigned int) offset, orig); 303 304 switch (orig) { 305 case 0: 306 if (offset < 0) { 307 ret = -EINVAL; 308 break; 309 } 310 311 if ((unsigned int) offset > gbFlashSize) { 312 ret = -EINVAL; 313 break; 314 } 315 316 file->f_pos = (unsigned int) offset; 317 ret = file->f_pos; 318 break; 319 case 1: 320 if ((file->f_pos + offset) > gbFlashSize) { 321 ret = -EINVAL; 322 break; 323 } 324 if ((file->f_pos + offset) < 0) { 325 ret = -EINVAL; 326 break; 327 } 328 file->f_pos += offset; 329 ret = file->f_pos; 330 break; 331 default: 332 ret = -EINVAL; 333 } 334 unlock_kernel(); 335 return ret; 336 } 337 338 339 /* 340 * assume that main Write routine did the parameter checking... 341 * so just go ahead and erase, what requested! 342 */ 343 344 static int erase_block(int nBlock) 345 { 346 volatile unsigned int c1; 347 volatile unsigned char *pWritePtr; 348 unsigned long timeout; 349 int temp, temp1; 350 351 /* 352 * orange LED == erase 353 */ 354 leds_event(led_amber_on); 355 356 /* 357 * reset footbridge to the correct offset 0 (...0..3) 358 */ 359 *CSR_ROMWRITEREG = 0; 360 361 /* 362 * dummy ROM read 363 */ 364 c1 = *(volatile unsigned char *) (FLASH_BASE + 0x8000); 365 366 kick_open(); 367 /* 368 * reset status if old errors 369 */ 370 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0x50; 371 372 /* 373 * erase a block... 374 * aim at the middle of a current block... 375 */ 376 pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + 0x8000 + (nBlock << 16))); 377 /* 378 * dummy read 379 */ 380 c1 = *pWritePtr; 381 382 kick_open(); 383 /* 384 * erase 385 */ 386 *(volatile unsigned char *) pWritePtr = 0x20; 387 388 /* 389 * confirm 390 */ 391 *(volatile unsigned char *) pWritePtr = 0xD0; 392 393 /* 394 * wait 10 ms 395 */ 396 msleep(10); 397 398 /* 399 * wait while erasing in process (up to 10 sec) 400 */ 401 timeout = jiffies + 10 * HZ; 402 c1 = 0; 403 while (!(c1 & 0x80) && time_before(jiffies, timeout)) { 404 msleep(10); 405 /* 406 * read any address 407 */ 408 c1 = *(volatile unsigned char *) (pWritePtr); 409 // printk("Flash_erase: status=%X.\n",c1); 410 } 411 412 /* 413 * set flash for normal read access 414 */ 415 kick_open(); 416 // *(volatile unsigned char*)(FLASH_BASE+0x8000) = 0xFF; 417 *(volatile unsigned char *) pWritePtr = 0xFF; //back to normal operation 418 419 /* 420 * check if erase errors were reported 421 */ 422 if (c1 & 0x20) { 423 printk(KERN_ERR "flash_erase: err at %p\n", pWritePtr); 424 425 /* 426 * reset error 427 */ 428 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0x50; 429 return -2; 430 } 431 432 /* 433 * just to make sure - verify if erased OK... 434 */ 435 msleep(10); 436 437 pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + (nBlock << 16))); 438 439 for (temp = 0; temp < 16 * 1024; temp++, pWritePtr += 4) { 440 if ((temp1 = *(volatile unsigned int *) pWritePtr) != 0xFFFFFFFF) { 441 printk(KERN_ERR "flash_erase: verify err at %p = %X\n", 442 pWritePtr, temp1); 443 return -1; 444 } 445 } 446 447 return 0; 448 449 } 450 451 /* 452 * write_block will limit number of bytes written to the space in this block 453 */ 454 static int write_block(unsigned long p, const char __user *buf, int count) 455 { 456 volatile unsigned int c1; 457 volatile unsigned int c2; 458 unsigned char *pWritePtr; 459 unsigned int uAddress; 460 unsigned int offset; 461 unsigned long timeout; 462 unsigned long timeout1; 463 464 /* 465 * red LED == write 466 */ 467 leds_event(led_amber_off); 468 leds_event(led_red_on); 469 470 pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + p)); 471 472 /* 473 * check if write will end in this block.... 474 */ 475 offset = p & 0xFFFF; 476 477 if (offset + count > 0x10000) 478 count = 0x10000 - offset; 479 480 /* 481 * wait up to 30 sec for this block 482 */ 483 timeout = jiffies + 30 * HZ; 484 485 for (offset = 0; offset < count; offset++, pWritePtr++) { 486 uAddress = (unsigned int) pWritePtr; 487 uAddress &= 0xFFFFFFFC; 488 if (__get_user(c2, buf + offset)) 489 return -EFAULT; 490 491 WriteRetry: 492 /* 493 * dummy read 494 */ 495 c1 = *(volatile unsigned char *) (FLASH_BASE + 0x8000); 496 497 /* 498 * kick open the write gate 499 */ 500 kick_open(); 501 502 /* 503 * program footbridge to the correct offset...0..3 504 */ 505 *CSR_ROMWRITEREG = (unsigned int) pWritePtr & 3; 506 507 /* 508 * write cmd 509 */ 510 *(volatile unsigned char *) (uAddress) = 0x40; 511 512 /* 513 * data to write 514 */ 515 *(volatile unsigned char *) (uAddress) = c2; 516 517 /* 518 * get status 519 */ 520 *(volatile unsigned char *) (FLASH_BASE + 0x10000) = 0x70; 521 522 c1 = 0; 523 524 /* 525 * wait up to 1 sec for this byte 526 */ 527 timeout1 = jiffies + 1 * HZ; 528 529 /* 530 * while not ready... 531 */ 532 while (!(c1 & 0x80) && time_before(jiffies, timeout1)) 533 c1 = *(volatile unsigned char *) (FLASH_BASE + 0x8000); 534 535 /* 536 * if timeout getting status 537 */ 538 if (time_after_eq(jiffies, timeout1)) { 539 kick_open(); 540 /* 541 * reset err 542 */ 543 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0x50; 544 545 goto WriteRetry; 546 } 547 /* 548 * switch on read access, as a default flash operation mode 549 */ 550 kick_open(); 551 /* 552 * read access 553 */ 554 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0xFF; 555 556 /* 557 * if hardware reports an error writing, and not timeout - 558 * reset the chip and retry 559 */ 560 if (c1 & 0x10) { 561 kick_open(); 562 /* 563 * reset err 564 */ 565 *(volatile unsigned char *) (FLASH_BASE + 0x8000) = 0x50; 566 567 /* 568 * before timeout? 569 */ 570 if (time_before(jiffies, timeout)) { 571 if (flashdebug) 572 printk(KERN_DEBUG "write_block: Retrying write at 0x%X)n", 573 pWritePtr - FLASH_BASE); 574 575 /* 576 * no LED == waiting 577 */ 578 leds_event(led_amber_off); 579 /* 580 * wait couple ms 581 */ 582 msleep(10); 583 /* 584 * red LED == write 585 */ 586 leds_event(led_red_on); 587 588 goto WriteRetry; 589 } else { 590 printk(KERN_ERR "write_block: timeout at 0x%X\n", 591 pWritePtr - FLASH_BASE); 592 /* 593 * return error -2 594 */ 595 return -2; 596 597 } 598 } 599 } 600 601 /* 602 * green LED == read/verify 603 */ 604 leds_event(led_amber_off); 605 leds_event(led_green_on); 606 607 msleep(10); 608 609 pWritePtr = (unsigned char *) ((unsigned int) (FLASH_BASE + p)); 610 611 for (offset = 0; offset < count; offset++) { 612 char c, c1; 613 if (__get_user(c, buf)) 614 return -EFAULT; 615 buf++; 616 if ((c1 = *pWritePtr++) != c) { 617 printk(KERN_ERR "write_block: verify error at 0x%X (%02X!=%02X)\n", 618 pWritePtr - FLASH_BASE, c1, c); 619 return 0; 620 } 621 } 622 623 return count; 624 } 625 626 627 static void kick_open(void) 628 { 629 unsigned long flags; 630 631 /* 632 * we want to write a bit pattern XXX1 to Xilinx to enable 633 * the write gate, which will be open for about the next 2ms. 634 */ 635 spin_lock_irqsave(&gpio_lock, flags); 636 cpld_modify(1, 1); 637 spin_unlock_irqrestore(&gpio_lock, flags); 638 639 /* 640 * let the ISA bus to catch on... 641 */ 642 udelay(25); 643 } 644 645 static const struct file_operations flash_fops = 646 { 647 .owner = THIS_MODULE, 648 .llseek = flash_llseek, 649 .read = flash_read, 650 .write = flash_write, 651 .ioctl = flash_ioctl, 652 }; 653 654 static struct miscdevice flash_miscdev = 655 { 656 FLASH_MINOR, 657 "nwflash", 658 &flash_fops 659 }; 660 661 static int __init nwflash_init(void) 662 { 663 int ret = -ENODEV; 664 665 if (machine_is_netwinder()) { 666 int id; 667 668 FLASH_BASE = ioremap(DC21285_FLASH, KFLASH_SIZE4); 669 if (!FLASH_BASE) 670 goto out; 671 672 id = get_flash_id(); 673 if ((id != KFLASH_ID) && (id != KFLASH_ID4)) { 674 ret = -ENXIO; 675 iounmap((void *)FLASH_BASE); 676 printk("Flash: incorrect ID 0x%04X.\n", id); 677 goto out; 678 } 679 680 printk("Flash ROM driver v.%s, flash device ID 0x%04X, size %d Mb.\n", 681 NWFLASH_VERSION, id, gbFlashSize / (1024 * 1024)); 682 683 ret = misc_register(&flash_miscdev); 684 if (ret < 0) { 685 iounmap((void *)FLASH_BASE); 686 } 687 } 688 out: 689 return ret; 690 } 691 692 static void __exit nwflash_exit(void) 693 { 694 misc_deregister(&flash_miscdev); 695 iounmap((void *)FLASH_BASE); 696 } 697 698 MODULE_LICENSE("GPL"); 699 700 module_param(flashdebug, bool, 0644); 701 702 module_init(nwflash_init); 703 module_exit(nwflash_exit); 704