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 its DRAM banks have 64MiB 34 * of ram configured (making a grand total of 256MiB 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/FIXMEs: 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, 138 (void **)&ptr, NULL); 139 140 if (soff_hi == eoff_hi || mtd->size == priv->asize) { 141 /* The whole thing fits within one access, so just one shot 142 will do it. */ 143 memset(ptr, 0xff, instr->len); 144 } else { 145 /* We have to do multiple writes to get all the data 146 written. */ 147 while (soff_hi != eoff_hi) { 148 #ifdef CONFIG_MTD_PMC551_DEBUG 149 printk(KERN_DEBUG "pmc551_erase() soff_hi: %ld, " 150 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 151 #endif 152 memset(ptr, 0xff, priv->asize); 153 if (soff_hi + priv->asize >= mtd->size) { 154 goto out; 155 } 156 soff_hi += priv->asize; 157 pmc551_point(mtd, (priv->base_map0 | soff_hi), 158 priv->asize, &retlen, 159 (void **)&ptr, NULL); 160 } 161 memset(ptr, 0xff, eoff_lo); 162 } 163 164 out: 165 instr->state = MTD_ERASE_DONE; 166 #ifdef CONFIG_MTD_PMC551_DEBUG 167 printk(KERN_DEBUG "pmc551_erase() done\n"); 168 #endif 169 170 mtd_erase_callback(instr); 171 return 0; 172 } 173 174 static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len, 175 size_t *retlen, void **virt, resource_size_t *phys) 176 { 177 struct mypriv *priv = mtd->priv; 178 u32 soff_hi; 179 u32 soff_lo; 180 181 #ifdef CONFIG_MTD_PMC551_DEBUG 182 printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len); 183 #endif 184 185 if (from + len > mtd->size) { 186 #ifdef CONFIG_MTD_PMC551_DEBUG 187 printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n", 188 (long)from + len, (long)mtd->size); 189 #endif 190 return -EINVAL; 191 } 192 193 /* can we return a physical address with this driver? */ 194 if (phys) 195 return -EINVAL; 196 197 soff_hi = from & ~(priv->asize - 1); 198 soff_lo = from & (priv->asize - 1); 199 200 /* Cheap hack optimization */ 201 if (priv->curr_map0 != from) { 202 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0, 203 (priv->base_map0 | soff_hi)); 204 priv->curr_map0 = soff_hi; 205 } 206 207 *virt = priv->start + soff_lo; 208 *retlen = len; 209 return 0; 210 } 211 212 static void pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 213 { 214 #ifdef CONFIG_MTD_PMC551_DEBUG 215 printk(KERN_DEBUG "pmc551_unpoint()\n"); 216 #endif 217 } 218 219 static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len, 220 size_t * retlen, u_char * buf) 221 { 222 struct mypriv *priv = mtd->priv; 223 u32 soff_hi, soff_lo; /* start address offset hi/lo */ 224 u32 eoff_hi, eoff_lo; /* end address offset hi/lo */ 225 unsigned long end; 226 u_char *ptr; 227 u_char *copyto = buf; 228 229 #ifdef CONFIG_MTD_PMC551_DEBUG 230 printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ld\n", 231 (long)from, (long)len, (long)priv->asize); 232 #endif 233 234 end = from + len - 1; 235 236 /* Is it past the end? */ 237 if (end > mtd->size) { 238 #ifdef CONFIG_MTD_PMC551_DEBUG 239 printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n", 240 (long)end, (long)mtd->size); 241 #endif 242 return -EINVAL; 243 } 244 245 soff_hi = from & ~(priv->asize - 1); 246 eoff_hi = end & ~(priv->asize - 1); 247 soff_lo = from & (priv->asize - 1); 248 eoff_lo = end & (priv->asize - 1); 249 250 pmc551_point(mtd, from, len, retlen, (void **)&ptr, NULL); 251 252 if (soff_hi == eoff_hi) { 253 /* The whole thing fits within one access, so just one shot 254 will do it. */ 255 memcpy(copyto, ptr, len); 256 copyto += len; 257 } else { 258 /* We have to do multiple writes to get all the data 259 written. */ 260 while (soff_hi != eoff_hi) { 261 #ifdef CONFIG_MTD_PMC551_DEBUG 262 printk(KERN_DEBUG "pmc551_read() soff_hi: %ld, " 263 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 264 #endif 265 memcpy(copyto, ptr, priv->asize); 266 copyto += priv->asize; 267 if (soff_hi + priv->asize >= mtd->size) { 268 goto out; 269 } 270 soff_hi += priv->asize; 271 pmc551_point(mtd, soff_hi, priv->asize, retlen, 272 (void **)&ptr, NULL); 273 } 274 memcpy(copyto, ptr, eoff_lo); 275 copyto += eoff_lo; 276 } 277 278 out: 279 #ifdef CONFIG_MTD_PMC551_DEBUG 280 printk(KERN_DEBUG "pmc551_read() done\n"); 281 #endif 282 *retlen = copyto - buf; 283 return 0; 284 } 285 286 static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len, 287 size_t * retlen, const u_char * buf) 288 { 289 struct mypriv *priv = mtd->priv; 290 u32 soff_hi, soff_lo; /* start address offset hi/lo */ 291 u32 eoff_hi, eoff_lo; /* end address offset hi/lo */ 292 unsigned long end; 293 u_char *ptr; 294 const u_char *copyfrom = buf; 295 296 #ifdef CONFIG_MTD_PMC551_DEBUG 297 printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ld\n", 298 (long)to, (long)len, (long)priv->asize); 299 #endif 300 301 end = to + len - 1; 302 /* Is it past the end? or did the u32 wrap? */ 303 if (end > mtd->size) { 304 #ifdef CONFIG_MTD_PMC551_DEBUG 305 printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, " 306 "size: %ld, to: %ld)\n", (long)end, (long)mtd->size, 307 (long)to); 308 #endif 309 return -EINVAL; 310 } 311 312 soff_hi = to & ~(priv->asize - 1); 313 eoff_hi = end & ~(priv->asize - 1); 314 soff_lo = to & (priv->asize - 1); 315 eoff_lo = end & (priv->asize - 1); 316 317 pmc551_point(mtd, to, len, retlen, (void **)&ptr, NULL); 318 319 if (soff_hi == eoff_hi) { 320 /* The whole thing fits within one access, so just one shot 321 will do it. */ 322 memcpy(ptr, copyfrom, len); 323 copyfrom += len; 324 } else { 325 /* We have to do multiple writes to get all the data 326 written. */ 327 while (soff_hi != eoff_hi) { 328 #ifdef CONFIG_MTD_PMC551_DEBUG 329 printk(KERN_DEBUG "pmc551_write() soff_hi: %ld, " 330 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi); 331 #endif 332 memcpy(ptr, copyfrom, priv->asize); 333 copyfrom += priv->asize; 334 if (soff_hi >= mtd->size) { 335 goto out; 336 } 337 soff_hi += priv->asize; 338 pmc551_point(mtd, soff_hi, priv->asize, retlen, 339 (void **)&ptr, NULL); 340 } 341 memcpy(ptr, copyfrom, eoff_lo); 342 copyfrom += eoff_lo; 343 } 344 345 out: 346 #ifdef CONFIG_MTD_PMC551_DEBUG 347 printk(KERN_DEBUG "pmc551_write() done\n"); 348 #endif 349 *retlen = copyfrom - buf; 350 return 0; 351 } 352 353 /* 354 * Fixup routines for the V370PDC 355 * PCI device ID 0x020011b0 356 * 357 * This function basicly kick starts the DRAM oboard the card and gets it 358 * ready to be used. Before this is done the device reads VERY erratic, so 359 * much that it can crash the Linux 2.2.x series kernels when a user cat's 360 * /proc/pci .. though that is mainly a kernel bug in handling the PCI DEVSEL 361 * register. FIXME: stop spinning on registers .. must implement a timeout 362 * mechanism 363 * returns the size of the memory region found. 364 */ 365 static u32 fixup_pmc551(struct pci_dev *dev) 366 { 367 #ifdef CONFIG_MTD_PMC551_BUGFIX 368 u32 dram_data; 369 #endif 370 u32 size, dcmd, cfg, dtmp; 371 u16 cmd, tmp, i; 372 u8 bcmd, counter; 373 374 /* Sanity Check */ 375 if (!dev) { 376 return -ENODEV; 377 } 378 379 /* 380 * Attempt to reset the card 381 * FIXME: Stop Spinning registers 382 */ 383 counter = 0; 384 /* unlock registers */ 385 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5); 386 /* read in old data */ 387 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd); 388 /* bang the reset line up and down for a few */ 389 for (i = 0; i < 10; i++) { 390 counter = 0; 391 bcmd &= ~0x80; 392 while (counter++ < 100) { 393 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 394 } 395 counter = 0; 396 bcmd |= 0x80; 397 while (counter++ < 100) { 398 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 399 } 400 } 401 bcmd |= (0x40 | 0x20); 402 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd); 403 404 /* 405 * Take care and turn off the memory on the device while we 406 * tweak the configurations 407 */ 408 pci_read_config_word(dev, PCI_COMMAND, &cmd); 409 tmp = cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY); 410 pci_write_config_word(dev, PCI_COMMAND, tmp); 411 412 /* 413 * Disable existing aperture before probing memory size 414 */ 415 pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd); 416 dtmp = (dcmd | PMC551_PCI_MEM_MAP_ENABLE | PMC551_PCI_MEM_MAP_REG_EN); 417 pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp); 418 /* 419 * Grab old BAR0 config so that we can figure out memory size 420 * This is another bit of kludge going on. The reason for the 421 * redundancy is I am hoping to retain the original configuration 422 * previously assigned to the card by the BIOS or some previous 423 * fixup routine in the kernel. So we read the old config into cfg, 424 * then write all 1's to the memory space, read back the result into 425 * "size", and then write back all the old config. 426 */ 427 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &cfg); 428 #ifndef CONFIG_MTD_PMC551_BUGFIX 429 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, ~0); 430 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &size); 431 size = (size & PCI_BASE_ADDRESS_MEM_MASK); 432 size &= ~(size - 1); 433 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, cfg); 434 #else 435 /* 436 * Get the size of the memory by reading all the DRAM size values 437 * and adding them up. 438 * 439 * KLUDGE ALERT: the boards we are using have invalid column and 440 * row mux values. We fix them here, but this will break other 441 * memory configurations. 442 */ 443 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data); 444 size = PMC551_DRAM_BLK_GET_SIZE(dram_data); 445 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 446 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 447 pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data); 448 449 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data); 450 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 451 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 452 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 453 pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data); 454 455 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data); 456 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 457 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 458 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 459 pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data); 460 461 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data); 462 size += PMC551_DRAM_BLK_GET_SIZE(dram_data); 463 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5); 464 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9); 465 pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data); 466 467 /* 468 * Oops .. something went wrong 469 */ 470 if ((size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) { 471 return -ENODEV; 472 } 473 #endif /* CONFIG_MTD_PMC551_BUGFIX */ 474 475 if ((cfg & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) { 476 return -ENODEV; 477 } 478 479 /* 480 * Precharge Dram 481 */ 482 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0400); 483 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x00bf); 484 485 /* 486 * Wait until command has gone through 487 * FIXME: register spinning issue 488 */ 489 do { 490 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 491 if (counter++ > 100) 492 break; 493 } while ((PCI_COMMAND_IO) & cmd); 494 495 /* 496 * Turn on auto refresh 497 * The loop is taken directly from Ramix's example code. I assume that 498 * this must be held high for some duration of time, but I can find no 499 * documentation refrencing the reasons why. 500 */ 501 for (i = 1; i <= 8; i++) { 502 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0df); 503 504 /* 505 * Make certain command has gone through 506 * FIXME: register spinning issue 507 */ 508 counter = 0; 509 do { 510 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 511 if (counter++ > 100) 512 break; 513 } while ((PCI_COMMAND_IO) & cmd); 514 } 515 516 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0020); 517 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0ff); 518 519 /* 520 * Wait until command completes 521 * FIXME: register spinning issue 522 */ 523 counter = 0; 524 do { 525 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd); 526 if (counter++ > 100) 527 break; 528 } while ((PCI_COMMAND_IO) & cmd); 529 530 pci_read_config_dword(dev, PMC551_DRAM_CFG, &dcmd); 531 dcmd |= 0x02000000; 532 pci_write_config_dword(dev, PMC551_DRAM_CFG, dcmd); 533 534 /* 535 * Check to make certain fast back-to-back, if not 536 * then set it so 537 */ 538 pci_read_config_word(dev, PCI_STATUS, &cmd); 539 if ((cmd & PCI_COMMAND_FAST_BACK) == 0) { 540 cmd |= PCI_COMMAND_FAST_BACK; 541 pci_write_config_word(dev, PCI_STATUS, cmd); 542 } 543 544 /* 545 * Check to make certain the DEVSEL is set correctly, this device 546 * has a tendancy to assert DEVSEL and TRDY when a write is performed 547 * to the memory when memory is read-only 548 */ 549 if ((cmd & PCI_STATUS_DEVSEL_MASK) != 0x0) { 550 cmd &= ~PCI_STATUS_DEVSEL_MASK; 551 pci_write_config_word(dev, PCI_STATUS, cmd); 552 } 553 /* 554 * Set to be prefetchable and put everything back based on old cfg. 555 * it's possible that the reset of the V370PDC nuked the original 556 * setup 557 */ 558 /* 559 cfg |= PCI_BASE_ADDRESS_MEM_PREFETCH; 560 pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg ); 561 */ 562 563 /* 564 * Turn PCI memory and I/O bus access back on 565 */ 566 pci_write_config_word(dev, PCI_COMMAND, 567 PCI_COMMAND_MEMORY | PCI_COMMAND_IO); 568 #ifdef CONFIG_MTD_PMC551_DEBUG 569 /* 570 * Some screen fun 571 */ 572 printk(KERN_DEBUG "pmc551: %d%sB (0x%x) of %sprefetchable memory at " 573 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ? 574 size >> 10 : size >> 20, 575 (size < 1024) ? "" : (size < 1048576) ? "Ki" : "Mi", size, 576 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "", 577 (unsigned long long)pci_resource_start(dev, 0)); 578 579 /* 580 * Check to see the state of the memory 581 */ 582 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dcmd); 583 printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%s\n" 584 "pmc551: DRAM_BLK0 Size: %d at %d\n" 585 "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %d\n", 586 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 587 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 588 PMC551_DRAM_BLK_GET_SIZE(dcmd), 589 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 590 ((dcmd >> 9) & 0xF)); 591 592 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dcmd); 593 printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%s\n" 594 "pmc551: DRAM_BLK1 Size: %d at %d\n" 595 "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %d\n", 596 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 597 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 598 PMC551_DRAM_BLK_GET_SIZE(dcmd), 599 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 600 ((dcmd >> 9) & 0xF)); 601 602 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dcmd); 603 printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%s\n" 604 "pmc551: DRAM_BLK2 Size: %d at %d\n" 605 "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %d\n", 606 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 607 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 608 PMC551_DRAM_BLK_GET_SIZE(dcmd), 609 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 610 ((dcmd >> 9) & 0xF)); 611 612 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dcmd); 613 printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%s\n" 614 "pmc551: DRAM_BLK3 Size: %d at %d\n" 615 "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %d\n", 616 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO", 617 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On", 618 PMC551_DRAM_BLK_GET_SIZE(dcmd), 619 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7), 620 ((dcmd >> 9) & 0xF)); 621 622 pci_read_config_word(dev, PCI_COMMAND, &cmd); 623 printk(KERN_DEBUG "pmc551: Memory Access %s\n", 624 (((0x1 << 1) & cmd) == 0) ? "off" : "on"); 625 printk(KERN_DEBUG "pmc551: I/O Access %s\n", 626 (((0x1 << 0) & cmd) == 0) ? "off" : "on"); 627 628 pci_read_config_word(dev, PCI_STATUS, &cmd); 629 printk(KERN_DEBUG "pmc551: Devsel %s\n", 630 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x000) ? "Fast" : 631 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x200) ? "Medium" : 632 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x400) ? "Slow" : "Invalid"); 633 634 printk(KERN_DEBUG "pmc551: %sFast Back-to-Back\n", 635 ((PCI_COMMAND_FAST_BACK & cmd) == 0) ? "Not " : ""); 636 637 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd); 638 printk(KERN_DEBUG "pmc551: EEPROM is under %s control\n" 639 "pmc551: System Control Register is %slocked to PCI access\n" 640 "pmc551: System Control Register is %slocked to EEPROM access\n", 641 (bcmd & 0x1) ? "software" : "hardware", 642 (bcmd & 0x20) ? "" : "un", (bcmd & 0x40) ? "" : "un"); 643 #endif 644 return size; 645 } 646 647 /* 648 * Kernel version specific module stuffages 649 */ 650 651 MODULE_LICENSE("GPL"); 652 MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>"); 653 MODULE_DESCRIPTION(PMC551_VERSION); 654 655 /* 656 * Stuff these outside the ifdef so as to not bust compiled in driver support 657 */ 658 static int msize = 0; 659 static int asize = 0; 660 661 module_param(msize, int, 0); 662 MODULE_PARM_DESC(msize, "memory size in MiB [1 - 1024]"); 663 module_param(asize, int, 0); 664 MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]"); 665 666 /* 667 * PMC551 Card Initialization 668 */ 669 static int __init init_pmc551(void) 670 { 671 struct pci_dev *PCI_Device = NULL; 672 struct mypriv *priv; 673 int count, found = 0; 674 struct mtd_info *mtd; 675 u32 length = 0; 676 677 if (msize) { 678 msize = (1 << (ffs(msize) - 1)) << 20; 679 if (msize > (1 << 30)) { 680 printk(KERN_NOTICE "pmc551: Invalid memory size [%d]\n", 681 msize); 682 return -EINVAL; 683 } 684 } 685 686 if (asize) { 687 asize = (1 << (ffs(asize) - 1)) << 20; 688 if (asize > (1 << 30)) { 689 printk(KERN_NOTICE "pmc551: Invalid aperture size " 690 "[%d]\n", asize); 691 return -EINVAL; 692 } 693 } 694 695 printk(KERN_INFO PMC551_VERSION); 696 697 /* 698 * PCU-bus chipset probe. 699 */ 700 for (count = 0; count < MAX_MTD_DEVICES; count++) { 701 702 if ((PCI_Device = pci_get_device(PCI_VENDOR_ID_V3_SEMI, 703 PCI_DEVICE_ID_V3_SEMI_V370PDC, 704 PCI_Device)) == NULL) { 705 break; 706 } 707 708 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n", 709 (unsigned long long)pci_resource_start(PCI_Device, 0)); 710 711 /* 712 * The PMC551 device acts VERY weird if you don't init it 713 * first. i.e. it will not correctly report devsel. If for 714 * some reason the sdram is in a wrote-protected state the 715 * device will DEVSEL when it is written to causing problems 716 * with the oldproc.c driver in 717 * some kernels (2.2.*) 718 */ 719 if ((length = fixup_pmc551(PCI_Device)) <= 0) { 720 printk(KERN_NOTICE "pmc551: Cannot init SDRAM\n"); 721 break; 722 } 723 724 /* 725 * This is needed until the driver is capable of reading the 726 * onboard I2C SROM to discover the "real" memory size. 727 */ 728 if (msize) { 729 length = msize; 730 printk(KERN_NOTICE "pmc551: Using specified memory " 731 "size 0x%x\n", length); 732 } else { 733 msize = length; 734 } 735 736 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); 737 if (!mtd) { 738 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD " 739 "device.\n"); 740 break; 741 } 742 743 priv = kzalloc(sizeof(struct mypriv), GFP_KERNEL); 744 if (!priv) { 745 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD " 746 "device.\n"); 747 kfree(mtd); 748 break; 749 } 750 mtd->priv = priv; 751 priv->dev = PCI_Device; 752 753 if (asize > length) { 754 printk(KERN_NOTICE "pmc551: reducing aperture size to " 755 "fit %dM\n", length >> 20); 756 priv->asize = asize = length; 757 } else if (asize == 0 || asize == length) { 758 printk(KERN_NOTICE "pmc551: Using existing aperture " 759 "size %dM\n", length >> 20); 760 priv->asize = asize = length; 761 } else { 762 printk(KERN_NOTICE "pmc551: Using specified aperture " 763 "size %dM\n", asize >> 20); 764 priv->asize = asize; 765 } 766 priv->start = pci_iomap(PCI_Device, 0, priv->asize); 767 768 if (!priv->start) { 769 printk(KERN_NOTICE "pmc551: Unable to map IO space\n"); 770 kfree(mtd->priv); 771 kfree(mtd); 772 break; 773 } 774 #ifdef CONFIG_MTD_PMC551_DEBUG 775 printk(KERN_DEBUG "pmc551: setting aperture to %d\n", 776 ffs(priv->asize >> 20) - 1); 777 #endif 778 779 priv->base_map0 = (PMC551_PCI_MEM_MAP_REG_EN 780 | PMC551_PCI_MEM_MAP_ENABLE 781 | (ffs(priv->asize >> 20) - 1) << 4); 782 priv->curr_map0 = priv->base_map0; 783 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0, 784 priv->curr_map0); 785 786 #ifdef CONFIG_MTD_PMC551_DEBUG 787 printk(KERN_DEBUG "pmc551: aperture set to %d\n", 788 (priv->base_map0 & 0xF0) >> 4); 789 #endif 790 791 mtd->size = msize; 792 mtd->flags = MTD_CAP_RAM; 793 mtd->erase = pmc551_erase; 794 mtd->read = pmc551_read; 795 mtd->write = pmc551_write; 796 mtd->point = pmc551_point; 797 mtd->unpoint = pmc551_unpoint; 798 mtd->type = MTD_RAM; 799 mtd->name = "PMC551 RAM board"; 800 mtd->erasesize = 0x10000; 801 mtd->writesize = 1; 802 mtd->owner = THIS_MODULE; 803 804 if (add_mtd_device(mtd)) { 805 printk(KERN_NOTICE "pmc551: Failed to register new device\n"); 806 pci_iounmap(PCI_Device, priv->start); 807 kfree(mtd->priv); 808 kfree(mtd); 809 break; 810 } 811 812 /* Keep a reference as the add_mtd_device worked */ 813 pci_dev_get(PCI_Device); 814 815 printk(KERN_NOTICE "Registered pmc551 memory device.\n"); 816 printk(KERN_NOTICE "Mapped %dMiB of memory from 0x%p to 0x%p\n", 817 priv->asize >> 20, 818 priv->start, priv->start + priv->asize); 819 printk(KERN_NOTICE "Total memory is %d%sB\n", 820 (length < 1024) ? length : 821 (length < 1048576) ? length >> 10 : length >> 20, 822 (length < 1024) ? "" : (length < 1048576) ? "Ki" : "Mi"); 823 priv->nextpmc551 = pmc551list; 824 pmc551list = mtd; 825 found++; 826 } 827 828 /* Exited early, reference left over */ 829 if (PCI_Device) 830 pci_dev_put(PCI_Device); 831 832 if (!pmc551list) { 833 printk(KERN_NOTICE "pmc551: not detected\n"); 834 return -ENODEV; 835 } else { 836 printk(KERN_NOTICE "pmc551: %d pmc551 devices loaded\n", found); 837 return 0; 838 } 839 } 840 841 /* 842 * PMC551 Card Cleanup 843 */ 844 static void __exit cleanup_pmc551(void) 845 { 846 int found = 0; 847 struct mtd_info *mtd; 848 struct mypriv *priv; 849 850 while ((mtd = pmc551list)) { 851 priv = mtd->priv; 852 pmc551list = priv->nextpmc551; 853 854 if (priv->start) { 855 printk(KERN_DEBUG "pmc551: unmapping %dMiB starting at " 856 "0x%p\n", priv->asize >> 20, priv->start); 857 pci_iounmap(priv->dev, priv->start); 858 } 859 pci_dev_put(priv->dev); 860 861 kfree(mtd->priv); 862 del_mtd_device(mtd); 863 kfree(mtd); 864 found++; 865 } 866 867 printk(KERN_NOTICE "pmc551: %d pmc551 devices unloaded\n", found); 868 } 869 870 module_init(init_pmc551); 871 module_exit(cleanup_pmc551); 872