os/linux-2.6-tag--devboard-R2_10-4/arch/cris/arch-v32/drivers/elphel/cxsdram.c

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : cxsdram353.c
*! DESCRIPTION: TBD
*! Copyright (C) 2002-2007 Elphel, Inc
*! -----------------------------------------------------------------------------**
*!
*!  This program is free software: you can redistribute it and/or modify
*!  it under the terms of the GNU General Public License as published by
*!  the Free Software Foundation, either version 3 of the License, or
*!  (at your option) any later version.
*!
*!  This program is distributed in the hope that it will be useful,
*!  but WITHOUT ANY WARRANTY; without even the implied warranty of
*!  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*!  GNU General Public License for more details.
*!
*!  You should have received a copy of the GNU General Public License
*!  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*! -----------------------------------------------------------------------------**
*!  $Log: cxsdram353.c,v $
*!  Revision 1.1.1.1  2007/08/17 10:23:18  elphel
*!  This is a fresh tree based on elphel353-2.10
*!
*!  Revision 1.7  2007/08/17 10:23:18  spectr_rain
*!  switch to GPL3 license
*!
*!  Revision 1.6  2007/07/20 10:17:45  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.1.1.1  2007/02/23 10:11:48  elphel
*!  initial import into CVS
*!
*!  Revision 1.8  2006/09/19 16:22:14  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.7  2006/09/02 22:04:17  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.6  2006/09/02 00:19:49  spectr_rain
*!  lock sensor while readrawimage
*!
*!  Revision 1.5  2006/09/01 21:36:59  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.4  2006/09/01 21:16:00  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.3  2006/09/01 21:02:00  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.2  2006/09/01 18:54:40  spectr_rain
*!  some fixes for /dev/ccam_img (image.raw)
*!
*!  Revision 1.1.1.1  2006/07/11 19:14:59  spectr_rain
*!  unwork with less than 5MPx Micron sensor, initial branch
*!
*!  Revision 1.2  2005/05/10 21:08:49  elphel
*!  *** empty log message ***
*!

P_ACTUAL_WIDTH2 and P_ACTUAL_HEIGHT2 increased by 4 each to include 1
*/

/****************** INCLUDE FILES SECTION ***********************************/
#define P_ACTUAL_WIDTH2  ( get_imageParamsR(P_ACTUAL_WIDTH)+4 )
#define P_ACTUAL_HEIGHT2 ( get_imageParamsR(P_ACTUAL_HEIGHT)+4 )

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/autoconf.h>

#include <asm/system.h>
//#include <asm/svinto.h>
#include <asm/io.h>

#include <asm/irq.h>

#include <asm/delay.h>
#include <asm/uaccess.h>

#include <asm/elphel/c313a.h>

#include "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr 

#include "x3x3.h"
#include "cc3x3.h"
#include "cxsdram.h"

#define D(x)
//#define MD3(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD3(x)

static int linebuf_fpn[4096];
static int lineinbuf_fpn;               // should be -1 after frame acquisition, etc - program sensor
static int linebufdirty_fpn = 0;
static int linebuf_img[4096];
static int lineinbuf_img;               // should be -1 after frame acquisition, etc - program sensor


int *x313_fpn_readline(int line, int ignore) {  // read fpn line to buffer (returns buffer address). ignore - contents does not matter (to write over)
        int ntilex, padlen, sa, nw, n, i, li;   //nw - number of 32-bit words to read)

        if(line == lineinbuf_fpn)
                return linebuf_fpn;             // cache hit
        if((port_csp0_addr[X313_WA_SD_MODE] & 3) != 3)
                return NULL;                    // SDRAM was not enabled or refresh was not on
        if(linebufdirty_fpn) {
                if (x313_fpn_writeline() < 0)
                        return NULL;            // failed to write buffer
        }
        if(ignore)
                return linebuf_fpn;
        nw = ((P_ACTUAL_WIDTH2 + 1) >> 1);
        ntilex = ((nw + 3) >> 2);
//      padlen = ((ntilex + 15) >> 4);
        padlen = ((ntilex + 31) >> 5);
//      sa = X313_MAP_FPN + ((padlen * line) << 7);
        sa = X313_MAP_FPN + ((padlen * line) << 8);

//      printk(" *%x*",sa);
        X313_INIT_SDCHAN(3, 0, 0, 0, sa, 0x3ff, 0xfff); // 4096 rows of 32x256 16-bit words each - 64MB > than memory
//      enable channel if it was not already
        port_csp0_addr[X313_WA_SD_MODE] |= 0x23;        // channel3 enabled, refresh, sdram
        li = 0;
//      n = nw;
        while (nw > 0) {
                i = 1000;
                D(printk("wait "));
                while (((i--) > 0) && !X313_SR(PIORDY));
                udelay(1);
                D(printk("ready, i=%d\n", (int) i));
                if (i == 0)
                        return NULL;            // page not ready
                n = nw;
                if (n > 128)
                        n = 128;
                i = port_csp4_addr[X313_WA_SD_PIOWIN];  // will return garbage (because of latency), prepares to the next read, increments address
                for (i = 0; i < n; i++)
                        linebuf_fpn[li++] = port_csp4_addr[X313_WA_SD_PIOWIN];
                nw -= n;
                if (nw > 0)
                        port_csp0_addr[X313_WA_SDPIO_NEXT] = 0; // next page (all but last)
        }
        lineinbuf_fpn = line;
        return linebuf_fpn;
}

int x313_fpn_writeline(void) {  // write current line of FPN data to SDRAM, clear "dirty" flag
        int ntilex, padlen, sa, nw, n, i, li;

        if(linebufdirty_fpn == 0)
                return 0;
//  if((lineinbuf_fpn >= 0) && (lineinbuf_fpn < 1024)) {
        if(lineinbuf_fpn >= 0) {
                if((port_csp0_addr[X313_WA_SD_MODE] & 3) != 3)
                        return -1;                      // SDRAM was not enabled or refresh was not on
                nw = ((P_ACTUAL_WIDTH2 + 1) >> 1);
                ntilex = ((nw + 3) >> 2);
//              padlen = ((ntilex + 15) >> 4);
                padlen = ((ntilex + 31) >> 5);
//              sa = X313_MAP_FPN + ((padlen * lineinbuf_fpn) << 7);
                sa = X313_MAP_FPN + ((padlen * lineinbuf_fpn) << 8);
//              X313_INIT_SDCHAN(3, 0, 1, 0, sa, 0xff, 0x7ff);   // 2048 rows of 16x128 16-bit words each
                X313_INIT_SDCHAN(3, 0, 1, 0, sa, 0x3ff, 0xfff); // 4096 rows of 32x256 16-bit words each - 64MB > than memory

                // enable channel if it was not already
                port_csp0_addr[X313_WA_SD_MODE] |= 0x23;        // channel3 enabled, refresh, sdram
                li = 0;
//              n = nw;
                while (nw > 0) {
//              if(!(li & 0x3f)) { // wait SDRAM ready (here 0x3f, as li addresses 32-bit words)
                        i = 1000;
                        D(printk("wait "));
                        while (((i--) > 0) && !X313_SR(PIORDY));
                        udelay(1);
                        D(printk("ready, i=%d\n", (int) i));
                        if (i == 0)
                                return -1;              // page not ready
//                      }
                        n = nw;
                        if (n > 128)
                                n = 128;
                        for (i = 0; i < n; i++)
                                port_csp0_addr[X313_WA_SD_PIOWIN] = linebuf_fpn[li++];
                        nw -= n;
                        port_csp0_addr[X313_WA_SDPIO_NEXT] = 0; // skip 8x32 data (all but last)
                }
                // write the last page if it was partial
//              while(li & 0x3f) {
//                      port_csp0_addr[X313_WA_SDPIO_NEXT] = 0; // skip 8x32 data (all but last)
//                      li += 8;
//              }
                // wait page is written
                i = 1000;
                while (((i--) > 0) && !X313_SR(PIOWEMPTY))
                        udelay(1);
                if (i == 0)
                        return -EFAULT;         // page not ready
        }
        linebufdirty_fpn = 0;
        return 0;
}


ssize_t x313_fpn_read(struct file * file, char *buf, size_t count, loff_t * off) {
        unsigned long p, fsz, y, xb, xbl, left;
        char *bp = buf;
        char *mp;

        MD3(printk("x313_fpn_read, count=%x, off=%x\n", (int) count, (int) off));
//      p = file->f_pos;
   p = *off;
//      printk("x313_fpn_read (%x/%x) ", (int) p, (int) count);
        fsz = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << 1;
//      if(p >= fsz)  return -EINVAL; // bigger than SDRAM
        if((p + count) > fsz) { // truncate count
                count = fsz - p;
        }
        left = count;
        while(left > 0) {
                // calculate start address, pointed by p;
//              printk(":%x:",(int) p);
                y = (p / P_ACTUAL_WIDTH2) >> 1;
//              printk("+%x+",(int) y);
                xb = p - y * (P_ACTUAL_WIDTH2 << 1);
                xbl = (P_ACTUAL_WIDTH2 << 1) - xb;
                if(xbl > left)
                        xbl = left;                     // xbl - number of bytes left in the same line
                if(!(mp = (char *)x313_fpn_readline(y, 0)))
                        return -EFAULT;         // read SDRAM error
//              copy data
                mp += xb;
//              D(printk("copytouser, ibp=%x, nb=%x\n", (int) ibp, (int) nb));
                if(copy_to_user(bp, mp, xbl))
                        return -EFAULT;
                left -= xbl;
                p += xbl;
                bp += xbl;
        }                                                       // while (left >0)
//      file->f_pos += count;
   *off+=count;
        return count;
}

ssize_t x313_fpn_write(struct file * file, const char *buf, size_t count, loff_t * off) {
        unsigned long p, fsz, y, xb, xbl, left;
        const char *bp = buf;
        char *mp;

//  MD3(printk("x313_fpn_write, count=%x, off=%x\n", (int) count, (int) off));
//      p = file->f_pos;
   p=*off;
        fsz = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << 1;
        if (p >= fsz)
                return -EINVAL;                 // bigger than SDRAM
        if ((p + count) > fsz) {        // truncate count
                count = fsz - p;
        }
        left = count;
        while (left > 0) {
                // calculate start address, pointed by p;
                y = (p / P_ACTUAL_WIDTH2) >> 1;
                xb = p - y * (P_ACTUAL_WIDTH2 << 1);
                xbl = (P_ACTUAL_WIDTH2 << 1) - xb;
                if (xbl > left)
                        xbl = left;                     // xbl - number of bytes left in the same line
                // do we need to overwrite a whole line? ((xb==0) && (xbl==(P_ACTUAL_WIDTH2<<1)))
                if (!(mp = (char *) x313_fpn_readline(y, ((xb == 0) && (xbl == (P_ACTUAL_WIDTH2 << 1))))))
                        return -EFAULT;         // read SDRAM error
                // copy to line buffer
                mp += xb;
                if (copy_from_user(mp, bp, xbl))
                        return -EFAULT;
                left -= xbl;
                p += xbl;
                bp += xbl;
                linebufdirty_fpn = 1;   // mark as modified
        }                                                       // while (left >0)
//      file->f_pos += count;
   *off+=count;
        return count;
}


loff_t x313_fpn_lseek(struct file * file, loff_t offset, int orig) {

        //  orig 0: position from begining
        //  orig 1: relative from current position
        //  orig 2: position from last address


        unsigned long fsz;

        fsz = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << 1;

        MD3(printk("fpn_lseek %x\n", (int) offset));

        D(printk("fsdram_lseek\n"));

        switch (orig) {
        case 0:
                file->f_pos = offset;
                break;
        case 1:
                file->f_pos += offset;
                break;
        case 2:
                file->f_pos = fsz + offset;
                break;
        default:
                return -EINVAL;
        }

        // truncate position
        if (file->f_pos < 0) {
                file->f_pos = 0;
                return (-EOVERFLOW);
        }

        if (file->f_pos > fsz) {
                file->f_pos = fsz;
                return (-EOVERFLOW);
        }
        return (file->f_pos);
}


// ----------------------------------------
int *x313_frame_readline(int line) {    // read image line to buffer (returns buffer address)- may be modified to use DMA. Also - cache multiple lines? (for color)
        int ntilex, padlen, sa, nw, n, i, li;

//      int line2;
//      int buf128[128];
//      int d;
//      int d, pw;
//      unsigned char *cbuf128 = (unsigned char *) buf128;
//      unsigned char *clinebuf = (unsigned char *) linebuf_img;
//      unsigned short *sbuf128 = (unsigned short *) buf128;
//      unsigned short *slinebuf = (unsigned short *) linebuf_img;

        if(line == lineinbuf_img)
                return linebuf_img;             // cache hit
        if((port_csp0_addr[X313_WA_SD_MODE] & 3) != 3)
                return NULL;                    // SDRAM was not enabled or refresh was not on
        lineinbuf_img = line;
        if((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME))     // n - number of 32-bit words to read 
                nw = ((P_ACTUAL_WIDTH2 + 3) >> 2);
        else
                nw = ((P_ACTUAL_WIDTH2 + 1) >> 1);
        ntilex = ((nw + 3) >> 2);
//  padlen = ((ntilex + 15) >> 4);
        padlen = ((ntilex + 31) >> 5);

// in external (or virtual) trigger mode always 2 frames acquired (exactly), so there is no need to find the boarder
// just add 2 frames.
// so read line into buffer in any case

        sa = X313_MAP_FRAME + ((padlen * line) << 8);

//pw = P_ACTUAL_WIDTH2;
        X313_INIT_SDCHAN(3, 0, 0, 0, sa, 0x3ff, 0xfff); // 4096 rows of 32x256 16-bit words each - 64MB > than memory
//printk("readline(): line1 == %d, sa == 0x%08X; nw == %d, padlen == %d, P_ACTUAL_WIDTH2 == %d\r\n", line, sa, nw, padlen, pw);

        // enable channel if it was not already
        port_csp0_addr[X313_WA_SD_MODE] |= 0x23;        // channel3 enabled, refresh, sdram
        li = 0;
        while(nw > 0) {
                i = 1000;
                D(printk("wait "));
                while(((i--) > 0) && !X313_SR(PIORDY));
                udelay(1);
                D(printk("ready, i = %d\n", (int) i));
                if(i == 0)
                        return NULL;            // page not ready
                n = nw;
                if(n > 128)
                        n = 128;
                i = port_csp4_addr[X313_WA_SD_PIOWIN];  // will return garbage (because of latency), prepares to the next read, increments address
                for(i = 0; i < n; i++)
//                      linebuf_img[li++] = 0x13141516;
                        linebuf_img[li++] = port_csp4_addr[X313_WA_SD_PIOWIN];
                nw -= n;
                if(nw > 0)
                        port_csp0_addr[X313_WA_SDPIO_NEXT] = 0; // next page (all but last)
        }

        // now add line from the second frame if external (or virtual) trigger
/*
        if(get_imageParamsR(P_TRIG) > 0) {      //(external)
                line2 = line + P_ACTUAL_HEIGHT2;        // second frame
//              sa = X313_MAP_FRAME + ((padlen * line2) << 7);
                sa = X313_MAP_FRAME + ((padlen * line2) << 8);
//              X313_INIT_SDCHAN(3, 0, 0, 0, sa, 0xff, 0x7ff);   // 2048 rows of 16x128 16-bit words each
                X313_INIT_SDCHAN(3, 0, 0, 0, sa, 0x3ff, 0xfff); // 4096 rows of 32x256 16-bit words each - 64MB > than memory
printk("readline(): line2 == %d, sa == 0x%08X\r\n", line, sa);
                // enable channel if it was not already
                port_csp0_addr[X313_WA_SD_MODE] |= 0x23;        // channel3 enabled, refresh, sdram

                li = 0;
                while(nw > 0) {
                        i = 1000;
                        while(((i--) > 0) && !X313_SR(PIORDY));
                        udelay(1);
                        if(i == 0)
                                return NULL;    // page not ready
                        n = nw;
                        if(n > 128)
                                n = 128;
//                      i = port_csp4_addr[X313_WA_SD_PIOWIN];  // will return garbage (because of latency), prepares to the next read, increments address
                        for(i = 0; i < n; i++)
                                buf128[i] = port_csp0_addr[X313_WA_SD_PIOWIN];
                        if((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME)) {
                                for(i = 0; i < 512; i++) {
                                        d = clinebuf[li];
                                        d += cbuf128[i];
                                        d -= get_imageParamsR(P_FATZERO);
                                        if (d < 0)
                                                d = 0;
                                        else if (d > 255)
                                                d = 255;
                                        clinebuf[li++] = d;
                                }
                        } else {
                                for(i = 0; i < 256; i++) {
                                        d = slinebuf[li];
                                        d += sbuf128[i];
                                        d -= get_imageParamsR(P_FATZERO);
                                        if(d < 0)
                                                d = 0;
                                        else if(d > 65535)
                                                d = 65535;
                                        slinebuf[li++] = d;
                                }
                        }
                        nw -= n;
                        if(nw > 0)
                                port_csp0_addr[X313_WA_SDPIO_NEXT] = 0; // next page (all but last)
                }
        }
*/
        return linebuf_img;
}

static int lock_flag = 0;

int slock = 0;
wait_queue_head_t vack_wait_queue;

void ch0_lock(void) {
        unsigned long t = port_csp0_addr[0x27];
        t = t & ~(1 << 2);
        port_csp0_addr[0x27] = t;
}

void ch0_dis(void) {
//      init_waitqueue_head(&vack_wait_queue);
        slock = 2;
        while(slock == 2)
                yield();
//              sched_yield();
//      interruptible_sleep_on(&vack_wait_queue);
}

void ch0_en(void) {
        unsigned long t = port_csp0_addr[0x27];
        t |= 1 << 2;
        port_csp0_addr[0x27] = t;
        slock = 0;
}

ssize_t x313_frame_read(struct file * file, char *buf, size_t count, loff_t * off) {
        unsigned long p, fsz, y, xb, xbl, left;
        char *bp = buf;
        char *mp;

        if(lock_flag == 0) {
                lock_flag = 1;
                printk("frame read first time - lock sensor and wait it\r\n");
//              if(get_imageParamsR(P_BITS) <= 8 || get_imageParamsR(P_BITS) > 16)
//                      sensor_stop(1);
//              else
//              sensor_stop(0);
                ch0_dis();
        }

//      MD3(printk("x313_frame_read, count=%x, off=%x\n", (int)count, (int)off));
//      p = file->f_pos;
   p=*off;
//      printk("x313_frame_read, count == %x, off == %x, f_pos == %d\r\n", (int)count, (int)off, p);
        fsz = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << (((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME)) ? 0 : 1);
//  if(p >= fsz)  return -EINVAL; // bigger than SDRAM
        if((p + count) > fsz) { // truncate count
                count = fsz - p;
        }
        left = count;
        while(left > 0) {
                // calculate start address, pointed by p;
                if((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME)) {
                        y = p / P_ACTUAL_WIDTH2;
                        xb = p - y * P_ACTUAL_WIDTH2;
                        xbl = P_ACTUAL_WIDTH2 - xb;
                } else {
                        y = (p / P_ACTUAL_WIDTH2) >> 1;
                        xb = p - y * (P_ACTUAL_WIDTH2 << 1);
                        xbl = (P_ACTUAL_WIDTH2 << 1) - xb;
                }
                if(xbl > left)
                        xbl = left;                     // xbl - number of bytes left in the same line
//              if(!(mp = (char *)x313_frame_readline(y + ((P_ACTUAL_HEIGHT2 * get_imageParamsR(P_PAGE_READ)) << (get_imageParamsR(P_TRIG) ? 1 : 0))))) {
                if(!(mp = (char *)x313_frame_readline(y + P_ACTUAL_HEIGHT2 * get_imageParamsR(P_PAGE_READ)))) {
printk("read SDRAM error!\r\n");
                        return -EFAULT;         // read SDRAM error
                }
// copy data
                mp += xb;
//    D(printk ("copytouser, ibp=%x, nb=%x\n", (int) ibp, (int) nb));
                if(copy_to_user(bp, mp, xbl)) {
printk("copy_to_user error!\r\n");
                        return -EFAULT;
                }
                left -= xbl;
                p += xbl;
                bp += xbl;
        }                                                       // while (left >0)
//      file->f_pos += count;
   *off+=count;
//printk("count == %d\r\n", count);
        return count;
}


loff_t x313_frame_lseek(struct file * file, loff_t offset, int orig) {
/*
 *  orig 0: position from begning of eeprom
 *  orig 1: relative from current position
 *  orig 2: position from last eeprom address
 */

        unsigned long fsz;
        fsz = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << (((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME)) ? 0 : 1);

//      MD3(printk("frame_lseek %x\n", (int) offset));

        switch (orig) {
        case 0:
                file->f_pos = offset;
                break;
        case 1:
                file->f_pos += offset;
                break;
        case 2:
                file->f_pos = fsz + offset;
                break;
        default:
                return -EINVAL;
        }

        /* truncate position */
        if (file->f_pos < 0) {
                file->f_pos = 0;
                return (-EOVERFLOW);
        }

        if (file->f_pos > fsz) {
                file->f_pos = fsz;
                return (-EOVERFLOW);
        }
        return (file->f_pos);
}

int x313_frame_open(struct inode *inode, struct file *filp) {   // set filesize
        inode->i_size = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << (((get_imageParamsR(P_BITS) == 8) && !get_imageParamsR(P_BGFRAME)) ? 0 : 1);
        linebufdirty_fpn = 0;
        lineinbuf_img = -1;
//      MD3(printk("frame_open, size = %x\n", (int) inode->i_size));
//      printk("frame_open, size = 0x%08X; %d\n", (int)inode->i_size, (int)inode->i_size);
        return 0;
}

void x313_frame_release(void) {

        if(lock_flag == 1) {
                printk("frame release - release sensor\r\n");
//              sensor_release();
                ch0_en();
                lock_flag = 0;
        }
}

int x313_fpn_open(struct inode *inode, struct file *filp) {     // set filesize
        inode->i_size = (P_ACTUAL_WIDTH2 * P_ACTUAL_HEIGHT2) << 1;
        linebufdirty_fpn = 0;
        lineinbuf_fpn = -1;
        MD3(printk("fpn_open, size = %x\n", (int) inode->i_size));
        return 0;
}

void x313_fpn_release(void) {
        if(linebufdirty_fpn)
                x313_fpn_writeline();
        MD3(printk("fpn_release\n"));

}

void x313_f_invalidate(void) {  // to be called when page number is changed. Write should not be in progress
        linebufdirty_fpn = 0;
        lineinbuf_fpn = -1;
        lineinbuf_img = -1;
}

---