Subversion Repositories or1k

/* $Id: flash.c,v 1.1.1.1 2001-09-10 07:44:10 simons Exp $

 *

 * Flash-memory char or block device

 *

 * Copyright (c) 1998, 1999 Bjorn Wesen, Axis Communications AB

 *

 * This driver implements a read/write/erase interface to the flash chips.

 * It probes for chips, and tries to read a bootblock with partition info from

 * the bootblock on the first chip. This bootblock is given the device name

 * /dev/flash0, and the rest of the partitions are given flash1 and upwards.

 * If no bootblock is found, the entire first chip (including bootblock) is

 * set as /dev/flash1.

 *

 * TODO:

 *   implement Unlock Bypass programming, to double the write speed

 *   fix various loops for partitions than span more than one chip

 */

/* define to make kernel bigger, but with verbose Flash messages */

//#define LISAHACK

/* if IRQ_LOCKS is enabled, interrupts are disabled while doing things

 * with the flash that cant have other accesses to the flash at the same

 * time. this is normally not needed since we have a wait_queue lock on the

 * flash chip as a mutex.

 */

//#define IRQ_LOCKS

#define FLASH_VERBOSE

#define MEM_NON_CACHEABLE 0

#define FLASH_16BIT

/* ROM and flash devices have major 31 (Documentation/devices.txt)

 * However, KROM is using that major now, so we use an experimental major = 60.

 * When this driver works, it will support read-only memory as well and we can

 * remove KROM.

 * Our minors start at: 16 = /dev/flash0       First flash memory card (rw)

 */

/*#define MAJOR_NR 31 */

#define MAJOR_NR 60

#define ROM_MINOR   8   /* ro ROM card */

#define FLASH_MINOR 16  /* rw Flash card */

/* dont touch the MAX_CHIPS until the hardcoded chip0 and chip1 are removed from the code */

#define MAX_CHIPS /* 2 */ 1

#define MAX_PARTITIONS 8

#define DEF_FLASH2_SIZE 0x50000   /* 5 sectors for JFFS partition per default */

#include <linux/config.h>

#include <linux/major.h>

#include <linux/malloc.h>

/* all this stuff needs to go in blk.h */

#define DEVICE_NAME "Flash/ROM device"

#ifdef CONFIG_BLK_DEV_FLASH

#define FLASH_SECTSIZE 512 /* arbitrary, but Linux assumes 512 often it seems */

#define DEVICE_REQUEST do_flash_request

#define DEVICE_NR(device) (MINOR(device))

#define DEVICE_ON(device)

#define DEVICE_OFF(device)

#include <linux/blk.h>

/* the device and block sizes for each minor */

static int flash_sizes[32];

static int flash_blk_sizes[32];

#endif

#include <asm/system.h>

#include <linux/flash.h>

//#define DEBUG

#ifdef DEBUG

#define FDEBUG(x) x

#else

#define FDEBUG(x)

#endif

#if defined(__CRIS__) && !defined(DEBUG)

/* breaks badly if we use printk before we flash an image... */

extern void console_print_etrax(const char *b, ...);

#define safe_printk console_print_etrax

#else

#define safe_printk printk

#endif

int flash_write(unsigned char *ptr, const unsigned char *source, unsigned int size);

void flash_init_erase(unsigned char *ptr, unsigned int size);

static struct flashchip *getchip(unsigned char *ptr);

#ifdef FLASH_16BIT

/* 16-bit wide Flash-ROM */

enum {  unlockAddress1          = 0x555,

        unlockData1             = 0xAA,

        unlockAddress2          = 0x2AA,

        unlockData2             = 0x55,

        manufacturerUnlockData  = 0x90,

        manufacturerAddress     = 0x00,

        deviceIdAddress         = 0x01,

        programUnlockData       = 0xA0,

        resetData               = 0xF0,

        sectorEraseUnlockData   = 0x80,

        sectorEraseUnlockData2  = 0x30 };

typedef volatile unsigned short *flashptr;

#else

/* 32-bit wide Flash-ROM

 * Since we have two devices in parallell, we need to duplicate

 * the special _data_ below so it reaches both chips.

 */

enum {  unlockAddress1          = 0x555,

        unlockData1             = 0x00AA00AA,

        unlockAddress2          = 0x2AA,

        unlockData2             = 0x00550055,

        manufacturerUnlockData  = 0x00900090,

        manufacturerAddress     = 0x00,

        deviceIdAddress         = 0x01,

        programUnlockData       = 0x00A000A0,

        resetData               = 0x00F000F0,

        sectorEraseUnlockData   = 0x00800080,

        sectorEraseUnlockData2  = 0x00300030 };

typedef volatile unsigned long *flashptr;

#endif

enum {  ManufacturerAMD   = 0x01,

        AM29F800BB        = 0x2258,

        AM29F800BT        = 0x22D6,

        AM29LV800BB       = 0x225B,

        AM29LV800BT       = 0x22DA,

        AM29LV160BT       = 0x22C4

};

enum {  ManufacturerToshiba = 0x0098,

        TC58FVT160          = 0x00c2,

        TC58FVB160          = 0x0043

};

enum {

        /* ST - www.st.com*/

        ManufacturerST    = 0x20, /* 0x20 */

        M29W800T          = 0x00D7 /* Used in 5600, similar to AM29LV800,

                                    * but no unlock bypass */

};

enum {  D6_MASK           = 0x40};

enum {  maxNumberOfBootSectors = 8 };

/* internal structure for keeping track of flash devices */

struct flashchip {

        unsigned char *start;

        unsigned char *bootsector;

        unsigned int bootsectorsize[maxNumberOfBootSectors];

        unsigned short device_id;

        unsigned short isValid;

        int size, sectorsize;

        /* to block accesses during erase and writing etc */

        int busy;

        struct wait_queue *wqueue;

};

/* and partitions */

struct flashpartition {

        struct flashchip *chip;   /* the chip we reside in */

        unsigned char *start;     /* starting flash mem address */

        int size;                 /* size of partition in bytes */

        unsigned int flags;       /* protection bits etc */

};

static struct flashchip chips[MAX_CHIPS];

static struct flashpartition partitions[MAX_PARTITIONS];

/* check if flash is busy */

static inline int flash_is_busy(flashptr flashStart)

{

        /* this should probably be protected! */

        return((*flashStart & D6_MASK) !=

               (*flashStart & D6_MASK));

}

/* Open the device. We don't need to do anything really.  */

static int

flash_open(struct inode *inode, struct file *filp)

{

#ifdef CONFIG_CHR_DEV_FLASH

        int minor = MINOR(inode->i_rdev);

        struct flashpartition *part;

        if(minor < FLASH_MINOR)

                return -ENODEV;

        part = &partitions[minor - FLASH_MINOR];

        if(!part->start)

                return -ENODEV;

        filp->private_data = (void *)part;  /* remember for the future */

#endif

        return 0; /* everything went ok */

}

static void

flash_release(struct inode *inode, struct file *filp)

{

#ifdef CONFIG_BLK_DEV_FLASH

        sync_dev(inode->i_rdev);

#endif

        return;

}

#ifdef CONFIG_BLK_DEV_FLASH

static void

do_flash_request()

{

        while(1) {

                int minor, fsize, opsize;

                struct flashchip *chip;

                struct flashpartition *part;

                unsigned char *fptr;

                unsigned long flags;

                INIT_REQUEST;

                minor = DEVICE_NR(CURRENT_DEV);

                minor -= FLASH_MINOR;

                /* for now, just handle requests to the flash minors */

                if(minor < 0 || minor >= MAX_PARTITIONS ||

                   !partitions[minor].start) {

                        printk(KERN_WARNING "flash: bad minor %d.", minor);

                        end_request(0);

                        continue;

                }

                part = partitions + minor;

                /* get the actual memory address of the sectors requested */

                fptr = part->start + CURRENT->sector * FLASH_SECTSIZE;

                fsize = CURRENT->current_nr_sectors * FLASH_SECTSIZE;

                /* check so it's not totally out of bounds */

                if(fptr + fsize > part->start + part->size) {

                        printk(KERN_WARNING "flash: request past end "

                               "of partition\n");

                        end_request(0);

                        continue;

                }

                /* actually do something, but get a lock on the chip first.

                 * since the partition might span several chips, we need to

                 * loop and lock each chip in turn

                 */

                while(fsize > 0) {

                        chip = getchip(fptr);

                        /* how much fits in this chip ? */

                        opsize = (fptr + fsize) > (chip->start + chip->size) ?

                                 (chip->start + chip->size - fptr) : fsize;

                        /* lock the chip */

                        save_flags(flags);

                        cli();

                        while(chip->busy)

                                sleep_on(&chip->wqueue);

                        chip->busy = 1;

                        restore_flags(flags);

                        switch(CURRENT->cmd) {

                        case READ:

                                memcpy(CURRENT->buffer, fptr, opsize);

                                FDEBUG(printk("flash read from %p to %p "

                                              "size %d\n", fptr,

                                              CURRENT->buffer, opsize));

                                break;

                        case WRITE:

                                FDEBUG(printk("flash write block at 0x%p\n",

                                              fptr));

                                flash_write(fptr,

                                            (unsigned char *)

                                            CURRENT->buffer,

                                            opsize);

                                break;

                        default:

                                /* Shouldn't happen.  */

                                chip->busy = 0;

                                wake_up(&chip->wqueue);

                                end_request(0);

                                continue;

                        }

                        /* release the lock */

                        chip->busy = 0;

                        wake_up(&chip->wqueue);

                        /* see if there is anything left to write in the next chip */

                        fsize -= opsize;

                        fptr += opsize;

                }

                /* We have a liftoff! */

                end_request(1);

        }

}

#endif /* CONFIG_BLK_DEV_FLASH */

void

flash_safe_acquire(void *part)

{

        struct flashchip *chip = ((struct flashpartition *)part)->chip;

        while (chip->busy)

                sleep_on(&chip->wqueue);

        chip->busy = 1;

}

void

flash_safe_release(void *part)

{

        struct flashchip *chip = ((struct flashpartition *)part)->chip;

        chip->busy = 0;

        wake_up(&chip->wqueue);

}

/* flash_safe_read and flash_safe_write are used by the JFFS flash filesystem */

int

flash_safe_read(void *_part, unsigned char *fptr,

                unsigned char *buf, int count)

{

        struct flashpartition *part = (struct flashpartition *)_part;

        /* Check so it's not totally out of bounds.  */

        if(fptr + count > part->start + part->size) {

                printk(KERN_WARNING "flash: read request past "

                       "end of device (address: 0x%p, size: %d)\n",

                       fptr, count);

                return -EINVAL;

        }

        FDEBUG(printk("flash_safe_read: %d bytes from 0x%p to 0x%p\n",

                      count, fptr, buf));

        /* Actually do something, but get a lock on the chip first.  */

        flash_safe_acquire(part);

        memcpy(buf, fptr, count);

        /* Release the lock.  */

        flash_safe_release(part);

        return count; /* success */

}

int

flash_safe_write(void *_part, unsigned char *fptr,

                 const unsigned char *buf, int count)

{

        struct flashpartition *part = (struct flashpartition *)_part;

        int err;

        /* Check so it's not totally out of bounds.  */

        if(fptr + count > part->start + part->size) {

                printk(KERN_WARNING "flash: write operation past "

                       "end of device (address: 0x%p, size: %d)\n",

                       fptr, count);

                return -EINVAL;

        }

        FDEBUG(printk("flash_safe_write: %d bytes from 0x%p to 0x%p\n",

                      count, buf, fptr));

        /* Actually do something, but get a lock on the chip first.  */

        flash_safe_acquire(part);

        if ((err = flash_write(fptr, buf, count)) < 0) {

                count = err;

        }

        /* Release the lock.  */

        flash_safe_release(part);

        return count; /* success */

}

#ifdef CONFIG_CHR_DEV_FLASH

static int

flash_char_read(struct inode *inode, struct file *filp,

                char *buf, int count)

{

        int rlen;

        struct flashpartition *part = (struct flashpartition *)filp->private_data;

        FDEBUG(printk("flash_char_read\n"));

        rlen = flash_safe_read(part,

                               (unsigned char *)part->start + filp->f_pos,

                               (unsigned char *)buf, count);

        /* advance file position pointer */

        if(rlen >= 0)

                filp->f_pos += rlen;

        return rlen;

}

static int

flash_char_write(struct inode *inode, struct file *filp,

                 const char *buf, int count)

{

        int wlen;

        struct flashpartition *part = (struct flashpartition *)filp->private_data;

        FDEBUG(printk("flash_char_write\n"));

        wlen = flash_safe_write(part,

                                (unsigned char *)part->start + filp->f_pos,

                                (unsigned char *)buf, count);

        /* advance file position pointer */

        if(wlen >= 0)

                filp->f_pos += wlen;

        return wlen;

}

#endif /* CONFIG_CHR_DEV_FLASH */

static int

flash_ioctl(struct inode *inode, struct file *file,

            unsigned int cmd, unsigned long arg)

{

        int minor;

        struct flashpartition *part;

        if (!inode || !inode->i_rdev)

                return -EINVAL;

        minor = MINOR(inode->i_rdev);

        if(minor < FLASH_MINOR)

                return -EINVAL; /* only ioctl's for flash devices */

        part = &partitions[minor - FLASH_MINOR];

        if(!part->start)

                return -EINVAL;

        switch(cmd) {

        case FLASHIO_ERASEALL:

                FDEBUG(printk("flash_ioctl(): Got FLASHIO_ERASEALL request.\n"));

                if(!suser())

                        return -EACCES;

                /* Invalidate all pages and buffers */

                invalidate_inodes(inode->i_rdev);

                invalidate_buffers(inode->i_rdev);

                /*

                 * Start the erasure, then sleep and wake up now and

                 * then to see if it's done. We use the waitqueue to

                 * make sure we don't start erasing in the middle of

                 * a write, or that nobody start using the flash while

                 * we're erasing.

                 *

                 * TODO: break up partition erases that spans more than one

                 *       chip.

                 */

                flash_safe_acquire(part);

                flash_init_erase(part->start, part->size);

                while(flash_is_busy((flashptr)part->chip->start)) {

                        current->state = TASK_INTERRUPTIBLE;

                        current->timeout = jiffies + HZ / 2;

                        schedule();

                }

                flash_safe_release(part);

                return 0;

        default:

                return -EPERM;

        }

        return -EPERM;

}

/* probe for Flash RAM's - this isn't in the init function, because this needs

 * to be done really early in the boot, so we can use the device to burn an

 * image before the system is running.

 */

void

flash_probe()

{

        int i;

        /* start adresses for the Flash chips - these should really

         * be settable in some other way.

         */

#ifdef FLASH_VERBOSE

        safe_printk("Probing flash...\n");

#endif

#if 0

        chips[0].start = (unsigned char *)(MEM_CSE0_START | MEM_NON_CACHEABLE);

        chips[1].start = (unsigned char *)(MEM_CSE1_START | MEM_NON_CACHEABLE);

#else

        chips[0].start = (unsigned char *)(0x10c00000);

        chips[1].start = (unsigned char *)(0x0);

#endif

        for(i = 0; i < MAX_CHIPS; i++) {

                struct flashchip *chip = chips + i;

                flashptr flashStart = (flashptr)chip->start;

                unsigned short manu;

#ifdef CONFIG_SVINTO_SIM

                /* in the simulator, dont trash the flash ram by writing unlocks */

                chip->isValid = 1;

                chip->device_id = AM29LV160BT;

#else

                /* reset */

                flashStart[unlockAddress1] = unlockData1;

                flashStart[unlockAddress2] = unlockData2;

                flashStart[unlockAddress1] = resetData;

                /* read manufacturer */

                flashStart[unlockAddress1] = unlockData1;

                flashStart[unlockAddress2] = unlockData2;

                flashStart[unlockAddress1] = manufacturerUnlockData;

                manu = flashStart[manufacturerAddress];

                chip->isValid = (manu == ManufacturerAMD ||

                                 manu == ManufacturerToshiba ||

                                 manu == ManufacturerST);

                if(!chip->isValid) {

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: No flash or unsupported "

                                    "manufacturer.\n", i);

#endif

                        continue;

                }

                /* reset */

                flashStart[unlockAddress1] = unlockData1;

                flashStart[unlockAddress2] = unlockData2;

                flashStart[unlockAddress1] = resetData;

                /* read device id */

                flashStart[unlockAddress1] = unlockData1;

                flashStart[unlockAddress2] = unlockData2;

                flashStart[unlockAddress1] = manufacturerUnlockData;

                chip->device_id = flashStart[deviceIdAddress];

                /* reset */

                flashStart[unlockAddress1] = unlockData1;

                flashStart[unlockAddress2] = unlockData2;

                flashStart[unlockAddress1] = resetData;

#endif

                /* check device type and fill in correct sizes etc */

                switch(chip->device_id) {

                case AM29LV160BT:

                case TC58FVT160:

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: 16Mb TB.\n");

#endif

                        chip->size = 0x00200000;

                        chip->sectorsize = 0x10000;

                        chip->bootsector = chip->start + chip->size

                                           - chip->sectorsize;

                        chip->bootsectorsize[0] = 0x8000;

                        chip->bootsectorsize[1] = 0x2000;

                        chip->bootsectorsize[2] = 0x2000;

                        chip->bootsectorsize[3] = 0x4000;

                        break;

                //case AM29LV160BB:

                case TC58FVB160:

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: 16Mb BB.\n");

#endif

                        chip->size = 0x00200000;

                        chip->sectorsize = 0x10000;

                        chip->bootsector = chip->start;

                        chip->bootsectorsize[0] = 0x4000;

                        chip->bootsectorsize[1] = 0x2000;

                        chip->bootsectorsize[2] = 0x2000;

                        chip->bootsectorsize[3] = 0x8000;

                        break;

                case AM29LV800BB:

                case AM29F800BB:

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: 8Mb BB.\n");

#endif

                        chip->size = 0x00100000;

                        chip->sectorsize = 0x10000;

                        chip->bootsector = chip->start;

                        chip->bootsectorsize[0] = 0x4000;

                        chip->bootsectorsize[1] = 0x2000;

                        chip->bootsectorsize[2] = 0x2000;

                        chip->bootsectorsize[3] = 0x8000;

                        break;

                case M29W800T:

                case AM29LV800BT:

                case AM29F800BT:

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: 8Mb TB.\n");

#endif

                        chip->size = 0x00100000;

                        chip->sectorsize = 0x10000;

                        chip->bootsector = chip->start + chip->size

                                           - chip->sectorsize;

                        chip->bootsectorsize[0] = 0x8000;

                        chip->bootsectorsize[1] = 0x2000;

                        chip->bootsectorsize[2] = 0x2000;

                        chip->bootsectorsize[3] = 0x4000;

                        break;

                        //     case AM29LV800BB:

                default:

#ifdef FLASH_VERBOSE

                        safe_printk("Flash: Unknown device.\n");

#endif

                        chip->isValid = 0;

                        break;

                }

                chip->busy = 0;

                init_waitqueue(&chip->wqueue);

        }

}

/* locate the flashchip structure associated with the given adress */

static struct flashchip *

getchip(unsigned char *ptr)

{

        int i;

        for(i = 0; i < MAX_CHIPS; i++) {

                if(ptr >= chips[i].start &&

                   ptr < (chips[i].start + chips[i].size))

                        return &chips[i];

        }

        FDEBUG(printk("Illegal adress in Flash: getchip(0x%p)!\n", ptr));

        return (void *)0;

}