You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Merge tag 'for-linus-3.4' of git://git.infradead.org/mtd-2.6
Pull MTD changes from David Woodhouse: - Artem's cleanup of the MTD API continues apace. - Fixes and improvements for ST FSMC and SuperH FLCTL NAND, amongst others. - More work on DiskOnChip G3, new driver for DiskOnChip G4. - Clean up debug/warning printks in JFFS2 to use pr_<level>. Fix up various trivial conflicts, largely due to changes in calling conventions for things like dmaengine_prep_slave_sg() (new inline wrapper to hide new parameter, clashing with rewrite of previously last parameter that used to be an 'append' flag, and is now a bitmap of 'unsigned long flags'). (Also some header file fallout - like so many merges this merge window - and silly conflicts with sparse fixes) * tag 'for-linus-3.4' of git://git.infradead.org/mtd-2.6: (120 commits) mtd: docg3 add protection against concurrency mtd: docg3 refactor cascade floors structure mtd: docg3 increase write/erase timeout mtd: docg3 fix inbound calculations mtd: nand: gpmi: fix function annotations mtd: phram: fix section mismatch for phram_setup mtd: unify initialization of erase_info->fail_addr mtd: support ONFI multi lun NAND mtd: sm_ftl: fix typo in major number. mtd: add device-tree support to spear_smi mtd: spear_smi: Remove default partition information from driver mtd: Add device-tree support to fsmc_nand mtd: fix section mismatch for doc_probe_device mtd: nand/fsmc: Remove sparse warnings and errors mtd: nand/fsmc: Add DMA support mtd: nand/fsmc: Access the NAND device word by word whenever possible mtd: nand/fsmc: Use dev_err to report error scenario mtd: nand/fsmc: Use devm routines mtd: nand/fsmc: Modify fsmc driver to accept nand timing parameters via platform mtd: fsmc_nand: add pm callbacks to support hibernation ...
This commit is contained in:
Linus Torvalds
@@ -103,6 +103,13 @@ config M25PXX_USE_FAST_READ
|
||||
help
|
||||
This option enables FAST_READ access supported by ST M25Pxx.
|
||||
|
||||
config MTD_SPEAR_SMI
|
||||
tristate "SPEAR MTD NOR Support through SMI controller"
|
||||
depends on PLAT_SPEAR
|
||||
default y
|
||||
help
|
||||
This enable SNOR support on SPEAR platforms using SMI controller
|
||||
|
||||
config MTD_SST25L
|
||||
tristate "Support SST25L (non JEDEC) SPI Flash chips"
|
||||
depends on SPI_MASTER
|
||||
|
||||
@@ -17,6 +17,7 @@ obj-$(CONFIG_MTD_LART) += lart.o
|
||||
obj-$(CONFIG_MTD_BLOCK2MTD) += block2mtd.o
|
||||
obj-$(CONFIG_MTD_DATAFLASH) += mtd_dataflash.o
|
||||
obj-$(CONFIG_MTD_M25P80) += m25p80.o
|
||||
obj-$(CONFIG_MTD_SPEAR_SMI) += spear_smi.o
|
||||
obj-$(CONFIG_MTD_SST25L) += sst25l.o
|
||||
|
||||
CFLAGS_docg3.o += -I$(src)
|
||||
@@ -104,14 +104,6 @@ static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
int offset = from & (PAGE_SIZE-1);
|
||||
int cpylen;
|
||||
|
||||
if (from > mtd->size)
|
||||
return -EINVAL;
|
||||
if (from + len > mtd->size)
|
||||
len = mtd->size - from;
|
||||
|
||||
if (retlen)
|
||||
*retlen = 0;
|
||||
|
||||
while (len) {
|
||||
if ((offset + len) > PAGE_SIZE)
|
||||
cpylen = PAGE_SIZE - offset; // multiple pages
|
||||
@@ -148,8 +140,6 @@ static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf,
|
||||
int offset = to & ~PAGE_MASK; // page offset
|
||||
int cpylen;
|
||||
|
||||
if (retlen)
|
||||
*retlen = 0;
|
||||
while (len) {
|
||||
if ((offset+len) > PAGE_SIZE)
|
||||
cpylen = PAGE_SIZE - offset; // multiple pages
|
||||
@@ -188,13 +178,6 @@ static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
struct block2mtd_dev *dev = mtd->priv;
|
||||
int err;
|
||||
|
||||
if (!len)
|
||||
return 0;
|
||||
if (to >= mtd->size)
|
||||
return -ENOSPC;
|
||||
if (to + len > mtd->size)
|
||||
len = mtd->size - to;
|
||||
|
||||
mutex_lock(&dev->write_mutex);
|
||||
err = _block2mtd_write(dev, buf, to, len, retlen);
|
||||
mutex_unlock(&dev->write_mutex);
|
||||
@@ -283,13 +266,14 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
|
||||
dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
|
||||
dev->mtd.erasesize = erase_size;
|
||||
dev->mtd.writesize = 1;
|
||||
dev->mtd.writebufsize = PAGE_SIZE;
|
||||
dev->mtd.type = MTD_RAM;
|
||||
dev->mtd.flags = MTD_CAP_RAM;
|
||||
dev->mtd.erase = block2mtd_erase;
|
||||
dev->mtd.write = block2mtd_write;
|
||||
dev->mtd.writev = mtd_writev;
|
||||
dev->mtd.sync = block2mtd_sync;
|
||||
dev->mtd.read = block2mtd_read;
|
||||
dev->mtd._erase = block2mtd_erase;
|
||||
dev->mtd._write = block2mtd_write;
|
||||
dev->mtd._writev = mtd_writev;
|
||||
dev->mtd._sync = block2mtd_sync;
|
||||
dev->mtd._read = block2mtd_read;
|
||||
dev->mtd.priv = dev;
|
||||
dev->mtd.owner = THIS_MODULE;
|
||||
|
||||
|
||||
@@ -562,14 +562,15 @@ void DoC2k_init(struct mtd_info *mtd)
|
||||
|
||||
mtd->type = MTD_NANDFLASH;
|
||||
mtd->flags = MTD_CAP_NANDFLASH;
|
||||
mtd->writesize = 512;
|
||||
mtd->writebufsize = mtd->writesize = 512;
|
||||
mtd->oobsize = 16;
|
||||
mtd->ecc_strength = 2;
|
||||
mtd->owner = THIS_MODULE;
|
||||
mtd->erase = doc_erase;
|
||||
mtd->read = doc_read;
|
||||
mtd->write = doc_write;
|
||||
mtd->read_oob = doc_read_oob;
|
||||
mtd->write_oob = doc_write_oob;
|
||||
mtd->_erase = doc_erase;
|
||||
mtd->_read = doc_read;
|
||||
mtd->_write = doc_write;
|
||||
mtd->_read_oob = doc_read_oob;
|
||||
mtd->_write_oob = doc_write_oob;
|
||||
this->curfloor = -1;
|
||||
this->curchip = -1;
|
||||
mutex_init(&this->lock);
|
||||
@@ -602,13 +603,7 @@ static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
int i, len256 = 0, ret=0;
|
||||
size_t left = len;
|
||||
|
||||
/* Don't allow read past end of device */
|
||||
if (from >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&this->lock);
|
||||
|
||||
*retlen = 0;
|
||||
while (left) {
|
||||
len = left;
|
||||
|
||||
@@ -748,13 +743,7 @@ static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
size_t left = len;
|
||||
int status;
|
||||
|
||||
/* Don't allow write past end of device */
|
||||
if (to >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&this->lock);
|
||||
|
||||
*retlen = 0;
|
||||
while (left) {
|
||||
len = left;
|
||||
|
||||
|
||||
@@ -346,14 +346,15 @@ void DoCMil_init(struct mtd_info *mtd)
|
||||
|
||||
/* FIXME: erase size is not always 8KiB */
|
||||
mtd->erasesize = 0x2000;
|
||||
mtd->writesize = 512;
|
||||
mtd->writebufsize = mtd->writesize = 512;
|
||||
mtd->oobsize = 16;
|
||||
mtd->ecc_strength = 2;
|
||||
mtd->owner = THIS_MODULE;
|
||||
mtd->erase = doc_erase;
|
||||
mtd->read = doc_read;
|
||||
mtd->write = doc_write;
|
||||
mtd->read_oob = doc_read_oob;
|
||||
mtd->write_oob = doc_write_oob;
|
||||
mtd->_erase = doc_erase;
|
||||
mtd->_read = doc_read;
|
||||
mtd->_write = doc_write;
|
||||
mtd->_read_oob = doc_read_oob;
|
||||
mtd->_write_oob = doc_write_oob;
|
||||
this->curfloor = -1;
|
||||
this->curchip = -1;
|
||||
|
||||
@@ -383,10 +384,6 @@ static int doc_read (struct mtd_info *mtd, loff_t from, size_t len,
|
||||
void __iomem *docptr = this->virtadr;
|
||||
struct Nand *mychip = &this->chips[from >> (this->chipshift)];
|
||||
|
||||
/* Don't allow read past end of device */
|
||||
if (from >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
/* Don't allow a single read to cross a 512-byte block boundary */
|
||||
if (from + len > ((from | 0x1ff) + 1))
|
||||
len = ((from | 0x1ff) + 1) - from;
|
||||
@@ -494,10 +491,6 @@ static int doc_write (struct mtd_info *mtd, loff_t to, size_t len,
|
||||
void __iomem *docptr = this->virtadr;
|
||||
struct Nand *mychip = &this->chips[to >> (this->chipshift)];
|
||||
|
||||
/* Don't allow write past end of device */
|
||||
if (to >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
#if 0
|
||||
/* Don't allow a single write to cross a 512-byte block boundary */
|
||||
if (to + len > ( (to | 0x1ff) + 1))
|
||||
@@ -599,7 +592,6 @@ static int doc_write (struct mtd_info *mtd, loff_t to, size_t len,
|
||||
printk("Error programming flash\n");
|
||||
/* Error in programming
|
||||
FIXME: implement Bad Block Replacement (in nftl.c ??) */
|
||||
*retlen = 0;
|
||||
ret = -EIO;
|
||||
}
|
||||
dummy = ReadDOC(docptr, LastDataRead);
|
||||
|
||||
@@ -467,14 +467,15 @@ void DoCMilPlus_init(struct mtd_info *mtd)
|
||||
|
||||
mtd->type = MTD_NANDFLASH;
|
||||
mtd->flags = MTD_CAP_NANDFLASH;
|
||||
mtd->writesize = 512;
|
||||
mtd->writebufsize = mtd->writesize = 512;
|
||||
mtd->oobsize = 16;
|
||||
mtd->ecc_strength = 2;
|
||||
mtd->owner = THIS_MODULE;
|
||||
mtd->erase = doc_erase;
|
||||
mtd->read = doc_read;
|
||||
mtd->write = doc_write;
|
||||
mtd->read_oob = doc_read_oob;
|
||||
mtd->write_oob = doc_write_oob;
|
||||
mtd->_erase = doc_erase;
|
||||
mtd->_read = doc_read;
|
||||
mtd->_write = doc_write;
|
||||
mtd->_read_oob = doc_read_oob;
|
||||
mtd->_write_oob = doc_write_oob;
|
||||
this->curfloor = -1;
|
||||
this->curchip = -1;
|
||||
|
||||
@@ -581,10 +582,6 @@ static int doc_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
void __iomem * docptr = this->virtadr;
|
||||
struct Nand *mychip = &this->chips[from >> (this->chipshift)];
|
||||
|
||||
/* Don't allow read past end of device */
|
||||
if (from >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
/* Don't allow a single read to cross a 512-byte block boundary */
|
||||
if (from + len > ((from | 0x1ff) + 1))
|
||||
len = ((from | 0x1ff) + 1) - from;
|
||||
@@ -700,10 +697,6 @@ static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
void __iomem * docptr = this->virtadr;
|
||||
struct Nand *mychip = &this->chips[to >> (this->chipshift)];
|
||||
|
||||
/* Don't allow write past end of device */
|
||||
if (to >= this->totlen)
|
||||
return -EINVAL;
|
||||
|
||||
/* Don't allow writes which aren't exactly one block (512 bytes) */
|
||||
if ((to & 0x1ff) || (len != 0x200))
|
||||
return -EINVAL;
|
||||
@@ -800,7 +793,6 @@ static int doc_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
printk("MTD: Error 0x%x programming at 0x%x\n", dummy, (int)to);
|
||||
/* Error in programming
|
||||
FIXME: implement Bad Block Replacement (in nftl.c ??) */
|
||||
*retlen = 0;
|
||||
ret = -EIO;
|
||||
}
|
||||
dummy = ReadDOC(docptr, Mplus_LastDataRead);
|
||||
|
||||
+115
-86
File diff suppressed because it is too large
Load Diff
@@ -22,6 +22,8 @@
|
||||
#ifndef _MTD_DOCG3_H
|
||||
#define _MTD_DOCG3_H
|
||||
|
||||
#include <linux/mtd/mtd.h>
|
||||
|
||||
/*
|
||||
* Flash memory areas :
|
||||
* - 0x0000 .. 0x07ff : IPL
|
||||
@@ -266,10 +268,24 @@
|
||||
*/
|
||||
#define DOC_LAYOUT_DPS_KEY_LENGTH 8
|
||||
|
||||
/**
|
||||
* struct docg3_cascade - Cascade of 1 to 4 docg3 chips
|
||||
* @floors: floors (ie. one physical docg3 chip is one floor)
|
||||
* @base: IO space to access all chips in the cascade
|
||||
* @bch: the BCH correcting control structure
|
||||
* @lock: lock to protect docg3 IO space from concurrent accesses
|
||||
*/
|
||||
struct docg3_cascade {
|
||||
struct mtd_info *floors[DOC_MAX_NBFLOORS];
|
||||
void __iomem *base;
|
||||
struct bch_control *bch;
|
||||
struct mutex lock;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct docg3 - DiskOnChip driver private data
|
||||
* @dev: the device currently under control
|
||||
* @base: mapped IO space
|
||||
* @cascade: the cascade this device belongs to
|
||||
* @device_id: number of the cascaded DoCG3 device (0, 1, 2 or 3)
|
||||
* @if_cfg: if true, reads are on 16bits, else reads are on 8bits
|
||||
|
||||
@@ -287,7 +303,7 @@
|
||||
*/
|
||||
struct docg3 {
|
||||
struct device *dev;
|
||||
void __iomem *base;
|
||||
struct docg3_cascade *cascade;
|
||||
unsigned int device_id:4;
|
||||
unsigned int if_cfg:1;
|
||||
unsigned int reliable:2;
|
||||
|
||||
@@ -367,9 +367,6 @@ static int flash_erase (struct mtd_info *mtd,struct erase_info *instr)
|
||||
printk (KERN_DEBUG "%s(addr = 0x%.8x, len = %d)\n", __func__, instr->addr, instr->len);
|
||||
#endif
|
||||
|
||||
/* sanity checks */
|
||||
if (instr->addr + instr->len > mtd->size) return (-EINVAL);
|
||||
|
||||
/*
|
||||
* check that both start and end of the requested erase are
|
||||
* aligned with the erasesize at the appropriate addresses.
|
||||
@@ -440,10 +437,6 @@ static int flash_read (struct mtd_info *mtd,loff_t from,size_t len,size_t *retle
|
||||
printk (KERN_DEBUG "%s(from = 0x%.8x, len = %d)\n", __func__, (__u32)from, len);
|
||||
#endif
|
||||
|
||||
/* sanity checks */
|
||||
if (!len) return (0);
|
||||
if (from + len > mtd->size) return (-EINVAL);
|
||||
|
||||
/* we always read len bytes */
|
||||
*retlen = len;
|
||||
|
||||
@@ -522,11 +515,8 @@ static int flash_write (struct mtd_info *mtd,loff_t to,size_t len,size_t *retlen
|
||||
printk (KERN_DEBUG "%s(to = 0x%.8x, len = %d)\n", __func__, (__u32)to, len);
|
||||
#endif
|
||||
|
||||
*retlen = 0;
|
||||
|
||||
/* sanity checks */
|
||||
if (!len) return (0);
|
||||
if (to + len > mtd->size) return (-EINVAL);
|
||||
|
||||
/* first, we write a 0xFF.... padded byte until we reach a dword boundary */
|
||||
if (to & (BUSWIDTH - 1))
|
||||
@@ -630,14 +620,15 @@ static int __init lart_flash_init (void)
|
||||
mtd.name = module_name;
|
||||
mtd.type = MTD_NORFLASH;
|
||||
mtd.writesize = 1;
|
||||
mtd.writebufsize = 4;
|
||||
mtd.flags = MTD_CAP_NORFLASH;
|
||||
mtd.size = FLASH_BLOCKSIZE_PARAM * FLASH_NUMBLOCKS_16m_PARAM + FLASH_BLOCKSIZE_MAIN * FLASH_NUMBLOCKS_16m_MAIN;
|
||||
mtd.erasesize = FLASH_BLOCKSIZE_MAIN;
|
||||
mtd.numeraseregions = ARRAY_SIZE(erase_regions);
|
||||
mtd.eraseregions = erase_regions;
|
||||
mtd.erase = flash_erase;
|
||||
mtd.read = flash_read;
|
||||
mtd.write = flash_write;
|
||||
mtd._erase = flash_erase;
|
||||
mtd._read = flash_read;
|
||||
mtd._write = flash_write;
|
||||
mtd.owner = THIS_MODULE;
|
||||
|
||||
#ifdef LART_DEBUG
|
||||
|
||||
@@ -288,9 +288,6 @@ static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
__func__, (long long)instr->addr,
|
||||
(long long)instr->len);
|
||||
|
||||
/* sanity checks */
|
||||
if (instr->addr + instr->len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
div_u64_rem(instr->len, mtd->erasesize, &rem);
|
||||
if (rem)
|
||||
return -EINVAL;
|
||||
@@ -349,13 +346,6 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
pr_debug("%s: %s from 0x%08x, len %zd\n", dev_name(&flash->spi->dev),
|
||||
__func__, (u32)from, len);
|
||||
|
||||
/* sanity checks */
|
||||
if (!len)
|
||||
return 0;
|
||||
|
||||
if (from + len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
spi_message_init(&m);
|
||||
memset(t, 0, (sizeof t));
|
||||
|
||||
@@ -371,9 +361,6 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
t[1].len = len;
|
||||
spi_message_add_tail(&t[1], &m);
|
||||
|
||||
/* Byte count starts at zero. */
|
||||
*retlen = 0;
|
||||
|
||||
mutex_lock(&flash->lock);
|
||||
|
||||
/* Wait till previous write/erase is done. */
|
||||
@@ -417,15 +404,6 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
pr_debug("%s: %s to 0x%08x, len %zd\n", dev_name(&flash->spi->dev),
|
||||
__func__, (u32)to, len);
|
||||
|
||||
*retlen = 0;
|
||||
|
||||
/* sanity checks */
|
||||
if (!len)
|
||||
return(0);
|
||||
|
||||
if (to + len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
spi_message_init(&m);
|
||||
memset(t, 0, (sizeof t));
|
||||
|
||||
@@ -509,15 +487,6 @@ static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
pr_debug("%s: %s to 0x%08x, len %zd\n", dev_name(&flash->spi->dev),
|
||||
__func__, (u32)to, len);
|
||||
|
||||
*retlen = 0;
|
||||
|
||||
/* sanity checks */
|
||||
if (!len)
|
||||
return 0;
|
||||
|
||||
if (to + len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
spi_message_init(&m);
|
||||
memset(t, 0, (sizeof t));
|
||||
|
||||
@@ -908,14 +877,14 @@ static int __devinit m25p_probe(struct spi_device *spi)
|
||||
flash->mtd.writesize = 1;
|
||||
flash->mtd.flags = MTD_CAP_NORFLASH;
|
||||
flash->mtd.size = info->sector_size * info->n_sectors;
|
||||
flash->mtd.erase = m25p80_erase;
|
||||
flash->mtd.read = m25p80_read;
|
||||
flash->mtd._erase = m25p80_erase;
|
||||
flash->mtd._read = m25p80_read;
|
||||
|
||||
/* sst flash chips use AAI word program */
|
||||
if (JEDEC_MFR(info->jedec_id) == CFI_MFR_SST)
|
||||
flash->mtd.write = sst_write;
|
||||
flash->mtd._write = sst_write;
|
||||
else
|
||||
flash->mtd.write = m25p80_write;
|
||||
flash->mtd._write = m25p80_write;
|
||||
|
||||
/* prefer "small sector" erase if possible */
|
||||
if (info->flags & SECT_4K) {
|
||||
@@ -932,6 +901,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
|
||||
ppdata.of_node = spi->dev.of_node;
|
||||
flash->mtd.dev.parent = &spi->dev;
|
||||
flash->page_size = info->page_size;
|
||||
flash->mtd.writebufsize = flash->page_size;
|
||||
|
||||
if (info->addr_width)
|
||||
flash->addr_width = info->addr_width;
|
||||
@@ -1004,21 +974,7 @@ static struct spi_driver m25p80_driver = {
|
||||
*/
|
||||
};
|
||||
|
||||
|
||||
static int __init m25p80_init(void)
|
||||
{
|
||||
return spi_register_driver(&m25p80_driver);
|
||||
}
|
||||
|
||||
|
||||
static void __exit m25p80_exit(void)
|
||||
{
|
||||
spi_unregister_driver(&m25p80_driver);
|
||||
}
|
||||
|
||||
|
||||
module_init(m25p80_init);
|
||||
module_exit(m25p80_exit);
|
||||
module_spi_driver(m25p80_driver);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Mike Lavender");
|
||||
|
||||
@@ -59,12 +59,8 @@ static int ms02nv_read(struct mtd_info *mtd, loff_t from,
|
||||
{
|
||||
struct ms02nv_private *mp = mtd->priv;
|
||||
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy(buf, mp->uaddr + from, len);
|
||||
*retlen = len;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -73,12 +69,8 @@ static int ms02nv_write(struct mtd_info *mtd, loff_t to,
|
||||
{
|
||||
struct ms02nv_private *mp = mtd->priv;
|
||||
|
||||
if (to + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy(mp->uaddr + to, buf, len);
|
||||
*retlen = len;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -215,8 +207,8 @@ static int __init ms02nv_init_one(ulong addr)
|
||||
mtd->size = fixsize;
|
||||
mtd->name = (char *)ms02nv_name;
|
||||
mtd->owner = THIS_MODULE;
|
||||
mtd->read = ms02nv_read;
|
||||
mtd->write = ms02nv_write;
|
||||
mtd->_read = ms02nv_read;
|
||||
mtd->_write = ms02nv_write;
|
||||
mtd->writesize = 1;
|
||||
|
||||
ret = -EIO;
|
||||
|
||||
@@ -164,9 +164,6 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
dev_name(&spi->dev), (long long)instr->addr,
|
||||
(long long)instr->len);
|
||||
|
||||
/* Sanity checks */
|
||||
if (instr->addr + instr->len > mtd->size)
|
||||
return -EINVAL;
|
||||
div_u64_rem(instr->len, priv->page_size, &rem);
|
||||
if (rem)
|
||||
return -EINVAL;
|
||||
@@ -252,14 +249,6 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
pr_debug("%s: read 0x%x..0x%x\n", dev_name(&priv->spi->dev),
|
||||
(unsigned)from, (unsigned)(from + len));
|
||||
|
||||
*retlen = 0;
|
||||
|
||||
/* Sanity checks */
|
||||
if (!len)
|
||||
return 0;
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
/* Calculate flash page/byte address */
|
||||
addr = (((unsigned)from / priv->page_size) << priv->page_offset)
|
||||
+ ((unsigned)from % priv->page_size);
|
||||
@@ -328,14 +317,6 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
pr_debug("%s: write 0x%x..0x%x\n",
|
||||
dev_name(&spi->dev), (unsigned)to, (unsigned)(to + len));
|
||||
|
||||
*retlen = 0;
|
||||
|
||||
/* Sanity checks */
|
||||
if (!len)
|
||||
return 0;
|
||||
if ((to + len) > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
spi_message_init(&msg);
|
||||
|
||||
x[0].tx_buf = command = priv->command;
|
||||
@@ -490,8 +471,6 @@ static ssize_t otp_read(struct spi_device *spi, unsigned base,
|
||||
|
||||
if ((off + len) > 64)
|
||||
len = 64 - off;
|
||||
if (len == 0)
|
||||
return len;
|
||||
|
||||
spi_message_init(&m);
|
||||
|
||||
@@ -611,16 +590,16 @@ static int dataflash_write_user_otp(struct mtd_info *mtd,
|
||||
|
||||
static char *otp_setup(struct mtd_info *device, char revision)
|
||||
{
|
||||
device->get_fact_prot_info = dataflash_get_otp_info;
|
||||
device->read_fact_prot_reg = dataflash_read_fact_otp;
|
||||
device->get_user_prot_info = dataflash_get_otp_info;
|
||||
device->read_user_prot_reg = dataflash_read_user_otp;
|
||||
device->_get_fact_prot_info = dataflash_get_otp_info;
|
||||
device->_read_fact_prot_reg = dataflash_read_fact_otp;
|
||||
device->_get_user_prot_info = dataflash_get_otp_info;
|
||||
device->_read_user_prot_reg = dataflash_read_user_otp;
|
||||
|
||||
/* rev c parts (at45db321c and at45db1281 only!) use a
|
||||
* different write procedure; not (yet?) implemented.
|
||||
*/
|
||||
if (revision > 'c')
|
||||
device->write_user_prot_reg = dataflash_write_user_otp;
|
||||
device->_write_user_prot_reg = dataflash_write_user_otp;
|
||||
|
||||
return ", OTP";
|
||||
}
|
||||
@@ -672,9 +651,9 @@ add_dataflash_otp(struct spi_device *spi, char *name,
|
||||
device->owner = THIS_MODULE;
|
||||
device->type = MTD_DATAFLASH;
|
||||
device->flags = MTD_WRITEABLE;
|
||||
device->erase = dataflash_erase;
|
||||
device->read = dataflash_read;
|
||||
device->write = dataflash_write;
|
||||
device->_erase = dataflash_erase;
|
||||
device->_read = dataflash_read;
|
||||
device->_write = dataflash_write;
|
||||
device->priv = priv;
|
||||
|
||||
device->dev.parent = &spi->dev;
|
||||
@@ -946,18 +925,7 @@ static struct spi_driver dataflash_driver = {
|
||||
/* FIXME: investigate suspend and resume... */
|
||||
};
|
||||
|
||||
static int __init dataflash_init(void)
|
||||
{
|
||||
return spi_register_driver(&dataflash_driver);
|
||||
}
|
||||
module_init(dataflash_init);
|
||||
|
||||
static void __exit dataflash_exit(void)
|
||||
{
|
||||
spi_unregister_driver(&dataflash_driver);
|
||||
}
|
||||
module_exit(dataflash_exit);
|
||||
|
||||
module_spi_driver(dataflash_driver);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Andrew Victor, David Brownell");
|
||||
|
||||
@@ -34,34 +34,23 @@ static struct mtd_info *mtd_info;
|
||||
|
||||
static int ram_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
{
|
||||
if (instr->addr + instr->len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
|
||||
|
||||
instr->state = MTD_ERASE_DONE;
|
||||
mtd_erase_callback(instr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ram_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
size_t *retlen, void **virt, resource_size_t *phys)
|
||||
{
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
/* can we return a physical address with this driver? */
|
||||
if (phys)
|
||||
return -EINVAL;
|
||||
|
||||
*virt = mtd->priv + from;
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
static int ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -80,11 +69,7 @@ static unsigned long ram_get_unmapped_area(struct mtd_info *mtd,
|
||||
static int ram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
size_t *retlen, u_char *buf)
|
||||
{
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy(buf, mtd->priv + from, len);
|
||||
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
@@ -92,11 +77,7 @@ static int ram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
static int ram_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
size_t *retlen, const u_char *buf)
|
||||
{
|
||||
if (to + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy((char *)mtd->priv + to, buf, len);
|
||||
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
@@ -126,12 +107,12 @@ int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
|
||||
mtd->priv = mapped_address;
|
||||
|
||||
mtd->owner = THIS_MODULE;
|
||||
mtd->erase = ram_erase;
|
||||
mtd->point = ram_point;
|
||||
mtd->unpoint = ram_unpoint;
|
||||
mtd->get_unmapped_area = ram_get_unmapped_area;
|
||||
mtd->read = ram_read;
|
||||
mtd->write = ram_write;
|
||||
mtd->_erase = ram_erase;
|
||||
mtd->_point = ram_point;
|
||||
mtd->_unpoint = ram_unpoint;
|
||||
mtd->_get_unmapped_area = ram_get_unmapped_area;
|
||||
mtd->_read = ram_read;
|
||||
mtd->_write = ram_write;
|
||||
|
||||
if (mtd_device_register(mtd, NULL, 0))
|
||||
return -EIO;
|
||||
|
||||
+37
-39
@@ -33,45 +33,33 @@ struct phram_mtd_list {
|
||||
|
||||
static LIST_HEAD(phram_list);
|
||||
|
||||
|
||||
static int phram_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
{
|
||||
u_char *start = mtd->priv;
|
||||
|
||||
if (instr->addr + instr->len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memset(start + instr->addr, 0xff, instr->len);
|
||||
|
||||
/* This'll catch a few races. Free the thing before returning :)
|
||||
/*
|
||||
* This'll catch a few races. Free the thing before returning :)
|
||||
* I don't feel at all ashamed. This kind of thing is possible anyway
|
||||
* with flash, but unlikely.
|
||||
*/
|
||||
|
||||
instr->state = MTD_ERASE_DONE;
|
||||
|
||||
mtd_erase_callback(instr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int phram_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
size_t *retlen, void **virt, resource_size_t *phys)
|
||||
{
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
/* can we return a physical address with this driver? */
|
||||
if (phys)
|
||||
return -EINVAL;
|
||||
|
||||
*virt = mtd->priv + from;
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
static int phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int phram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
@@ -79,14 +67,7 @@ static int phram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
{
|
||||
u_char *start = mtd->priv;
|
||||
|
||||
if (from >= mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
if (len > mtd->size - from)
|
||||
len = mtd->size - from;
|
||||
|
||||
memcpy(buf, start + from, len);
|
||||
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
@@ -96,20 +77,11 @@ static int phram_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
{
|
||||
u_char *start = mtd->priv;
|
||||
|
||||
if (to >= mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
if (len > mtd->size - to)
|
||||
len = mtd->size - to;
|
||||
|
||||
memcpy(start + to, buf, len);
|
||||
|
||||
*retlen = len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void unregister_devices(void)
|
||||
{
|
||||
struct phram_mtd_list *this, *safe;
|
||||
@@ -142,11 +114,11 @@ static int register_device(char *name, unsigned long start, unsigned long len)
|
||||
new->mtd.name = name;
|
||||
new->mtd.size = len;
|
||||
new->mtd.flags = MTD_CAP_RAM;
|
||||
new->mtd.erase = phram_erase;
|
||||
new->mtd.point = phram_point;
|
||||
new->mtd.unpoint = phram_unpoint;
|
||||
new->mtd.read = phram_read;
|
||||
new->mtd.write = phram_write;
|
||||
new->mtd._erase = phram_erase;
|
||||
new->mtd._point = phram_point;
|
||||
new->mtd._unpoint = phram_unpoint;
|
||||
new->mtd._read = phram_read;
|
||||
new->mtd._write = phram_write;
|
||||
new->mtd.owner = THIS_MODULE;
|
||||
new->mtd.type = MTD_RAM;
|
||||
new->mtd.erasesize = PAGE_SIZE;
|
||||
@@ -233,7 +205,17 @@ static inline void kill_final_newline(char *str)
|
||||
return 1; \
|
||||
} while (0)
|
||||
|
||||
static int phram_setup(const char *val, struct kernel_param *kp)
|
||||
/*
|
||||
* This shall contain the module parameter if any. It is of the form:
|
||||
* - phram=<device>,<address>,<size> for module case
|
||||
* - phram.phram=<device>,<address>,<size> for built-in case
|
||||
* We leave 64 bytes for the device name, 12 for the address and 12 for the
|
||||
* size.
|
||||
* Example: phram.phram=rootfs,0xa0000000,512Mi
|
||||
*/
|
||||
static __initdata char phram_paramline[64+12+12];
|
||||
|
||||
static int __init phram_setup(const char *val)
|
||||
{
|
||||
char buf[64+12+12], *str = buf;
|
||||
char *token[3];
|
||||
@@ -282,12 +264,28 @@ static int phram_setup(const char *val, struct kernel_param *kp)
|
||||
return ret;
|
||||
}
|
||||
|
||||
module_param_call(phram, phram_setup, NULL, NULL, 000);
|
||||
static int __init phram_param_call(const char *val, struct kernel_param *kp)
|
||||
{
|
||||
/*
|
||||
* This function is always called before 'init_phram()', whether
|
||||
* built-in or module.
|
||||
*/
|
||||
if (strlen(val) >= sizeof(phram_paramline))
|
||||
return -ENOSPC;
|
||||
strcpy(phram_paramline, val);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
module_param_call(phram, phram_param_call, NULL, NULL, 000);
|
||||
MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>\"");
|
||||
|
||||
|
||||
static int __init init_phram(void)
|
||||
{
|
||||
if (phram_paramline[0])
|
||||
return phram_setup(phram_paramline);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -94,12 +94,48 @@
|
||||
#include <linux/ioctl.h>
|
||||
#include <asm/io.h>
|
||||
#include <linux/pci.h>
|
||||
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/pmc551.h>
|
||||
|
||||
#define PMC551_VERSION \
|
||||
"Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n"
|
||||
|
||||
#define PCI_VENDOR_ID_V3_SEMI 0x11b0
|
||||
#define PCI_DEVICE_ID_V3_SEMI_V370PDC 0x0200
|
||||
|
||||
#define PMC551_PCI_MEM_MAP0 0x50
|
||||
#define PMC551_PCI_MEM_MAP1 0x54
|
||||
#define PMC551_PCI_MEM_MAP_MAP_ADDR_MASK 0x3ff00000
|
||||
#define PMC551_PCI_MEM_MAP_APERTURE_MASK 0x000000f0
|
||||
#define PMC551_PCI_MEM_MAP_REG_EN 0x00000002
|
||||
#define PMC551_PCI_MEM_MAP_ENABLE 0x00000001
|
||||
|
||||
#define PMC551_SDRAM_MA 0x60
|
||||
#define PMC551_SDRAM_CMD 0x62
|
||||
#define PMC551_DRAM_CFG 0x64
|
||||
#define PMC551_SYS_CTRL_REG 0x78
|
||||
|
||||
#define PMC551_DRAM_BLK0 0x68
|
||||
#define PMC551_DRAM_BLK1 0x6c
|
||||
#define PMC551_DRAM_BLK2 0x70
|
||||
#define PMC551_DRAM_BLK3 0x74
|
||||
#define PMC551_DRAM_BLK_GET_SIZE(x) (524288 << ((x >> 4) & 0x0f))
|
||||
#define PMC551_DRAM_BLK_SET_COL_MUX(x, v) (((x) & ~0x00007000) | (((v) & 0x7) << 12))
|
||||
#define PMC551_DRAM_BLK_SET_ROW_MUX(x, v) (((x) & ~0x00000f00) | (((v) & 0xf) << 8))
|
||||
|
||||
struct mypriv {
|
||||
struct pci_dev *dev;
|
||||
u_char *start;
|
||||
u32 base_map0;
|
||||
u32 curr_map0;
|
||||
u32 asize;
|
||||
struct mtd_info *nextpmc551;
|
||||
};
|
||||
|
||||
static struct mtd_info *pmc551list;
|
||||
|
||||
static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
size_t *retlen, void **virt, resource_size_t *phys);
|
||||
|
||||
static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
{
|
||||
struct mypriv *priv = mtd->priv;
|
||||
@@ -115,16 +151,6 @@ static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
#endif
|
||||
|
||||
end = instr->addr + instr->len - 1;
|
||||
|
||||
/* Is it past the end? */
|
||||
if (end > mtd->size) {
|
||||
#ifdef CONFIG_MTD_PMC551_DEBUG
|
||||
printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)\n",
|
||||
(long)end, (long)mtd->size);
|
||||
#endif
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
eoff_hi = end & ~(priv->asize - 1);
|
||||
soff_hi = instr->addr & ~(priv->asize - 1);
|
||||
eoff_lo = end & (priv->asize - 1);
|
||||
@@ -178,18 +204,6 @@ static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len);
|
||||
#endif
|
||||
|
||||
if (from + len > mtd->size) {
|
||||
#ifdef CONFIG_MTD_PMC551_DEBUG
|
||||
printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n",
|
||||
(long)from + len, (long)mtd->size);
|
||||
#endif
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* can we return a physical address with this driver? */
|
||||
if (phys)
|
||||
return -EINVAL;
|
||||
|
||||
soff_hi = from & ~(priv->asize - 1);
|
||||
soff_lo = from & (priv->asize - 1);
|
||||
|
||||
@@ -205,11 +219,12 @@ static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
static int pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
{
|
||||
#ifdef CONFIG_MTD_PMC551_DEBUG
|
||||
printk(KERN_DEBUG "pmc551_unpoint()\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
@@ -228,16 +243,6 @@ static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
#endif
|
||||
|
||||
end = from + len - 1;
|
||||
|
||||
/* Is it past the end? */
|
||||
if (end > mtd->size) {
|
||||
#ifdef CONFIG_MTD_PMC551_DEBUG
|
||||
printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n",
|
||||
(long)end, (long)mtd->size);
|
||||
#endif
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
soff_hi = from & ~(priv->asize - 1);
|
||||
eoff_hi = end & ~(priv->asize - 1);
|
||||
soff_lo = from & (priv->asize - 1);
|
||||
@@ -295,16 +300,6 @@ static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
#endif
|
||||
|
||||
end = to + len - 1;
|
||||
/* Is it past the end? or did the u32 wrap? */
|
||||
if (end > mtd->size) {
|
||||
#ifdef CONFIG_MTD_PMC551_DEBUG
|
||||
printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, "
|
||||
"size: %ld, to: %ld)\n", (long)end, (long)mtd->size,
|
||||
(long)to);
|
||||
#endif
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
soff_hi = to & ~(priv->asize - 1);
|
||||
eoff_hi = end & ~(priv->asize - 1);
|
||||
soff_lo = to & (priv->asize - 1);
|
||||
@@ -358,7 +353,7 @@ static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
* mechanism
|
||||
* returns the size of the memory region found.
|
||||
*/
|
||||
static u32 fixup_pmc551(struct pci_dev *dev)
|
||||
static int fixup_pmc551(struct pci_dev *dev)
|
||||
{
|
||||
#ifdef CONFIG_MTD_PMC551_BUGFIX
|
||||
u32 dram_data;
|
||||
@@ -668,7 +663,7 @@ static int __init init_pmc551(void)
|
||||
struct mypriv *priv;
|
||||
int found = 0;
|
||||
struct mtd_info *mtd;
|
||||
u32 length = 0;
|
||||
int length = 0;
|
||||
|
||||
if (msize) {
|
||||
msize = (1 << (ffs(msize) - 1)) << 20;
|
||||
@@ -786,11 +781,11 @@ static int __init init_pmc551(void)
|
||||
|
||||
mtd->size = msize;
|
||||
mtd->flags = MTD_CAP_RAM;
|
||||
mtd->erase = pmc551_erase;
|
||||
mtd->read = pmc551_read;
|
||||
mtd->write = pmc551_write;
|
||||
mtd->point = pmc551_point;
|
||||
mtd->unpoint = pmc551_unpoint;
|
||||
mtd->_erase = pmc551_erase;
|
||||
mtd->_read = pmc551_read;
|
||||
mtd->_write = pmc551_write;
|
||||
mtd->_point = pmc551_point;
|
||||
mtd->_unpoint = pmc551_unpoint;
|
||||
mtd->type = MTD_RAM;
|
||||
mtd->name = "PMC551 RAM board";
|
||||
mtd->erasesize = 0x10000;
|
||||
|
||||
@@ -75,7 +75,7 @@ static slram_mtd_list_t *slram_mtdlist = NULL;
|
||||
static int slram_erase(struct mtd_info *, struct erase_info *);
|
||||
static int slram_point(struct mtd_info *, loff_t, size_t, size_t *, void **,
|
||||
resource_size_t *);
|
||||
static void slram_unpoint(struct mtd_info *, loff_t, size_t);
|
||||
static int slram_unpoint(struct mtd_info *, loff_t, size_t);
|
||||
static int slram_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
|
||||
static int slram_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
|
||||
|
||||
@@ -83,21 +83,13 @@ static int slram_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
{
|
||||
slram_priv_t *priv = mtd->priv;
|
||||
|
||||
if (instr->addr + instr->len > mtd->size) {
|
||||
return(-EINVAL);
|
||||
}
|
||||
|
||||
memset(priv->start + instr->addr, 0xff, instr->len);
|
||||
|
||||
/* This'll catch a few races. Free the thing before returning :)
|
||||
* I don't feel at all ashamed. This kind of thing is possible anyway
|
||||
* with flash, but unlikely.
|
||||
*/
|
||||
|
||||
instr->state = MTD_ERASE_DONE;
|
||||
|
||||
mtd_erase_callback(instr);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
@@ -106,20 +98,14 @@ static int slram_point(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
{
|
||||
slram_priv_t *priv = mtd->priv;
|
||||
|
||||
/* can we return a physical address with this driver? */
|
||||
if (phys)
|
||||
return -EINVAL;
|
||||
|
||||
if (from + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
*virt = priv->start + from;
|
||||
*retlen = len;
|
||||
return(0);
|
||||
}
|
||||
|
||||
static void slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
static int slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int slram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
@@ -127,14 +113,7 @@ static int slram_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
{
|
||||
slram_priv_t *priv = mtd->priv;
|
||||
|
||||
if (from > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
if (from + len > mtd->size)
|
||||
len = mtd->size - from;
|
||||
|
||||
memcpy(buf, priv->start + from, len);
|
||||
|
||||
*retlen = len;
|
||||
return(0);
|
||||
}
|
||||
@@ -144,11 +123,7 @@ static int slram_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
{
|
||||
slram_priv_t *priv = mtd->priv;
|
||||
|
||||
if (to + len > mtd->size)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy(priv->start + to, buf, len);
|
||||
|
||||
*retlen = len;
|
||||
return(0);
|
||||
}
|
||||
@@ -199,11 +174,11 @@ static int register_device(char *name, unsigned long start, unsigned long length
|
||||
(*curmtd)->mtdinfo->name = name;
|
||||
(*curmtd)->mtdinfo->size = length;
|
||||
(*curmtd)->mtdinfo->flags = MTD_CAP_RAM;
|
||||
(*curmtd)->mtdinfo->erase = slram_erase;
|
||||
(*curmtd)->mtdinfo->point = slram_point;
|
||||
(*curmtd)->mtdinfo->unpoint = slram_unpoint;
|
||||
(*curmtd)->mtdinfo->read = slram_read;
|
||||
(*curmtd)->mtdinfo->write = slram_write;
|
||||
(*curmtd)->mtdinfo->_erase = slram_erase;
|
||||
(*curmtd)->mtdinfo->_point = slram_point;
|
||||
(*curmtd)->mtdinfo->_unpoint = slram_unpoint;
|
||||
(*curmtd)->mtdinfo->_read = slram_read;
|
||||
(*curmtd)->mtdinfo->_write = slram_write;
|
||||
(*curmtd)->mtdinfo->owner = THIS_MODULE;
|
||||
(*curmtd)->mtdinfo->type = MTD_RAM;
|
||||
(*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -175,9 +175,6 @@ static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr)
|
||||
int err;
|
||||
|
||||
/* Sanity checks */
|
||||
if (instr->addr + instr->len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
if ((uint32_t)instr->len % mtd->erasesize)
|
||||
return -EINVAL;
|
||||
|
||||
@@ -223,16 +220,6 @@ static int sst25l_read(struct mtd_info *mtd, loff_t from, size_t len,
|
||||
unsigned char command[4];
|
||||
int ret;
|
||||
|
||||
/* Sanity checking */
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
if (from + len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
if (retlen)
|
||||
*retlen = 0;
|
||||
|
||||
spi_message_init(&message);
|
||||
memset(&transfer, 0, sizeof(transfer));
|
||||
|
||||
@@ -274,13 +261,6 @@ static int sst25l_write(struct mtd_info *mtd, loff_t to, size_t len,
|
||||
int i, j, ret, bytes, copied = 0;
|
||||
unsigned char command[5];
|
||||
|
||||
/* Sanity checks */
|
||||
if (!len)
|
||||
return 0;
|
||||
|
||||
if (to + len > flash->mtd.size)
|
||||
return -EINVAL;
|
||||
|
||||
if ((uint32_t)to % mtd->writesize)
|
||||
return -EINVAL;
|
||||
|
||||
@@ -402,10 +382,11 @@ static int __devinit sst25l_probe(struct spi_device *spi)
|
||||
flash->mtd.flags = MTD_CAP_NORFLASH;
|
||||
flash->mtd.erasesize = flash_info->erase_size;
|
||||
flash->mtd.writesize = flash_info->page_size;
|
||||
flash->mtd.writebufsize = flash_info->page_size;
|
||||
flash->mtd.size = flash_info->page_size * flash_info->nr_pages;
|
||||
flash->mtd.erase = sst25l_erase;
|
||||
flash->mtd.read = sst25l_read;
|
||||
flash->mtd.write = sst25l_write;
|
||||
flash->mtd._erase = sst25l_erase;
|
||||
flash->mtd._read = sst25l_read;
|
||||
flash->mtd._write = sst25l_write;
|
||||
|
||||
dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name,
|
||||
(long long)flash->mtd.size >> 10);
|
||||
@@ -418,9 +399,9 @@ static int __devinit sst25l_probe(struct spi_device *spi)
|
||||
flash->mtd.numeraseregions);
|
||||
|
||||
|
||||
ret = mtd_device_parse_register(&flash->mtd, NULL, 0,
|
||||
data ? data->parts : NULL,
|
||||
data ? data->nr_parts : 0);
|
||||
ret = mtd_device_parse_register(&flash->mtd, NULL, NULL,
|
||||
data ? data->parts : NULL,
|
||||
data ? data->nr_parts : 0);
|
||||
if (ret) {
|
||||
kfree(flash);
|
||||
dev_set_drvdata(&spi->dev, NULL);
|
||||
@@ -450,18 +431,7 @@ static struct spi_driver sst25l_driver = {
|
||||
.remove = __devexit_p(sst25l_remove),
|
||||
};
|
||||
|
||||
static int __init sst25l_init(void)
|
||||
{
|
||||
return spi_register_driver(&sst25l_driver);
|
||||
}
|
||||
|
||||
static void __exit sst25l_exit(void)
|
||||
{
|
||||
spi_unregister_driver(&sst25l_driver);
|
||||
}
|
||||
|
||||
module_init(sst25l_init);
|
||||
module_exit(sst25l_exit);
|
||||
module_spi_driver(sst25l_driver);
|
||||
|
||||
MODULE_DESCRIPTION("MTD SPI driver for SST25L Flash chips");
|
||||
MODULE_AUTHOR("Andre Renaud <andre@bluewatersys.com>, "
|
||||
|
||||
Reference in New Issue
Block a user