开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pmc551.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：29k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pmc551.c：源码内容
  1. /*
  2.  * $Id: pmc551.c,v 1.20 2002/03/05 13:47:08 dwmw2 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.  */
  85. #include <linux/config.h>
  86. #include <linux/kernel.h>
  87. #include <linux/module.h>
  88. #include <asm/uaccess.h>
  89. #include <linux/types.h>
  90. #include <linux/sched.h>
  91. #include <linux/init.h>
  92. #include <linux/ptrace.h>
  93. #include <linux/slab.h>
  94. #include <linux/string.h>
  95. #include <linux/timer.h>
  96. #include <linux/major.h>
  97. #include <linux/fs.h>
  98. #include <linux/ioctl.h>
  99. #include <asm/io.h>
  100. #include <asm/system.h>
  101. #include <asm/segment.h>
  102. #include <stdarg.h>
  103. #include <linux/pci.h>
  105. #ifndef CONFIG_PCI
  106. #error Enable PCI in your kernel config
  107. #endif
  109. #include <linux/mtd/mtd.h>
  110. #include <linux/mtd/pmc551.h>
  111. #include <linux/mtd/compatmac.h>
  113. #if LINUX_VERSION_CODE > 0x20300
  114. #define PCI_BASE_ADDRESS(dev) (dev->resource[0].start)
  115. #else
  116. #define PCI_BASE_ADDRESS(dev) (dev->base_address[0])
  117. #endif
  119. static struct mtd_info *pmc551list;
  121. static int pmc551_erase (struct mtd_info *mtd, struct erase_info *instr)
  122. {
  123.         struct mypriv *priv = (struct mypriv *)mtd->priv;
  124.         u32 soff_hi, soff_lo; /* start address offset hi/lo */
  125.         u32 eoff_hi, eoff_lo; /* end address offset hi/lo */
  126.         unsigned long end;
  127. u_char *ptr;
  128. size_t retlen;
  130. #ifdef CONFIG_MTD_PMC551_DEBUG
  131. printk(KERN_DEBUG "pmc551_erase(pos:%ld, len:%ld)n", (long)instr->addr, (long)instr->len);
  132. #endif
  134.         end = instr->addr + instr->len - 1;
  136.         /* Is it past the end? */
  137.         if ( end > mtd->size ) {
  138. #ifdef CONFIG_MTD_PMC551_DEBUG
  139. printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)n", (long)end, (long)mtd->size);
  140. #endif
  141.                 return -EINVAL;
  142.         }
  144.         eoff_hi = end & ~(priv->asize - 1);
  145.         soff_hi = instr->addr & ~(priv->asize - 1);
  146.         eoff_lo = end & (priv->asize - 1);
  147.         soff_lo = instr->addr & (priv->asize - 1);
  149. pmc551_point (mtd, instr->addr, instr->len, &retlen, &ptr);
  151.         if ( soff_hi == eoff_hi || mtd->size == priv->asize) {
  152.                 /* The whole thing fits within one access, so just one shot
  153.                    will do it. */
  154.                 memset(ptr, 0xff, instr->len);
  155.         } else {
  156.                 /* We have to do multiple writes to get all the data
  157.                    written. */
  158.                 while (soff_hi != eoff_hi) {
  159. #ifdef CONFIG_MTD_PMC551_DEBUG
  160. printk( KERN_DEBUG "pmc551_erase() soff_hi: %ld, eoff_hi: %ldn", (long)soff_hi, (long)eoff_hi);
  161. #endif
  162.                         memset(ptr, 0xff, priv->asize);
  163.                         if (soff_hi + priv->asize >= mtd->size) {
  164.                                 goto out;
  165.                         }
  166.                         soff_hi += priv->asize;
  167. pmc551_point (mtd,(priv->base_map0|soff_hi),
  168.       priv->asize, &retlen, &ptr);
  169.                 }
  170.                 memset (ptr, 0xff, eoff_lo);
  171.         }
  173. out:
  174. instr->state = MTD_ERASE_DONE;
  175. #ifdef CONFIG_MTD_PMC551_DEBUG
  176. printk(KERN_DEBUG "pmc551_erase() donen");
  177. #endif
  179.         if (instr->callback) {
  180.                 (*(instr->callback))(instr);
  181. }
  182.         return 0;
  183. }
  186. static int pmc551_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf)
  187. {
  188.         struct mypriv *priv = (struct mypriv *)mtd->priv;
  189.         u32 soff_hi;
  190.         u32 soff_lo;
  192. #ifdef CONFIG_MTD_PMC551_DEBUG
  193. printk(KERN_DEBUG "pmc551_point(%ld, %ld)n", (long)from, (long)len);
  194. #endif
  196. if (from + len > mtd->size) {
  197. #ifdef CONFIG_MTD_PMC551_DEBUG
  198. printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)n", (long)from+len, (long)mtd->size);
  199. #endif
  200. return -EINVAL;
  201. }
  203.         soff_hi = from & ~(priv->asize - 1);
  204.         soff_lo = from & (priv->asize - 1);
  206. /* Cheap hack optimization */
  207. if( priv->curr_map0 != from ) {
  208.          pci_write_config_dword ( priv->dev, PMC551_PCI_MEM_MAP0,
  209.                                   (priv->base_map0 | soff_hi) );
  210. priv->curr_map0 = soff_hi;
  211. }
  213. *mtdbuf = priv->start + soff_lo;
  214. *retlen = len;
  215. return 0;
  216. }
  219. static void pmc551_unpoint (struct mtd_info *mtd, u_char *addr)
  220. {
  221. #ifdef CONFIG_MTD_PMC551_DEBUG
  222. printk(KERN_DEBUG "pmc551_unpoint()n");
  223. #endif
  224. }
  227. static int pmc551_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
  228. {
  229.         struct mypriv *priv = (struct mypriv *)mtd->priv;
  230.         u32 soff_hi, soff_lo; /* start address offset hi/lo */
  231.         u32 eoff_hi, eoff_lo; /* end address offset hi/lo */
  232.         unsigned long end;
  233. u_char *ptr;
  234.         u_char *copyto = buf;
  236. #ifdef CONFIG_MTD_PMC551_DEBUG
  237. printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ldn", (long)from, (long)len, (long)priv->asize);
  238. #endif
  240.         end = from + len - 1;
  242.         /* Is it past the end? */
  243.         if (end > mtd->size) {
  244. #ifdef CONFIG_MTD_PMC551_DEBUG
  245. printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)n", (long) end, (long)mtd->size);
  246. #endif
  247.                 return -EINVAL;
  248.         }
  250.         soff_hi = from & ~(priv->asize - 1);
  251.         eoff_hi = end & ~(priv->asize - 1);
  252.         soff_lo = from & (priv->asize - 1);
  253.         eoff_lo = end & (priv->asize - 1);
  255. pmc551_point (mtd, from, len, retlen, &ptr);
  257.         if (soff_hi == eoff_hi) {
  258.                 /* The whole thing fits within one access, so just one shot
  259.                    will do it. */
  260.                 memcpy(copyto, ptr, len);
  261.                 copyto += len;
  262.         } else {
  263.                 /* We have to do multiple writes to get all the data
  264.                    written. */
  265.                 while (soff_hi != eoff_hi) {
  266. #ifdef CONFIG_MTD_PMC551_DEBUG
  267. printk( KERN_DEBUG "pmc551_read() soff_hi: %ld, eoff_hi: %ldn", (long)soff_hi, (long)eoff_hi);
  268. #endif
  269.                         memcpy(copyto, ptr, priv->asize);
  270.                         copyto += priv->asize;
  271.                         if (soff_hi + priv->asize >= mtd->size) {
  272.                                 goto out;
  273.                         }
  274.                         soff_hi += priv->asize;
  275. pmc551_point (mtd, soff_hi, priv->asize, retlen, &ptr);
  276.                 }
  277.                 memcpy(copyto, ptr, eoff_lo);
  278.                 copyto += eoff_lo;
  279.         }
  281. out:
  282. #ifdef CONFIG_MTD_PMC551_DEBUG
  283. printk(KERN_DEBUG "pmc551_read() donen");
  284. #endif
  285.         *retlen = copyto - buf;
  286.         return 0;
  287. }
  289. static int pmc551_write (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
  290. {
  291.         struct mypriv *priv = (struct mypriv *)mtd->priv;
  292.         u32 soff_hi, soff_lo; /* start address offset hi/lo */
  293.         u32 eoff_hi, eoff_lo; /* end address offset hi/lo */
  294.         unsigned long end;
  295. u_char *ptr;
  296.         const u_char *copyfrom = buf;
  299. #ifdef CONFIG_MTD_PMC551_DEBUG
  300. printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ldn", (long)to, (long)len, (long)priv->asize);
  301. #endif
  303.         end = to + len - 1;
  304.         /* Is it past the end?  or did the u32 wrap? */
  305.         if (end > mtd->size ) {
  306. #ifdef CONFIG_MTD_PMC551_DEBUG
  307. printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, size: %ld, to: %ld)n", (long) end, (long)mtd->size, (long)to);
  308. #endif
  309.                 return -EINVAL;
  310.         }
  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);
  317. pmc551_point (mtd, to, len, retlen, &ptr);
  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, eoff_hi: %ldn", (long)soff_hi, (long)eoff_hi);
  330. #endif
  331.                  memcpy(ptr, copyfrom, priv->asize);
  332.                  copyfrom += priv->asize;
  333.                         if (soff_hi >= mtd->size) {
  334.                                 goto out;
  335.                         }
  336.                         soff_hi += priv->asize;
  337. pmc551_point (mtd, soff_hi, priv->asize, retlen, &ptr);
  338.                 }
  339.                 memcpy(ptr, copyfrom, eoff_lo);
  340.                 copyfrom += eoff_lo;
  341.         }
  343. out:
  344. #ifdef CONFIG_MTD_PMC551_DEBUG
  345. printk(KERN_DEBUG "pmc551_write() donen");
  346. #endif
  347.         *retlen = copyfrom - buf;
  348.         return 0;
  349. }
  351. /*
  352.  * Fixup routines for the V370PDC
  353.  * PCI device ID 0x020011b0
  354.  *
  355.  * This function basicly kick starts the DRAM oboard the card and gets it
  356.  * ready to be used.  Before this is done the device reads VERY erratic, so
  357.  * much that it can crash the Linux 2.2.x series kernels when a user cat's
  358.  * /proc/pci .. though that is mainly a kernel bug in handling the PCI DEVSEL
  359.  * register.  FIXME: stop spinning on registers .. must implement a timeout
  360.  * mechanism
  361.  * returns the size of the memory region found.
  362.  */
  363. static u32 fixup_pmc551 (struct pci_dev *dev)
  364. {
  365. #ifdef CONFIG_MTD_PMC551_BUGFIX
  366.         u32 dram_data;
  367. #endif
  368.         u32 size, dcmd, cfg, dtmp;
  369.         u16 cmd, tmp, i;
  370. u8 bcmd, counter;
  372.         /* Sanity Check */
  373.         if(!dev) {
  374.                 return -ENODEV;
  375.         }
  377. /*
  378.  * Attempt to reset the card
  379.  * FIXME: Stop Spinning registers
  380.  */
  381. counter=0;
  382. /* unlock registers */
  383. pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5 );
  384. /* read in old data */
  385. pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd );
  386. /* bang the reset line up and down for a few */
  387. for(i=0;i<10;i++) {
  388. counter=0;
  389. bcmd &= ~0x80;
  390. while(counter++ < 100) {
  391. pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
  392. }
  393. counter=0;
  394. bcmd |= 0x80;
  395. while(counter++ < 100) {
  396. pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
  397. }
  398. }
  399. bcmd |= (0x40|0x20);
  400. pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
  402.         /* 
  403.  * Take care and turn off the memory on the device while we
  404.  * tweak the configurations
  405.  */
  406.         pci_read_config_word(dev, PCI_COMMAND, &cmd);
  407.         tmp = cmd & ~(PCI_COMMAND_IO|PCI_COMMAND_MEMORY);
  408.         pci_write_config_word(dev, PCI_COMMAND, tmp);
  410. /*
  411.  * Disable existing aperture before probing memory size
  412.  */
  413. pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd);
  414.         dtmp=(dcmd|PMC551_PCI_MEM_MAP_ENABLE|PMC551_PCI_MEM_MAP_REG_EN);
  415. pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp);
  416. /*
  417.  * Grab old BAR0 config so that we can figure out memory size
  418.  * This is another bit of kludge going on.  The reason for the
  419.  * redundancy is I am hoping to retain the original configuration
  420.  * previously assigned to the card by the BIOS or some previous 
  421.  * fixup routine in the kernel.  So we read the old config into cfg,
  422.  * then write all 1's to the memory space, read back the result into
  423.  * "size", and then write back all the old config.
  424.  */
  425. pci_read_config_dword( dev, PCI_BASE_ADDRESS_0, &cfg );
  426. #ifndef CONFIG_MTD_PMC551_BUGFIX
  427. pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, ~0 );
  428. pci_read_config_dword( dev, PCI_BASE_ADDRESS_0, &size );
  429. size = (size&PCI_BASE_ADDRESS_MEM_MASK);
  430. size &= ~(size-1);
  431. pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg );
  432. #else
  433.         /*
  434.          * Get the size of the memory by reading all the DRAM size values
  435.          * and adding them up.
  436.          *
  437.          * KLUDGE ALERT: the boards we are using have invalid column and
  438.          * row mux values.  We fix them here, but this will break other
  439.          * memory configurations.
  440.          */
  441.         pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data);
  442.         size = PMC551_DRAM_BLK_GET_SIZE(dram_data);
  443.         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
  444.         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
  445.         pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data);
  447.         pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data);
  448.         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
  449.         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
  450.         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
  451.         pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data);
  453.         pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data);
  454.         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
  455.         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
  456.         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
  457.         pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data);
  459.         pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data);
  460.         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
  461.         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
  462.         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
  463.         pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data);
  465.         /*
  466.          * Oops .. something went wrong
  467.          */
  468.         if( (size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) {
  469.                 return -ENODEV;
  470.         }
  471. #endif /* CONFIG_MTD_PMC551_BUGFIX */
  473. if ((cfg&PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
  474.                 return -ENODEV;
  475. }
  477.         /*
  478.          * Precharge Dram
  479.          */
  480.         pci_write_config_word( dev, PMC551_SDRAM_MA, 0x0400 );
  481.         pci_write_config_word( dev, PMC551_SDRAM_CMD, 0x00bf );
  483.         /*
  484.          * Wait until command has gone through
  485.          * FIXME: register spinning issue
  486.          */
  487.         do { pci_read_config_word( dev, PMC551_SDRAM_CMD, &cmd );
  488. if(counter++ > 100)break;
  489.         } while ( (PCI_COMMAND_IO) & cmd );
  491.         /*
  492.  * Turn on auto refresh 
  493.  * The loop is taken directly from Ramix's example code.  I assume that
  494.  * this must be held high for some duration of time, but I can find no
  495.  * documentation refrencing the reasons why.
  496.          */
  497.         for ( i = 1; i<=8 ; i++) {
  498.                 pci_write_config_word (dev, PMC551_SDRAM_CMD, 0x0df);
  500.                 /*
  501.                  * Make certain command has gone through
  502.                  * FIXME: register spinning issue
  503.                  */
  504. counter=0;
  505.                 do { pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
  506. if(counter++ > 100)break;
  507.                 } while ( (PCI_COMMAND_IO) & cmd );
  508.         }
  510.         pci_write_config_word ( dev, PMC551_SDRAM_MA, 0x0020);
  511.         pci_write_config_word ( dev, PMC551_SDRAM_CMD, 0x0ff);
  513.         /*
  514.          * Wait until command completes
  515.          * FIXME: register spinning issue
  516.          */
  517. counter=0;
  518.         do { pci_read_config_word ( dev, PMC551_SDRAM_CMD, &cmd);
  519. if(counter++ > 100)break;
  520.         } while ( (PCI_COMMAND_IO) & cmd );
  522.         pci_read_config_dword ( dev, PMC551_DRAM_CFG, &dcmd);
  523.         dcmd |= 0x02000000;
  524.         pci_write_config_dword ( dev, PMC551_DRAM_CFG, dcmd);
  526.         /*
  527.          * Check to make certain fast back-to-back, if not
  528.          * then set it so
  529.          */
  530.         pci_read_config_word( dev, PCI_STATUS, &cmd);
  531.         if((cmd&PCI_COMMAND_FAST_BACK) == 0) {
  532.                 cmd |= PCI_COMMAND_FAST_BACK;
  533.                 pci_write_config_word( dev, PCI_STATUS, cmd);
  534.         }
  536.         /*
  537.          * Check to make certain the DEVSEL is set correctly, this device
  538.          * has a tendancy to assert DEVSEL and TRDY when a write is performed
  539.          * to the memory when memory is read-only
  540.          */
  541.         if((cmd&PCI_STATUS_DEVSEL_MASK) != 0x0) {
  542.                 cmd &= ~PCI_STATUS_DEVSEL_MASK;
  543.                 pci_write_config_word( dev, PCI_STATUS, cmd );
  544.         }
  545.         /*
  546.          * Set to be prefetchable and put everything back based on old cfg.
  547.  * it's possible that the reset of the V370PDC nuked the original
  548.  * setup
  549.          */
  550. /*
  551.         cfg |= PCI_BASE_ADDRESS_MEM_PREFETCH;
  552. pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg );
  553. */
  555.         /*
  556.          * Turn PCI memory and I/O bus access back on
  557.          */
  558.         pci_write_config_word( dev, PCI_COMMAND,
  559.                                PCI_COMMAND_MEMORY | PCI_COMMAND_IO );
  560. #ifdef CONFIG_MTD_PMC551_DEBUG
  561.         /*
  562.          * Some screen fun
  563.          */
  564.         printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at 0x%lxn",
  565.        (size<1024)?size:(size<1048576)?size>>10:size>>20,
  566.                (size<1024)?'B':(size<1048576)?'K':'M',
  567.        size, ((dcmd&(0x1<<3)) == 0)?"non-":"",
  568.                PCI_BASE_ADDRESS(dev)&PCI_BASE_ADDRESS_MEM_MASK );
  570.         /*
  571.          * Check to see the state of the memory
  572.          */
  573.         pci_read_config_dword( dev, PMC551_DRAM_BLK0, &dcmd );
  574.         printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%sn"
  575.   "pmc551: DRAM_BLK0 Size: %d at %dn"
  576.   "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %dn",
  577.                (((0x1<<1)&dcmd) == 0)?"RW":"RO",
  578.                (((0x1<<0)&dcmd) == 0)?"Off":"On",
  579.        PMC551_DRAM_BLK_GET_SIZE(dcmd),
  580.        ((dcmd>>20)&0x7FF), ((dcmd>>13)&0x7), ((dcmd>>9)&0xF) );
  582.         pci_read_config_dword( dev, PMC551_DRAM_BLK1, &dcmd );
  583.         printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%sn"
  584.   "pmc551: DRAM_BLK1 Size: %d at %dn"
  585.   "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %dn",
  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), ((dcmd>>9)&0xF) );
  591.         pci_read_config_dword( dev, PMC551_DRAM_BLK2, &dcmd );
  592.         printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%sn"
  593.   "pmc551: DRAM_BLK2 Size: %d at %dn"
  594.   "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %dn",
  595.                (((0x1<<1)&dcmd) == 0)?"RW":"RO",
  596.                (((0x1<<0)&dcmd) == 0)?"Off":"On",
  597.        PMC551_DRAM_BLK_GET_SIZE(dcmd),
  598.        ((dcmd>>20)&0x7FF), ((dcmd>>13)&0x7), ((dcmd>>9)&0xF) );
  600.         pci_read_config_dword( dev, PMC551_DRAM_BLK3, &dcmd );
  601.         printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%sn"
  602.   "pmc551: DRAM_BLK3 Size: %d at %dn"
  603.   "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %dn",
  604.                (((0x1<<1)&dcmd) == 0)?"RW":"RO",
  605.                (((0x1<<0)&dcmd) == 0)?"Off":"On",
  606.        PMC551_DRAM_BLK_GET_SIZE(dcmd),
  607.        ((dcmd>>20)&0x7FF), ((dcmd>>13)&0x7), ((dcmd>>9)&0xF) );
  609.         pci_read_config_word( dev, PCI_COMMAND, &cmd );
  610.         printk( KERN_DEBUG "pmc551: Memory Access %sn",
  611.                 (((0x1<<1)&cmd) == 0)?"off":"on" );
  612.         printk( KERN_DEBUG "pmc551: I/O Access %sn",
  613.                 (((0x1<<0)&cmd) == 0)?"off":"on" );
  615.         pci_read_config_word( dev, PCI_STATUS, &cmd );
  616.         printk( KERN_DEBUG "pmc551: Devsel %sn",
  617.                 ((PCI_STATUS_DEVSEL_MASK&cmd)==0x000)?"Fast":
  618.                 ((PCI_STATUS_DEVSEL_MASK&cmd)==0x200)?"Medium":
  619.                 ((PCI_STATUS_DEVSEL_MASK&cmd)==0x400)?"Slow":"Invalid" );
  621.         printk( KERN_DEBUG "pmc551: %sFast Back-to-Backn",
  622.                 ((PCI_COMMAND_FAST_BACK&cmd) == 0)?"Not ":"" );
  624. pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd );
  625. printk( KERN_DEBUG "pmc551: EEPROM is under %s controln"
  626.    "pmc551: System Control Register is %slocked to PCI accessn"
  627.    "pmc551: System Control Register is %slocked to EEPROM accessn", 
  628. (bcmd&0x1)?"software":"hardware",
  629. (bcmd&0x20)?"":"un", (bcmd&0x40)?"":"un");
  630. #endif
  631.         return size;
  632. }
  634. /*
  635.  * Kernel version specific module stuffages
  636.  */
  639. MODULE_LICENSE("GPL");
  640. MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>");
  641. MODULE_DESCRIPTION(PMC551_VERSION);
  642. MODULE_PARM(msize, "i");
  643. MODULE_PARM_DESC(msize, "memory size in Megabytes [1 - 1024]");
  644. MODULE_PARM(asize, "i");
  645. MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
  647. /*
  648.  * Stuff these outside the ifdef so as to not bust compiled in driver support
  649.  */
  650. static int msize=0;
  651. #if defined(CONFIG_MTD_PMC551_APERTURE_SIZE)
  652. static int asize=CONFIG_MTD_PMC551_APERTURE_SIZE
  653. #else
  654. static int asize=0;
  655. #endif
  657. /*
  658.  * PMC551 Card Initialization
  659.  */
  660. int __init init_pmc551(void)
  661. {
  662.         struct pci_dev *PCI_Device = NULL;
  663.         struct mypriv *priv;
  664.         int count, found=0;
  665.         struct mtd_info *mtd;
  666.         u32 length = 0;
  668. if(msize) {
  669. msize = (1 << (ffs(msize) - 1))<<20;
  670. if (msize > (1<<30)) {
  671. printk(KERN_NOTICE "pmc551: Invalid memory size [%d]n", msize);
  672. return -EINVAL;
  673. }
  674. }
  676. if(asize) {
  677. asize = (1 << (ffs(asize) - 1))<<20;
  678. if (asize > (1<<30) ) {
  679. printk(KERN_NOTICE "pmc551: Invalid aperture size [%d]n", asize);
  680. return -EINVAL;
  681. }
  682. }
  684.         printk(KERN_INFO PMC551_VERSION);
  686.         if(!pci_present()) {
  687.                 printk(KERN_NOTICE "pmc551: PCI not enabled.n");
  688.                 return -ENODEV;
  689.         }
  691.         /*
  692.          * PCU-bus chipset probe.
  693.          */
  694.         for( count = 0; count < MAX_MTD_DEVICES; count++ ) {
  696.                 if ((PCI_Device = pci_find_device(PCI_VENDOR_ID_V3_SEMI,
  697.                                                   PCI_DEVICE_ID_V3_SEMI_V370PDC,
  698.   PCI_Device ) ) == NULL) {
  699.                         break;
  700.                 }
  702.                 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%lXn",
  703.     PCI_BASE_ADDRESS(PCI_Device));
  705.                 /*
  706.                  * The PMC551 device acts VERY weird if you don't init it
  707.                  * first.  i.e. it will not correctly report devsel.  If for
  708.                  * some reason the sdram is in a wrote-protected state the
  709.                  * device will DEVSEL when it is written to causing problems
  710.                  * with the oldproc.c driver in
  711.                  * some kernels (2.2.*)
  712.                  */
  713.                 if((length = fixup_pmc551(PCI_Device)) <= 0) {
  714.                         printk(KERN_NOTICE "pmc551: Cannot init SDRAMn");
  715.                         break;
  716.                 }
  718. /*
  719.  * This is needed until the driver is capable of reading the
  720.  * onboard I2C SROM to discover the "real" memory size.
  721.  */
  722. if(msize) {
  723. length = msize;
  724. printk(KERN_NOTICE "pmc551: Using specified memory size 0x%xn", length);
  725. } else {
  726. msize = length;
  727. }
  729.                 mtd = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
  730.                 if (!mtd) {
  731.                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD device.n");
  732.                         break;
  733.                 }
  735.                 memset(mtd, 0, sizeof(struct mtd_info));
  737.                 priv = kmalloc (sizeof(struct mypriv), GFP_KERNEL);
  738.                 if (!priv) {
  739.                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD device.n");
  740.                         kfree(mtd);
  741.                         break;
  742.                 }
  743.                 memset(priv, 0, sizeof(*priv));
  744.                 mtd->priv = priv;
  745.                 priv->dev = PCI_Device;
  747. if(asize > length) {
  748. printk(KERN_NOTICE "pmc551: reducing aperture size to fit %dMn",length>>20);
  749. priv->asize = asize = length;
  750. } else if (asize == 0 || asize == length) {
  751. printk(KERN_NOTICE "pmc551: Using existing aperture size %dMn", length>>20);
  752. priv->asize = asize = length;
  753. } else {
  754. printk(KERN_NOTICE "pmc551: Using specified aperture size %dMn", asize>>20);
  755. priv->asize = asize;
  756. }
  757.                 priv->start = ioremap((PCI_BASE_ADDRESS(PCI_Device)
  758.                                        & PCI_BASE_ADDRESS_MEM_MASK),
  759.                                       priv->asize);
  761. if (!priv->start) {
  762. printk(KERN_NOTICE "pmc551: Unable to map IO spacen");
  763.                         kfree(mtd->priv);
  764.                         kfree(mtd);
  765. break;
  766. }
  768. #ifdef CONFIG_MTD_PMC551_DEBUG
  769. printk( KERN_DEBUG "pmc551: setting aperture to %dn",
  770. ffs(priv->asize>>20)-1);
  771. #endif
  773.                 priv->base_map0 = ( PMC551_PCI_MEM_MAP_REG_EN
  774.   | PMC551_PCI_MEM_MAP_ENABLE
  775.   | (ffs(priv->asize>>20)-1)<<4 );
  776.                 priv->curr_map0 = priv->base_map0;
  777.                 pci_write_config_dword ( priv->dev, PMC551_PCI_MEM_MAP0,
  778.                                          priv->curr_map0 );
  780. #ifdef CONFIG_MTD_PMC551_DEBUG
  781. printk( KERN_DEBUG "pmc551: aperture set to %dn", 
  782. (priv->base_map0 & 0xF0)>>4 );
  783. #endif
  785.                 mtd->size  = msize;
  786.                 mtd->flags  = MTD_CAP_RAM;
  787.                 mtd->erase  = pmc551_erase;
  788.                 mtd->read  = pmc551_read;
  789.                 mtd->write  = pmc551_write;
  790.                 mtd->point  = pmc551_point;
  791.                 mtd->unpoint  = pmc551_unpoint;
  792.                 mtd->module  = THIS_MODULE;
  793.                 mtd->type  = MTD_RAM;
  794.                 mtd->name  = "PMC551 RAM board";
  795.                 mtd->erasesize  = 0x10000;
  797.                 if (add_mtd_device(mtd)) {
  798.                         printk(KERN_NOTICE "pmc551: Failed to register new devicen");
  799. iounmap(priv->start);
  800.                         kfree(mtd->priv);
  801.                         kfree(mtd);
  802.                         break;
  803.                 }
  804.                 printk(KERN_NOTICE "Registered pmc551 memory device.n");
  805.                 printk(KERN_NOTICE "Mapped %dM of memory from 0x%p to 0x%pn",
  806.                        priv->asize>>20,
  807.                        priv->start,
  808.                        priv->start + priv->asize);
  809.                 printk(KERN_NOTICE "Total memory is %d%cn",
  810.         (length<1024)?length:
  811. (length<1048576)?length>>10:length>>20,
  812.                 (length<1024)?'B':(length<1048576)?'K':'M');
  813. priv->nextpmc551 = pmc551list;
  814. pmc551list = mtd;
  815. found++;
  816.         }
  818.         if( !pmc551list ) {
  819.                 printk(KERN_NOTICE "pmc551: not detectedn");
  820.                 return -ENODEV;
  821.         } else {
  822. printk(KERN_NOTICE "pmc551: %d pmc551 devices loadedn", found);
  823.                 return 0;
  824. }
  825. }
  827. /*
  828.  * PMC551 Card Cleanup
  829.  */
  830. static void __exit cleanup_pmc551(void)
  831. {
  832.         int found=0;
  833.         struct mtd_info *mtd;
  834. struct mypriv *priv;
  836. while((mtd=pmc551list)) {
  837. priv = (struct mypriv *)mtd->priv;
  838. pmc551list = priv->nextpmc551;
  840. if(priv->start) {
  841. printk (KERN_DEBUG "pmc551: unmapping %dM starting at 0x%pn",
  842. priv->asize>>20, priv->start);
  843. iounmap (priv->start);
  844. }
  846. kfree (mtd->priv);
  847. del_mtd_device (mtd);
  848. kfree (mtd);
  849. found++;
  850. }
  852. printk(KERN_NOTICE "pmc551: %d pmc551 devices unloadedn", found);
  853. }
  855. module_init(init_pmc551);
  856. module_exit(cleanup_pmc551);