1 /* 2 * $Id: pmc551.c,v 1.32 2005/11/07 11:14:25 gleixner Exp $ 3 * 4 * PMC551 PCI Mezzanine Ram Device 5 * 6 * Author: 7 * Mark Ferrell <mferrell@mvista.com> 8 * Copyright 1999,2000 Nortel Networks 9 * 10 * License: 11 * As part of this driver was derived from the slram.c driver it 12 * falls under the same license, which is GNU General Public 13 * License v2 14 * 15 * Description: 16 * This driver is intended to support the PMC551 PCI Ram device 17 * from Ramix Inc. The PMC551 is a PMC Mezzanine module for 18 * cPCI embedded systems. The device contains a single SROM 19 * that initially programs the V370PDC chipset onboard the 20 * device, and various banks of DRAM/SDRAM onboard. This driver 21 * implements this PCI Ram device as an MTD (Memory Technology 22 * Device) so that it can be used to hold a file system, or for 23 * added swap space in embedded systems. Since the memory on 24 * this board isn't as fast as main memory we do not try to hook 25 * it into main memory as that would simply reduce performance 26 * on the system. Using it as a block device allows us to use 27 * it as high speed swap or for a high speed disk device of some 28 * sort. Which becomes very useful on diskless systems in the 29 * embedded market I might add. 30 * 31 * Notes: 32 * Due to what I assume is more buggy SROM, the 64M PMC551 I 33 * have available claims that all 4 of it's DRAM banks have 64M 34 * of ram configured (making a grand total of 256M onboard). 35 * This is slightly annoying since the BAR0 size reflects the 36 * aperture size, not the dram size, and the V370PDC supplies no 37 * other method for memory size discovery. This problem is 38 * mostly only relevant when compiled as a module, as the 39 * unloading of the module with an aperture size smaller then 40 * the ram will cause the driver to detect the onboard memory 41 * size to be equal to the aperture size when the module is 42 * reloaded. Soooo, to help, the module supports an msize 43 * option to allow the specification of the onboard memory, and 44 * an asize option, to allow the specification of the aperture 45 * size. The aperture must be equal to or less then the memory 46 * size, the driver will correct this if you screw it up. This 47 * problem is not relevant for compiled in drivers as compiled 48 * in drivers only init once. 49 * 50 * Credits: 51 * Saeed Karamooz <saeed@ramix.com> of Ramix INC. for the 52 * initial example code of how to initialize this device and for 53 * help with questions I had concerning operation of the device. 54 * 55 * Most of the MTD code for this driver was originally written 56 * for the slram.o module in the MTD drivers package which 57 * allows the mapping of system memory into an MTD device. 58 * Since the PMC551 memory module is accessed in the same 59 * fashion as system memory, the slram.c code became a very nice 60 * fit to the needs of this driver. All we added was PCI 61 * detection/initialization to the driver and automatically figure 62 * out the size via the PCI detection.o, later changes by Corey 63 * Minyard set up the card to utilize a 1M sliding apature. 64 * 65 * Corey Minyard <minyard@nortelnetworks.com> 66 * * Modified driver to utilize a sliding aperture instead of 67 * mapping all memory into kernel space which turned out to 68 * be very wasteful. 69 * * Located a bug in the SROM's initialization sequence that 70 * made the memory unusable, added a fix to code to touch up 71 * the DRAM some. 72 * 73 * Bugs/FIXME's: 74 * * MUST fix the init function to not spin on a register 75 * waiting for it to set .. this does not safely handle busted 76 * devices that never reset the register correctly which will 77 * cause the system to hang w/ a reboot being the only chance at 78 * recover. [sort of fixed, could be better] 79 * * Add I2C handling of the SROM so we can read the SROM's information 80 * about the aperture size. This should always accurately reflect the 81 * onboard memory size. 82 * * Comb the init routine. It's still a bit cludgy on a few things. 83 */ 84 85 #include <linux/kernel.h> 86 #include <linux/module.h> 87 #include <asm/uaccess.h> 88 #include <linux/types.h> 89 #include <linux/init.h> 90 #include <linux/ptrace.h> 91 #include <linux/slab.h> 92 #include <linux/string.h> 93 #include <linux/timer.h> 94 #include <linux/major.h> 95 #include <linux/fs.h> 96 #include <linux/ioctl.h> 97 #include <asm/io.h> 98 #include <asm/system.h> 99 #include <linux/pci.h> 100 101 #include <linux/mtd/mtd.h> 102 #include <linux/mtd/pmc551.h> 103 #include <linux/mtd/compatmac.h> 104 105 static struct mtd_info *pmc551list; 106 107 static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr) 108 { 109 struct mypriv *priv = mtd->priv; 110 u32 soff_hi, soff_lo; /* start address offset hi/lo */ 111 u32 eoff_hi, eoff_lo; /* end address offset hi/lo */ 112 unsigned long end; 113 u_char *ptr; 114 size_t retlen; 115 116 #ifdef CONFIG_MTD_PMC551_DEBUG 117 printk(KERN_DEBUG "pmc551_erase(pos:%ld, len:%ld)\n", (long)instr->addr, 118 (long)instr->len); 119 #endif 120 121 end = instr->addr + instr->len - 1; 122 123 /* Is it past the end? */ 124 if (end > mtd->size) { 125 #ifdef CONFIG_MTD_PMC551_DEBUG 126 printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)\n", 127 (long)end, (long)mtd->size); 128 #endif 129 return -EINVAL; 130 } 131 132 eoff_hi = end & ~(priv->asize - 1); 133 soff_hi = instr->addr & ~(priv->asize - 1); 134 eoff_lo = end & (priv->asize - 1); 135 soff_lo = instr->addr & (priv->asize - 1); 136 137 pmc551_point(mtd, instr->addr, instr->len, &retlen, &ptr); 138 139 if (soff_hi == eoff_hi || mtd->size == priv->asize) { 140 /* The whole thing fits within one access, so just one shot 141 will do it. */ 142 memset(ptr, 0xff, instr->len); 143 } else { 144 /* We have to do multiple writes to get all the data 145 written. */ 146 while (soff_hi != eoff_hi) { 147 #ifdef CONFIG_MTD_PMC551_DEBUG 148 printk(KERN_DEBUG "pmc551_erase() soff_hi: %ld, " 149 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 150 #endif 151 memset(ptr, 0xff, priv->asize); 152 if (soff_hi + priv->asize >= mtd->size) { 153 goto out; 154 } 155 soff_hi += priv->asize; 156 pmc551_point(mtd, (priv->base_map0 | soff_hi), 157 priv->asize, &retlen, &ptr); 158 } 159 memset(ptr, 0xff, eoff_lo); 160 } 161 162 out: 163 instr->state = MTD_ERASE_DONE; 164 #ifdef CONFIG_MTD_PMC551_DEBUG 165 printk(KERN_DEBUG "pmc551_erase() done\n"); 166 #endif 167 168 mtd_erase_callback(instr); 169 return 0; 170 } 171 172 static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len, 173 size_t * retlen, u_char ** mtdbuf) 174 { 175 struct mypriv *priv = mtd->priv; 176 u32 soff_hi; 177 u32 soff_lo; 178 179 #ifdef CONFIG_MTD_PMC551_DEBUG 180 printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len); 181 #endif 182 183 if (from + len > mtd->size) { 184 #ifdef CONFIG_MTD_PMC551_DEBUG 185 printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n", 186 (long)from + len, (long)mtd->size); 187 #endif 188 return -EINVAL; 189 } 190 191 soff_hi = from & ~(priv->asize - 1); 192 soff_lo = from & (priv->asize - 1); 193 194 /* Cheap hack optimization */ 195 if (priv->curr_map0 != from) { 196 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0, 197 (priv->base_map0 | soff_hi)); 198 priv->curr_map0 = soff_hi; 199 } 200 201 *mtdbuf = priv->start + soff_lo; 202 *retlen = len; 203 return 0; 204 } 205 206 static void pmc551_unpoint(struct mtd_info *mtd, u_char * addr, loff_t from, 207 size_t len) 208 { 209 #ifdef CONFIG_MTD_PMC551_DEBUG 210 printk(KERN_DEBUG "pmc551_unpoint()\n"); 211 #endif 212 } 213 214 static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len, 215 size_t * retlen, u_char * buf) 216 { 217 struct mypriv *priv = mtd->priv; 218 u32 soff_hi, soff_lo; /* start address offset hi/lo */ 219 u32 eoff_hi, eoff_lo; /* end address offset hi/lo */ 220 unsigned long end; 221 u_char *ptr; 222 u_char *copyto = buf; 223 224 #ifdef CONFIG_MTD_PMC551_DEBUG 225 printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ld\n", 226 (long)from, (long)len, (long)priv->asize); 227 #endif 228 229 end = from + len - 1; 230 231 /* Is it past the end? */ 232 if (end > mtd->size) { 233 #ifdef CONFIG_MTD_PMC551_DEBUG 234 printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n", 235 (long)end, (long)mtd->size); 236 #endif 237 return -EINVAL; 238 } 239 240 soff_hi = from & ~(priv->asize - 1); 241 eoff_hi = end & ~(priv->asize - 1); 242 soff_lo = from & (priv->asize - 1); 243 eoff_lo = end & (priv->asize - 1); 244 245 pmc551_point(mtd, from, len, retlen, &ptr); 246 247 if (soff_hi == eoff_hi) { 248 /* The whole thing fits within one access, so just one shot 249 will do it. */ 250 memcpy(copyto, ptr, len); 251 copyto += len; 252 } else { 253 /* We have to do multiple writes to get all the data 254 written. */ 255 while (soff_hi != eoff_hi) { 256 #ifdef CONFIG_MTD_PMC551_DEBUG 257 printk(KERN_DEBUG "pmc551_read() soff_hi: %ld, " 258 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 259 #endif 260 memcpy(copyto, ptr, priv->asize); 261 copyto += priv->asize; 262 if (soff_hi + priv->asize >= mtd->size) { 263 goto out; 264 } 265 soff_hi += priv->asize; 266 pmc551_point(mtd, soff_hi, priv->asize, retlen, &ptr); 267 } 268 memcpy(copyto, ptr, eoff_lo); 269 copyto += eoff_lo; 270 } 271 272 out: 273 #ifdef CONFIG_MTD_PMC551_DEBUG 274 printk(KERN_DEBUG "pmc551_read() done\n"); 275 #endif 276 *retlen = copyto - buf; 277 return 0; 278 } 279 280 static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len, 281 size_t * retlen, const u_char * buf) 282 { 283 struct mypriv *priv = mtd->priv; 284 u32 soff_hi, soff_lo; /* start address offset hi/lo */ 285 u32 eoff_hi, eoff_lo; /* end address offset hi/lo */ 286 unsigned long end; 287 u_char *ptr; 288 const u_char *copyfrom = buf; 289 290 #ifdef CONFIG_MTD_PMC551_DEBUG 291 printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ld\n", 292 (long)to, (long)len, (long)priv->asize); 293 #endif 294 295 end = to + len - 1; 296 /* Is it past the end? or did the u32 wrap? */ 297 if (end > mtd->size) { 298 #ifdef CONFIG_MTD_PMC551_DEBUG 299 printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, " 300 "size: %ld, to: %ld)\n", (long)end, (long)mtd->size, 301 (long)to); 302 #endif 303 return -EINVAL; 304 } 305 306 soff_hi = to & ~(priv->asize - 1); 307 eoff_hi = end & ~(priv->asize - 1); 308 soff_lo = to & (priv->asize - 1); 309 eoff_lo = end & (priv->asize - 1); 310 311 pmc551_point(mtd, to, len, retlen, &ptr); 312 313 if (soff_hi == eoff_hi) { 314 /* The whole thing fits within one access, so just one shot 315 will do it. */ 316 memcpy(ptr, copyfrom, len); 317 copyfrom += len; 318 } else { 319 /* We have to do multiple writes to get all the data 320 written. */ 321 while (soff_hi != eoff_hi) { 322 #ifdef CONFIG_MTD_PMC551_DEBUG 323 printk(KERN_DEBUG "pmc551_write() soff_hi: %ld, " 324 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 325 #endif 326 memcpy(ptr, copyfrom, priv->asize); 327 copyfrom += priv->asize; 328 if (soff_hi >= mtd->size) { 329 goto out; 330 } 331 soff_hi += priv->asize; 332 pmc551_point(mtd, soff_hi, priv->asize, retlen, &ptr); 333 } 334 memcpy(ptr, copyfrom, eoff_lo); 335 copyfrom += eoff_lo; 336 } 337 338 out: 339 #ifdef CONFIG_MTD_PMC551_DEBUG 340 printk(KERN_DEBUG "pmc551_write() done\n"); 341 #endif 342 *retlen = copyfrom - buf; 343 return 0; 344 } 345 346 /* 347 * Fixup routines for the V370PDC 348 * PCI device ID 0x020011b0 349 * 350 * This function basicly kick starts the DRAM oboard the card and gets it 351 * ready to be used. Before this is done the device reads VERY erratic, so 352 * much that it can crash the Linux 2.2.x series kernels when a user cat's 353 * /proc/pci .. though that is mainly a kernel bug in handling the PCI DEVSEL 354 * register. FIXME: stop spinning on registers .. must implement a timeout 355 * mechanism 356 * returns the size of the memory region found. 357 */ 358 static u32 fixup_pmc551(struct pci_dev *dev) 359 { 360 #ifdef CONFIG_MTD_PMC551_BUGFIX 361 u32 dram_data; 362 #endif 363 u32 size, dcmd, cfg, dtmp; 364 u16 cmd, tmp, i; 365 u8 bcmd, counter; 366 367 /* Sanity Check */ 368 if (!dev) { 369 return -ENODEV; 370 } 371 372 /* 373 * Attempt to reset the card 374 * FIXME: Stop Spinning registers 375 */ 376 counter = 0; 377 /* unlock registers */ 378 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5); 379 /* read in old data */ 380 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd); 381 /* bang the reset line up and down for a few */ 382 for (i = 0; i < 10; i++) { 383 counter = 0; 384 bcmd &= ~0x80; 385 while (counter++ < 100) { 386 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 387 } 388 counter = 0; 389 bcmd |= 0x80; 390 while (counter++ < 100) { 391 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 392 } 393 } 394 bcmd |= (0x40 | 0x20); 395 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 396 397 /* 398 * Take care and turn off the memory on the device while we 399 * tweak the configurations 400 */ 401 pci_read_config_word(dev, PCI_COMMAND, &cmd); 402 tmp = cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY); 403 pci_write_config_word(dev, PCI_COMMAND, tmp); 404 405 /* 406 * Disable existing aperture before probing memory size 407 */ 408 pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd); 409 dtmp = (dcmd | PMC551_PCI_MEM_MAP_ENABLE | PMC551_PCI_MEM_MAP_REG_EN); 410 pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp); 411 /* 412 * Grab old BAR0 config so that we can figure out memory size 413 * This is another bit of kludge going on. The reason for the 414 * redundancy is I am hoping to retain the original configuration 415 * previously assigned to the card by the BIOS or some previous 416 * fixup routine in the kernel. So we read the old config into cfg, 417 * then write all 1's to the memory space, read back the result into 418 * "size", and then write back all the old config. 419 */ 420 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &cfg); 421 #ifndef CONFIG_MTD_PMC551_BUGFIX 422 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, ~0); 423 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &size); 424 size = (size & PCI_BASE_ADDRESS_MEM_MASK); 425 size &= ~(size - 1); 426 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, cfg); 427 #else 428 /* 429 * Get the size of the memory by reading all the DRAM size values 430 * and adding them up. 431 * 432 * KLUDGE ALERT: the boards we are using have invalid column and 433 * row mux values. We fix them here, but this will break other 434 * memory configurations. 435 */ 436 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data); 437 size = PMC551_DRAM_BLK_GET_SIZE(dram_data); 438 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 439 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 440 pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data); 441 442 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data); 443 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 444 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 445 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 446 pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data); 447 448 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data); 449 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 450 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 451 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 452 pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data); 453 454 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data); 455 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 456 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 457 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 458 pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data); 459 460 /* 461 * Oops .. something went wrong 462 */ 463 if ((size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) { 464 return -ENODEV; 465 } 466 #endif /* CONFIG_MTD_PMC551_BUGFIX */ 467 468 if ((cfg & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) { 469 return -ENODEV; 470 } 471 472 /* 473 * Precharge Dram 474 */ 475 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0400); 476 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x00bf); 477 478 /* 479 * Wait until command has gone through 480 * FIXME: register spinning issue 481 */ 482 do { 483 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 484 if (counter++ > 100) 485 break; 486 } while ((PCI_COMMAND_IO) & cmd); 487 488 /* 489 * Turn on auto refresh 490 * The loop is taken directly from Ramix's example code. I assume that 491 * this must be held high for some duration of time, but I can find no 492 * documentation refrencing the reasons why. 493 */ 494 for (i = 1; i <= 8; i++) { 495 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0df); 496 497 /* 498 * Make certain command has gone through 499 * FIXME: register spinning issue 500 */ 501 counter = 0; 502 do { 503 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 504 if (counter++ > 100) 505 break; 506 } while ((PCI_COMMAND_IO) & cmd); 507 } 508 509 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0020); 510 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0ff); 511 512 /* 513 * Wait until command completes 514 * FIXME: register spinning issue 515 */ 516 counter = 0; 517 do { 518 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 519 if (counter++ > 100) 520 break; 521 } while ((PCI_COMMAND_IO) & cmd); 522 523 pci_read_config_dword(dev, PMC551_DRAM_CFG, &dcmd); 524 dcmd |= 0x02000000; 525 pci_write_config_dword(dev, PMC551_DRAM_CFG, dcmd); 526 527 /* 528 * Check to make certain fast back-to-back, if not 529 * then set it so 530 */ 531 pci_read_config_word(dev, PCI_STATUS, &cmd); 532 if ((cmd & PCI_COMMAND_FAST_BACK) == 0) { 533 cmd |= PCI_COMMAND_FAST_BACK; 534 pci_write_config_word(dev, PCI_STATUS, cmd); 535 } 536 537 /* 538 * Check to make certain the DEVSEL is set correctly, this device 539 * has a tendancy to assert DEVSEL and TRDY when a write is performed 540 * to the memory when memory is read-only 541 */ 542 if ((cmd & PCI_STATUS_DEVSEL_MASK) != 0x0) { 543 cmd &= ~PCI_STATUS_DEVSEL_MASK; 544 pci_write_config_word(dev, PCI_STATUS, cmd); 545 } 546 /* 547 * Set to be prefetchable and put everything back based on old cfg. 548 * it's possible that the reset of the V370PDC nuked the original 549 * setup 550 */ 551 /* 552 cfg |= PCI_BASE_ADDRESS_MEM_PREFETCH; 553 pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg ); 554 */ 555 556 /* 557 * Turn PCI memory and I/O bus access back on 558 */ 559 pci_write_config_word(dev, PCI_COMMAND, 560 PCI_COMMAND_MEMORY | PCI_COMMAND_IO); 561 #ifdef CONFIG_MTD_PMC551_DEBUG 562 /* 563 * Some screen fun 564 */ 565 printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at " 566 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ? 567 size >> 10 : size >> 20, 568 (size < 1024) ? 'B' : (size < 1048576) ? 'K' : 'M', size, 569 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "", 570 (unsigned long long)pci_resource_start(dev, 0)); 571 572 /* 573 * Check to see the state of the memory 574 */ 575 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dcmd); 576 printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%s\n" 577 "pmc551: DRAM_BLK0 Size: %d at %d\n" 578 "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %d\n", 579 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 580 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 581 PMC551_DRAM_BLK_GET_SIZE(dcmd), 582 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 583 ((dcmd >> 9) & 0xF)); 584 585 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dcmd); 586 printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%s\n" 587 "pmc551: DRAM_BLK1 Size: %d at %d\n" 588 "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %d\n", 589 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 590 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 591 PMC551_DRAM_BLK_GET_SIZE(dcmd), 592 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 593 ((dcmd >> 9) & 0xF)); 594 595 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dcmd); 596 printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%s\n" 597 "pmc551: DRAM_BLK2 Size: %d at %d\n" 598 "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %d\n", 599 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 600 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 601 PMC551_DRAM_BLK_GET_SIZE(dcmd), 602 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 603 ((dcmd >> 9) & 0xF)); 604 605 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dcmd); 606 printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%s\n" 607 "pmc551: DRAM_BLK3 Size: %d at %d\n" 608 "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %d\n", 609 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 610 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 611 PMC551_DRAM_BLK_GET_SIZE(dcmd), 612 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 613 ((dcmd >> 9) & 0xF)); 614 615 pci_read_config_word(dev, PCI_COMMAND, &cmd); 616 printk(KERN_DEBUG "pmc551: Memory Access %s\n", 617 (((0x1 << 1) & cmd) == 0) ? "off" : "on"); 618 printk(KERN_DEBUG "pmc551: I/O Access %s\n", 619 (((0x1 << 0) & cmd) == 0) ? "off" : "on"); 620 621 pci_read_config_word(dev, PCI_STATUS, &cmd); 622 printk(KERN_DEBUG "pmc551: Devsel %s\n", 623 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x000) ? "Fast" : 624 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x200) ? "Medium" : 625 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x400) ? "Slow" : "Invalid"); 626 627 printk(KERN_DEBUG "pmc551: %sFast Back-to-Back\n", 628 ((PCI_COMMAND_FAST_BACK & cmd) == 0) ? "Not " : ""); 629 630 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd); 631 printk(KERN_DEBUG "pmc551: EEPROM is under %s control\n" 632 "pmc551: System Control Register is %slocked to PCI access\n" 633 "pmc551: System Control Register is %slocked to EEPROM access\n", 634 (bcmd & 0x1) ? "software" : "hardware", 635 (bcmd & 0x20) ? "" : "un", (bcmd & 0x40) ? "" : "un"); 636 #endif 637 return size; 638 } 639 640 /* 641 * Kernel version specific module stuffages 642 */ 643 644 MODULE_LICENSE("GPL"); 645 MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>"); 646 MODULE_DESCRIPTION(PMC551_VERSION); 647 648 /* 649 * Stuff these outside the ifdef so as to not bust compiled in driver support 650 */ 651 static int msize = 0; 652 #if defined(CONFIG_MTD_PMC551_APERTURE_SIZE) 653 static int asize = CONFIG_MTD_PMC551_APERTURE_SIZE; 654 #else 655 static int asize = 0; 656 #endif 657 658 module_param(msize, int, 0); 659 MODULE_PARM_DESC(msize, "memory size in Megabytes [1 - 1024]"); 660 module_param(asize, int, 0); 661 MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]"); 662 663 /* 664 * PMC551 Card Initialization 665 */ 666 static int __init init_pmc551(void) 667 { 668 struct pci_dev *PCI_Device = NULL; 669 struct mypriv *priv; 670 int count, found = 0; 671 struct mtd_info *mtd; 672 u32 length = 0; 673 674 if (msize) { 675 msize = (1 << (ffs(msize) - 1)) << 20; 676 if (msize > (1 << 30)) { 677 printk(KERN_NOTICE "pmc551: Invalid memory size [%d]\n", 678 msize); 679 return -EINVAL; 680 } 681 } 682 683 if (asize) { 684 asize = (1 << (ffs(asize) - 1)) << 20; 685 if (asize > (1 << 30)) { 686 printk(KERN_NOTICE "pmc551: Invalid aperture size " 687 "[%d]\n", asize); 688 return -EINVAL; 689 } 690 } 691 692 printk(KERN_INFO PMC551_VERSION); 693 694 /* 695 * PCU-bus chipset probe. 696 */ 697 for (count = 0; count < MAX_MTD_DEVICES; count++) { 698 699 if ((PCI_Device = pci_get_device(PCI_VENDOR_ID_V3_SEMI, 700 PCI_DEVICE_ID_V3_SEMI_V370PDC, 701 PCI_Device)) == NULL) { 702 break; 703 } 704 705 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n", 706 (unsigned long long)pci_resource_start(PCI_Device, 0)); 707 708 /* 709 * The PMC551 device acts VERY weird if you don't init it 710 * first. i.e. it will not correctly report devsel. If for 711 * some reason the sdram is in a wrote-protected state the 712 * device will DEVSEL when it is written to causing problems 713 * with the oldproc.c driver in 714 * some kernels (2.2.*) 715 */ 716 if ((length = fixup_pmc551(PCI_Device)) <= 0) { 717 printk(KERN_NOTICE "pmc551: Cannot init SDRAM\n"); 718 break; 719 } 720 721 /* 722 * This is needed until the driver is capable of reading the 723 * onboard I2C SROM to discover the "real" memory size. 724 */ 725 if (msize) { 726 length = msize; 727 printk(KERN_NOTICE "pmc551: Using specified memory " 728 "size 0x%x\n", length); 729 } else { 730 msize = length; 731 } 732 733 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); 734 if (!mtd) { 735 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD " 736 "device.\n"); 737 break; 738 } 739 740 priv = kzalloc(sizeof(struct mypriv), GFP_KERNEL); 741 if (!priv) { 742 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD " 743 "device.\n"); 744 kfree(mtd); 745 break; 746 } 747 mtd->priv = priv; 748 priv->dev = PCI_Device; 749 750 if (asize > length) { 751 printk(KERN_NOTICE "pmc551: reducing aperture size to " 752 "fit %dM\n", length >> 20); 753 priv->asize = asize = length; 754 } else if (asize == 0 || asize == length) { 755 printk(KERN_NOTICE "pmc551: Using existing aperture " 756 "size %dM\n", length >> 20); 757 priv->asize = asize = length; 758 } else { 759 printk(KERN_NOTICE "pmc551: Using specified aperture " 760 "size %dM\n", asize >> 20); 761 priv->asize = asize; 762 } 763 priv->start = pci_iomap(PCI_Device, 0, priv->asize); 764 765 if (!priv->start) { 766 printk(KERN_NOTICE "pmc551: Unable to map IO space\n"); 767 kfree(mtd->priv); 768 kfree(mtd); 769 break; 770 } 771 #ifdef CONFIG_MTD_PMC551_DEBUG 772 printk(KERN_DEBUG "pmc551: setting aperture to %d\n", 773 ffs(priv->asize >> 20) - 1); 774 #endif 775 776 priv->base_map0 = (PMC551_PCI_MEM_MAP_REG_EN 777 | PMC551_PCI_MEM_MAP_ENABLE 778 | (ffs(priv->asize >> 20) - 1) << 4); 779 priv->curr_map0 = priv->base_map0; 780 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0, 781 priv->curr_map0); 782 783 #ifdef CONFIG_MTD_PMC551_DEBUG 784 printk(KERN_DEBUG "pmc551: aperture set to %d\n", 785 (priv->base_map0 & 0xF0) >> 4); 786 #endif 787 788 mtd->size = msize; 789 mtd->flags = MTD_CAP_RAM; 790 mtd->erase = pmc551_erase; 791 mtd->read = pmc551_read; 792 mtd->write = pmc551_write; 793 mtd->point = pmc551_point; 794 mtd->unpoint = pmc551_unpoint; 795 mtd->type = MTD_RAM; 796 mtd->name = "PMC551 RAM board"; 797 mtd->erasesize = 0x10000; 798 mtd->writesize = 1; 799 mtd->owner = THIS_MODULE; 800 801 if (add_mtd_device(mtd)) { 802 printk(KERN_NOTICE "pmc551: Failed to register new " 803 "device\n"); 804 pci_iounmap(PCI_Device, priv->start); 805 kfree(mtd->priv); 806 kfree(mtd); 807 break; 808 } 809 810 /* Keep a reference as the add_mtd_device worked */ 811 pci_dev_get(PCI_Device); 812 813 printk(KERN_NOTICE "Registered pmc551 memory device.\n"); 814 printk(KERN_NOTICE "Mapped %dM of memory from 0x%p to 0x%p\n", 815 priv->asize >> 20, 816 priv->start, priv->start + priv->asize); 817 printk(KERN_NOTICE "Total memory is %d%c\n", 818 (length < 1024) ? length : 819 (length < 1048576) ? length >> 10 : length >> 20, 820 (length < 1024) ? 'B' : (length < 1048576) ? 'K' : 'M'); 821 priv->nextpmc551 = pmc551list; 822 pmc551list = mtd; 823 found++; 824 } 825 826 /* Exited early, reference left over */ 827 if (PCI_Device) 828 pci_dev_put(PCI_Device); 829 830 if (!pmc551list) { 831 printk(KERN_NOTICE "pmc551: not detected\n"); 832 return -ENODEV; 833 } else { 834 printk(KERN_NOTICE "pmc551: %d pmc551 devices loaded\n", found); 835 return 0; 836 } 837 } 838 839 /* 840 * PMC551 Card Cleanup 841 */ 842 static void __exit cleanup_pmc551(void) 843 { 844 int found = 0; 845 struct mtd_info *mtd; 846 struct mypriv *priv; 847 848 while ((mtd = pmc551list)) { 849 priv = mtd->priv; 850 pmc551list = priv->nextpmc551; 851 852 if (priv->start) { 853 printk(KERN_DEBUG "pmc551: unmapping %dM starting at " 854 "0x%p\n", priv->asize >> 20, priv->start); 855 pci_iounmap(priv->dev, priv->start); 856 } 857 pci_dev_put(priv->dev); 858 859 kfree(mtd->priv); 860 del_mtd_device(mtd); 861 kfree(mtd); 862 found++; 863 } 864 865 printk(KERN_NOTICE "pmc551: %d pmc551 devices unloaded\n", found); 866 } 867 868 module_init(init_pmc551); 869 module_exit(cleanup_pmc551); 870