Selfloopback testing on dm368 ECDK boards

Hi Venkat,

It looks like the application is failing during an i2c read for the sensor. You are using the Aptina sensor, right? Can you make sure the sensor connection to the board is proper?

Can you explain the error scenario? Was the same setup working previously?

Regards,

Sithara

Hi Sithara,

I am using the MT9P031 sensor on Dm365 ECDK Board , I run previously application on linux 2.6.18 kernel it working fine,Now I am working linux-staging kernel(2.6.32) with av_capture. the following is working logs. please can you suggest me how to solve this one.

# ./selfloopback.sh
CSL: Module install successful, device major num = 253
CSL: Module version 0.10.00, built on Jul 26 2010 16:46:50
I2C: Module install successful, device major num = 252
DMA: Module install successful, device major num = 251
DRV: Module install successful
DRV: Module built on Jul 26 2010 16:46:54
DRV: EDMACC.QUEPRI  = 00000777
DRV: SYSTEM.MSTPRI0 = 00550011
DRV: SYSTEM.MSTPRI1 = 00000000
DRV: ISP.BCR        = 00000002
CMEMK module: built on Jul 26 2010 at 16:45:08
  Reference Linux version 2.6.18
  File /work/eucdk/webcam_15/dvsdk_2_10_01_18/linuxutils_2_24_03/packages/ti/sdo/linuxutils/cmem/src/module/cmemk.c
allocated heap buffer 0xc7000000 of size 0x4400000
CMEM Range Overlaps Kernel Physical - allowing overlap
CMEM phys_start (0x1000) overlaps kernel (0x80000000 -> 0x83c00000)
cmemk initialized
EDMAK module: built on Jul 26 2010 at 16:45:11
  Reference Linux version 2.6.18
  File /work/eucdk/webcam_15/dvsdk_2_10_01_18/linuxutils_2_24_03/packages/ti/sdo/linuxutils/edma/src/module/edmak.c
IRQK module: built on Jul 26 2010 at 16:45:12
  Reference Linux version 2.6.18
  File /work/eucdk/webcam_15/dvsdk_2_10_01_18/linuxutils_2_24_03/packages/ti/sdo/linuxutils/irq/src/module/irqk.c
irqk initialized

 AVSERVER UI: Initializing.

DRV_SyncRst: module = 47, domain = 0, state = 0

DRV_SyncRst: module = 47, domain = 0, state = 3
 
 CLK Hz,
 ARM   Hz =  297000000
 DDR   Hz =  270000000
 VPSS  Hz =  270000000
 IMCOP Hz =  270000000
 
 DRV LDC: GetConfig 0004 0x0


 DEBUG WINDOW MODE

 AVSERVER UI: Starting in mode 8
 CAPTURE: Opening imager MICRON_MT9P031_5MP.
 Sensor Mode Info,
 Width      = 1280
 Height     =  740
 fps        =   30
 Bin Enable =    1
 
 Sensor Frame Timing Info,
 fps                  = 30
 t_frame (ns)         = 33333334.000000
 t_row   (ns)         = 43937.500000
 t_pclk  (ns)         = 15.625000
 W                    = 1280
 H                    = 740
 SW                   = 758
 SD                   = 0
 HB                   = 766
 VB                   = 8
 HBmin                = 0
 VBmin                = 0
 f_pclk               = 64000000
 shutterOverhead (ns) = 13156.250000
 col_size             = 2559
 row_size             = 1479
 col_skip             = 1
 row_skip             = 1
 col_bin              = 1
 row_bin              = 1
 col_start            = 16
 row_start            = 272
 pll_M                = 16
 pll_N                = 1
 pll_DIV              = 2
 
 CAPTURE: Opening ISIF.
 CAPTURE: Opening H3A.
TI Setting Applied
 
 H3A Settings,
 AEWB Win Start H       = 0
 AEWB Win Start V       = 2
 AEWB Win Num H         = 32
 AEWB Win Num V         = 12
 AEWB Win Width         = 40
 AEWB Win Height        = 60
 AEWB Win Inc H         = 6
 AEWB Win Inc V         = 6
 AEWB Win Pixels/Color  = 70
 
 CAPTURE: Opening IPIPE.

 Default Icon TI Logo

 Default Icon TI Logo

 DM365MM Init SuccessfulRate Control Type: IVIDEO_STORAGE ALG: VidEnc: DynamicParams: bitrate = 1000000 bps, Key-frame-interval = 30
 ALG: VidEnc: mbMvOutEnable =1
 ALG: VidEnc: encStatus.bufInfo.minNumOutBufs is 2
 ALG: VidEnc: encStatus.bufInfo.minOutBufSize[0] is 518400
 ALG: VidEnc: encStatus.bufInfo.minOutBufSize[1] is 10800
 ALG: VidEnc: XDM_GETBUFINFO: min in bufs:2 buf(0):353280 buf(1):176640
 ALG: VidEnc: pObj->MV algName =h264enc
 ALG: VidEnc: pObj->MV_Size =10800
 ALG: VidEnc: Default is Disable MV data output
 DECODE:decodeTskCreated
 DECODE: Decode in progress!!!

Receive (RTP) on port 1234 session 4944024


Send (RTP) to 127.0.0.1:1234 session: 4945400

 [OSA_FILE ] Reading file [startfile.264] ... Done. [2000 bytes]
FF: FF open
DavinciDisplay DavinciDisplay.1: Before finishing with S_FMT:
layer.pix_fmt.bytesperline = 736,
 layer.pix_fmt.width = 720,
 layer.pix_fmt.height = 480,
 layer.pix_fmt.sizeimage =529920
 [OSA_FILE ] ReaDavinciDisplay DavinciDisplay.1: pixfmt->width = 720,
 layer->layer_info.config.line_length= 736
ding file [/mnt/mmc/facerecognition.bin] ... Done. [1256 bytes]

 FR : 3 users registered from exsiting face album
FF: FF open done.
IPNC_0.6 (renxiang@renxiang-desktop) (gcc version 4.2.0 (MontaV
 IPNC AUTO_IRIS = 1 #####################
TI 2A Created
TI2A weight matrix: width = 32, height = 12
EE SETUP SHIFT VALUE: 4
dbg1: audio sample rate 16000

 ##### aic3x->master = 1

 ##### Fsref = 48000

 ##### bypass_pll = 0, AIC3X_GPIOB_REG = 0

 ##### params_rate(params) = 16000

 #### aic3x->sysclk = 27000000, codec_clk = 3640

 ##### pll_j=3, pll_d=6400, pll_r=1, pll_p=1
AUDIOCAP : period size = 320 frames
AUDIOCAP : period time = 20000 us

Speech Sent (RTP) on port 1236 session 5039856 ip 127.0.0.1

 ##### aic3x->master = 1

 ##### Fsref = 48000

 ##### bypass_pll = 0, AIC3X_GPIOB_REG = 0

 ##### params_rate(params) = 16000

 #### aic3x->sysclk = 27000000, codec_clk = 3640

 ##### pll_j=3, pll_d=6400, pll_r=1, pll_p=1
AUDIOPLAY : period size = 320 frames
AUDIOPLAY : period time = 20000 us

Audio Receive (RTP) on port 1236 session 5042960
Creat queue id:0
queue id:0
 AVSERVER MAIN: Assigning Decode buffers: 5 of size 102528 bytes
 CAPTURE: Starting IPIPE.
 CAPTURE: Starting ISIF.
 CAPTURE: Starting imager.
---DRV_i2cRead16()=40---
---DRV_i2cWrite16()=8040---
 CAPTURE: Starting H3A.
 Type v to start call :

Thanks

Venkatakrishna

Venkat,

The log who sent in your last mail is a working log, right? You just need to type 'v' followed by Enter to start call. So the first log corresponds to linux 2.6.32 and the second one corresponds to linux 2.6.18? We have not tried linux 2.6.32. Is there any particular reason why you want to migrate to 2.6.32?

If you want to proceed with 2.6.32, then you can try the following: We have made some modifications to the 2.6.18 we use for ECDK. So what you can do is compare the modified 2.6.18 with original 2.6.18 and then migrate the changes to your 2.6.32 kernel. You should also use the same defconfig used in 2.6.18.

Regards,

Sithara

Hi Sithara,

We ported android on dm365 ECDK. that why we are using linux-staging kernel (2..6.32). I changed dev_i2c.c file according to linux-staging kernel(2.6.32). I am attaching the dev_i2c.c file here please can u verify what i changed was correct or not


Changed file of dev_i2c.c

#include <dev_i2c.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>           /* everything... */
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/i2c.h>
#include <linux/kernel.h>       /* printk() */
#include <linux/slab.h>         /* kmalloc() */
#include <asm/uaccess.h>        /* copy_*_user */


static unsigned short gI2C_curAddr;

typedef struct {

  int devAddr;

  struct i2c_client client;   //!< Data structure containing general access routines.
  struct i2c_driver driver;   //!< Data structure containing information specific to each client.
 
  char name[20];
  int nameSize;
  int users;
 
} I2C_Obj;

typedef struct {

  struct cdev cdev;             /* Char device structure  */
  int     major;
  struct semaphore semLock;
   
  I2C_Obj *pObj[I2C_DEV_MAX_ADDR];

  uint8_t reg[I2C_TRANSFER_BUF_SIZE_MAX];
  uint8_t buffer[I2C_TRANSFER_BUF_SIZE_MAX*4];
 
} I2C_Dev;

I2C_Dev gI2C_dev;

static int __devexit I2C_remove(struct i2c_client *client)
{
    struct I2C_Obj *pObj = i2c_get_clientdata(client);

    kfree(pObj);
    return 0;
}
static int I2C_probe(struct i2c_client *client,const struct i2c_device_id *id)
{
    struct  I2C_Obj *pObj;
    struct device *dev = &client->dev;

    pObj = kzalloc(sizeof(I2C_Obj), GFP_KERNEL);
    if (pObj == NULL) {
        dev_err(dev, "failed to create our state\n");
        return -ENOMEM;
    }
    //pObj->client = &client; //venkat
    i2c_set_clientdata(client, pObj);
    return 0;

}


static const struct i2c_device_id mt9p031_id[] = {
    { "mt9p031", 0x48 },
    { }
};

MODULE_DEVICE_TABLE(i2c,mt9p031_id);

void *I2C_create(int devAddr)
{
    int ret;
    struct i2c_driver *driver;
    struct i2c_client *client = client;
   
    I2C_Obj *pObj;

    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: Driver registration in progress for address %x...\n", devAddr);
    #endif
   
    devAddr >>= 1;
   
    if(devAddr>I2C_DEV_MAX_ADDR)
      return NULL;
   
   if(gI2C_dev.pObj[devAddr]!=NULL)
   {
      // already allocated, increment user count, and return the allocated handle
     
      gI2C_dev.pObj[devAddr]->users++;
     
      return gI2C_dev.pObj[devAddr];
    }
   
    pObj = (void*)kmalloc( sizeof(I2C_Obj), GFP_KERNEL);

    gI2C_dev.pObj[devAddr] = pObj;
   
   memset(pObj, 0, sizeof(I2C_Obj));
 
    pObj->client.adapter = NULL;
    pObj->users++;
   
    pObj->devAddr = devAddr;
   
    gI2C_curAddr = pObj->devAddr;
   
    driver = &pObj->driver;

    driver->driver.name ="mt9p031";
    driver->id_table=mt9p031_id;
    driver->remove = I2C_remove;
    driver->probe  = I2C_probe;

   
     #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: i2c_add_driver() ...\n");
    #endif

    if((ret = i2c_add_driver(driver)))
    {
        printk( KERN_ERR "I2C: ERROR: Driver registration failed (address=%x), module not inserted.\n", pObj->devAddr);
    }

    if(ret<0)
     {
        gI2C_dev.pObj[pObj->devAddr] = NULL;
   
          kfree(pObj);
        return NULL;
    }
   
    return pObj;
}
int I2C_delete(I2C_Obj *pObj)
{
    if(pObj==NULL)
        return -1;
 
      pObj->users--;
 
      if(pObj->users<=0)
    {
        if(pObj->client.adapter!=NULL)
     {
        i2c_del_driver(&pObj->driver);
         // if(i2c_del_driver(&pObj->driver))
          printk(KERN_ERR "I2C: ERROR: Driver remove failed (address=%x), module not removed.\n", pObj->devAddr);
   
          pObj->client.adapter = NULL;
   
          gI2C_dev.pObj[pObj->devAddr] = NULL;
       
          kfree(pObj);   
        }
      }
   
      return 0;
}

int I2C_read(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
  uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[1];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV; 

  if(dataSize<=0||dataSize>4)
    return -1;
   
  for(i=0; i<count; i++) {
        msg->addr  = client->addr;
        msg->flags = 0;
        msg->len   = 1;
        msg->buf   = data;
        data[0]    = reg[i];
        err = i2c_transfer(client->adapter, msg, 1);
        if(err<0) {
          printk( KERN_ERR " i2c_transfer(0x%x, %x)\n", msg->addr, msg->buf[0]);
        }

        if (err >= 0)
        {
            msg->flags = I2C_M_RD;
      msg->len   = dataSize;
            err = i2c_transfer(client->adapter, msg, 1);
            if (err >= 0)
            {
              if(dataSize==1) {
                  buffer[i] = data[0];
            } else
            if(dataSize==2) {
              buffer[2*i]   = data[1];
              buffer[2*i+1] = data[0];             
            }
            }
        }
    if (err<0)
      return -ENODEV;
  }
 
  return 0;
}

int I2C_write(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
  uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[8];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV; 
 
  if(dataSize<=0||dataSize>4)
    return -1;
   
  for(i=0; i<count; i++) {
 
    msg->addr = client->addr;
        msg->flags= 0;
        msg->buf  = data;
       
        data[0] = reg[i];
       
        if(dataSize==1) {
          data[1]  = buffer[i];
          msg->len = 2;         
    }    else   
        if(dataSize==2) {
          data[1] = buffer[2*i+1];
          data[2] = buffer[2*i];
          msg->len = 3;
        }
        err = i2c_transfer(client->adapter, msg, 1);
    if( err < 0 )
      return err;
  }
 
  return 0;
}

int I2C_devOpen(struct inode *inode, struct file *filp)
{
  int minor, major;

  minor = iminor(inode);
  major = imajor(inode);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devOpen()   , %4d, %2d \n", major, minor);
#endif

  filp->private_data = NULL;

  return 0;                /* success */
}

int I2C_devRelease(struct inode *inode, struct file *filp)
{
  I2C_Obj *pObj;

  pObj = (I2C_Obj *)filp->private_data;
 
  if(pObj==NULL)
    return 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devRelease(), %x, %d \n", pObj->devAddr, pObj->users);
#endif

  I2C_delete(pObj);

  return 0;
}

int I2C_devIoctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
  I2C_Obj *pObj;
  int status=0;
  I2C_TransferPrm transferPrm;
 
  pObj = (I2C_Obj *)filp->private_data;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devIoctl() \n");
#endif

  if(!I2C_IOCTL_CMD_IS_VALID(cmd))
    return -1;

  cmd = I2C_IOCTL_CMD_GET(cmd);

  down_interruptible(&gI2C_dev.semLock);     
 
  switch(cmd)
  {
    case I2C_CMD_SET_DEV_ADDR:
      filp->private_data = I2C_create(arg);
      if(filp->private_data==NULL)
        status = -1;
      break;
     
    case I2C_CMD_WRITE:
     
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count); 
        status |= copy_from_user(gI2C_dev.buffer, transferPrm.value, transferPrm.count*transferPrm.dataSize); 
        if(status==0) {
          status = I2C_write(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
        }
      }
           
      break;
    case I2C_CMD_READ: 
   
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);       
        if(status==0) {
          status = I2C_read(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
          if(status==0) {
            status = copy_to_user(transferPrm.value, gI2C_dev.buffer, transferPrm.count*transferPrm.dataSize);
          }
        }
      }
     
      break;
    default:
      status = -1;
      break;   
  }

  up(&gI2C_dev.semLock);     

  return status;
}


struct file_operations gI2C_devFileOps = {
  .owner = THIS_MODULE,
  .open = I2C_devOpen,
  .release = I2C_devRelease,
  .ioctl = I2C_devIoctl,
};

int I2C_devInit(void)
{
  int     result, i;
  dev_t   dev = 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devInit() \n");
#endif

  result = alloc_chrdev_region(&dev, 0, 1, I2C_DRV_NAME);

  if (result < 0) {
    printk(KERN_WARNING "I2C: can't get device major num \n");
    return result;
  }
 
  for(i=0; i<I2C_DEV_MAX_ADDR; i++)
  {
    gI2C_dev.pObj[i]=NULL;
  }

  gI2C_dev.major = MAJOR(dev);
 
  sema_init(&gI2C_dev.semLock, 1);

  cdev_init(&gI2C_dev.cdev, &gI2C_devFileOps);

  gI2C_dev.cdev.owner = THIS_MODULE;
  gI2C_dev.cdev.ops = &gI2C_devFileOps;

  result = cdev_add(&gI2C_dev.cdev, dev, 1);

  if (result)
    printk(KERN_WARNING "I2C: Error [%d] while adding device [%s] \n", result, I2C_DRV_NAME);

  printk(KERN_INFO "I2C: Module install successful, device major num = %d \n", gI2C_dev.major);

  return result;
}

void I2C_devExit(void)
{
  dev_t   devno = MKDEV(gI2C_dev.major, 0);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devExit() \n");
#endif

  cdev_del(&gI2C_dev.cdev);

  unregister_chrdev_region(devno, 1);
}

orginal  file of dev_i2c.c



 
#include <dev_i2c.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>           /* everything... */
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/i2c.h>
#include <linux/kernel.h>       /* printk() */
#include <linux/slab.h>         /* kmalloc() */
#include <asm/uaccess.h>        /* copy_*_user */


static unsigned short gI2C_curAddr;

typedef struct {

  int devAddr;

  struct i2c_client client;   //!< Data structure containing general access routines.
  struct i2c_driver driver;   //!< Data structure containing information specific to each client.
 
  char name[20];
  int nameSize;
  int users;
 
} I2C_Obj;

typedef struct {

  struct cdev cdev;             /* Char device structure  */
  int     major;
  struct semaphore semLock;
   
  I2C_Obj *pObj[I2C_DEV_MAX_ADDR];

  uint8_t reg[I2C_TRANSFER_BUF_SIZE_MAX];
  uint8_t buffer[I2C_TRANSFER_BUF_SIZE_MAX*4];
 
} I2C_Dev;

I2C_Dev gI2C_dev;

int I2C_detectClient(struct i2c_adapter *adapter, int address)
{
    I2C_Obj *pObj;
    struct i2c_client *client;
    int err = 0;
   
    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: I2C_detectClient() at address %x ...\n", address);
    #endif
       
    if(address > I2C_DEV_MAX_ADDR) {
      printk( KERN_ERR "I2C: ERROR: Invalid device address %x\n", address);       
      return -1;
    }
     
    pObj = gI2C_dev.pObj[address];
    if(pObj==NULL) {
      printk( KERN_ERR "I2C: ERROR: Object not found for address %x\n", address);   
      return -1;
    }

    client = &pObj->client;

    if(client->adapter)
      return -EBUSY;  /* our client is already attached */

    memset(client, 0x00, sizeof(struct i2c_client));
    client->addr = pObj->devAddr;
    client->adapter = adapter;
    client->driver = &pObj->driver;

    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: i2c_attach_client() ...\n");
    #endif

    if((err = i2c_attach_client(client)))
    {
        printk( KERN_ERR "I2C: ERROR: Couldn't attach %s (address=%x)\n", pObj->name, pObj->devAddr);
        client->adapter = NULL;
        return err;
    }
   
    #ifdef I2C_DEBUG
    printk( KERN_INFO "I2C: %s client registered at address %x !\n", pObj->name, pObj->devAddr );
    #endif

    return 0;
}

int I2C_detachClient(struct i2c_client *client)
{
    int err;

    if(!client->adapter)
        return -ENODEV; /* our client isn't attached */

    if((err = i2c_detach_client(client))) {
        printk( KERN_ERR "Client deregistration failed (address=%x), client not detached.\n", client->addr);
        return err;
    }

    client->adapter = NULL;

    return 0;
}

int I2C_attachAdapter(struct i2c_adapter *adapter)
{
    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: I2C_attachAdapter() ...\n");
    #endif
   
    return I2C_detectClient(adapter, gI2C_curAddr);
}

void *I2C_create(int devAddr) {

    int ret;
    struct i2c_driver *driver;
    struct i2c_client *client = client;
   
    I2C_Obj *pObj;

    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: Driver registration in progress for address %x...\n", devAddr);
    #endif
   
    devAddr >>= 1;
   
    if(devAddr>I2C_DEV_MAX_ADDR)
      return NULL;
  
    if(gI2C_dev.pObj[devAddr]!=NULL) {
      // already allocated, increment user count, and return the allocated handle
     
      gI2C_dev.pObj[devAddr]->users++;
     
      return gI2C_dev.pObj[devAddr];
    }
   
    pObj = (void*)kmalloc( sizeof(I2C_Obj), GFP_KERNEL);

    gI2C_dev.pObj[devAddr] = pObj;

    memset(pObj, 0, sizeof(I2C_Obj));
 
    pObj->client.adapter = NULL;
    pObj->users++;
   
    pObj->devAddr = devAddr;
   
    gI2C_curAddr = pObj->devAddr;
   
    driver = &pObj->driver;

    pObj->nameSize=0;
    pObj->name[pObj->nameSize++] = 'I';
    pObj->name[pObj->nameSize++] = '2';
    pObj->name[pObj->nameSize++] = 'C';
    pObj->name[pObj->nameSize++] = '_';  
    pObj->name[pObj->nameSize++] = 'A' + ((pObj->devAddr >> 0) & 0xF);
    pObj->name[pObj->nameSize++] = 'B' + ((pObj->devAddr >> 4) & 0xF);
    pObj->name[pObj->nameSize++] = 0;

    driver->driver.name = pObj->name;
    driver->id = I2C_DRIVERID_MISC;
    driver->attach_adapter = I2C_attachAdapter;
    driver->detach_client = I2C_detachClient;

    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: i2c_add_driver() ...\n");
    #endif

    if((ret = i2c_add_driver(driver)))
    {
        printk( KERN_ERR "I2C: ERROR: Driver registration failed (address=%x), module not inserted.\n", pObj->devAddr);
    }
   
    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: Driver registration successful (address=%x)\n", pObj->devAddr);
    #endif
   
    if(ret<0) {

      gI2C_dev.pObj[pObj->devAddr] = NULL;
   
      kfree(pObj);   

      return NULL;
    }
   
    return pObj;
}

int I2C_delete(I2C_Obj *pObj)
{
  if(pObj==NULL)
    return -1;
 
  pObj->users--;
 
  if(pObj->users<=0) {
    if(pObj->client.adapter!=NULL) {
      if(i2c_del_driver(&pObj->driver))
      printk(KERN_ERR "I2C: ERROR: Driver remove failed (address=%x), module not removed.\n", pObj->devAddr);

      pObj->client.adapter = NULL;

      gI2C_dev.pObj[pObj->devAddr] = NULL;
   
      kfree(pObj);   
    }
  }

  return 0;
}

int I2C_read(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
  uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[1];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV; 

  if(dataSize<=0||dataSize>4)
    return -1;
   
  for(i=0; i<count; i++) {
        msg->addr  = client->addr;
        msg->flags = 0;
        msg->len   = 1;
        msg->buf   = data;
        data[0]    = reg[i];
        err = i2c_transfer(client->adapter, msg, 1);
        if(err<0) {
          printk( KERN_ERR " i2c_transfer(0x%x, %x)\n", msg->addr, msg->buf[0]);
        }

        if (err >= 0)
        {
            msg->flags = I2C_M_RD;
      msg->len   = dataSize;
            err = i2c_transfer(client->adapter, msg, 1);
            if (err >= 0)
            {
              if(dataSize==1) {
                  buffer[i] = data[0];
            } else
            if(dataSize==2) {
              buffer[2*i]   = data[1];
              buffer[2*i+1] = data[0];             
            }
            }
        }
    if (err<0)
      return -ENODEV;
  }
 
  return 0;
}

int I2C_write(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
  uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[8];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV; 
 
  if(dataSize<=0||dataSize>4)
    return -1;
   
  for(i=0; i<count; i++) {
 
    msg->addr = client->addr;
        msg->flags= 0;
        msg->buf  = data;
       
        data[0] = reg[i];
       
        if(dataSize==1) {
          data[1]  = buffer[i];
          msg->len = 2;         
    }    else   
        if(dataSize==2) {
          data[1] = buffer[2*i+1];
          data[2] = buffer[2*i];
          msg->len = 3;
        }
        err = i2c_transfer(client->adapter, msg, 1);
    if( err < 0 )
      return err;
  }
 
  return 0;
}

int I2C_devOpen(struct inode *inode, struct file *filp)
{
  int minor, major;

  minor = iminor(inode);
  major = imajor(inode);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devOpen()   , %4d, %2d \n", major, minor);
#endif

  filp->private_data = NULL;

  return 0;                /* success */
}

int I2C_devRelease(struct inode *inode, struct file *filp)
{
  I2C_Obj *pObj;

  pObj = (I2C_Obj *)filp->private_data;
 
  if(pObj==NULL)
    return 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devRelease(), %x, %d \n", pObj->devAddr, pObj->users);
#endif

  I2C_delete(pObj);

  return 0;
}

int I2C_devIoctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
  I2C_Obj *pObj;
  int status=0;
  I2C_TransferPrm transferPrm;
 
  pObj = (I2C_Obj *)filp->private_data;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devIoctl() \n");
#endif

  if(!I2C_IOCTL_CMD_IS_VALID(cmd))
    return -1;

  cmd = I2C_IOCTL_CMD_GET(cmd);

  down_interruptible(&gI2C_dev.semLock);     
 
  switch(cmd)
  {
    case I2C_CMD_SET_DEV_ADDR:
      filp->private_data = I2C_create(arg);
      if(filp->private_data==NULL)
        status = -1;
      break;
     
    case I2C_CMD_WRITE:
     
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count); 
        status |= copy_from_user(gI2C_dev.buffer, transferPrm.value, transferPrm.count*transferPrm.dataSize); 
        if(status==0) {
          status = I2C_write(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
        }
      }
           
      break;
    case I2C_CMD_READ: 
   
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);       
        if(status==0) {
          status = I2C_read(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
          if(status==0) {
            status = copy_to_user(transferPrm.value, gI2C_dev.buffer, transferPrm.count*transferPrm.dataSize);
          }
        }
      }
     
      break;
    default:
      status = -1;
      break;   
  }

  up(&gI2C_dev.semLock);     

  return status;
}


struct file_operations gI2C_devFileOps = {
  .owner = THIS_MODULE,
  .open = I2C_devOpen,
  .release = I2C_devRelease,
  .ioctl = I2C_devIoctl,
};

int I2C_devInit(void)
{
  int     result, i;
  dev_t   dev = 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devInit() \n");
#endif

  result = alloc_chrdev_region(&dev, 0, 1, I2C_DRV_NAME);

  if (result < 0) {
    printk(KERN_WARNING "I2C: can't get device major num \n");
    return result;
  }
 
  for(i=0; i<I2C_DEV_MAX_ADDR; i++)
  {
    gI2C_dev.pObj[i]=NULL;
  }

  gI2C_dev.major = MAJOR(dev);
 
  sema_init(&gI2C_dev.semLock, 1);

  cdev_init(&gI2C_dev.cdev, &gI2C_devFileOps);

  gI2C_dev.cdev.owner = THIS_MODULE;
  gI2C_dev.cdev.ops = &gI2C_devFileOps;

  result = cdev_add(&gI2C_dev.cdev, dev, 1);

  if (result)
    printk(KERN_WARNING "I2C: Error [%d] while adding device [%s] \n", result, I2C_DRV_NAME);

  printk(KERN_INFO "I2C: Module install successful, device major num = %d \n", gI2C_dev.major);

  return result;
}

void I2C_devExit(void)
{
  dev_t   devno = MKDEV(gI2C_dev.major, 0);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devExit() \n");
#endif

  cdev_del(&gI2C_dev.cdev);

  unregister_chrdev_region(devno, 1);
}

Thanks

Venkat

Venkat,

I meant you should make changes to the linux kernel (ti-davinci). Please compare the 2.6.18 linux kernel source that came with the ECDK with the original 2.6.18 version and then migrate these changes to the 2.6.32 linux kernel source you wish to use.

Regards,

Sithara

Hi Sithara,

I compared original 2.6.18 kernel and ti-davinci kernel 2.6.18.but it has lot of changes in the ti-davinci kernel. But we can't do all change in linux-staging . Actually linux-staging kernel for dm365 board only. I think that we should changes application file of av_capture/framework/drv/kermod/src files of dev_dma.c and dev_i2c.c files.

Please can you suggest me How to solve this

Thanks and Regards

venkat

Hi Venkat,

You are right. You should look into dev_i2c.c. Please find out where the error is actually coming from. I see that it finally reaches to i2c_transfer.c in ti-davinci/drivers/i2c. See if the interface is right. If not, make changes to dev_i2c.c accordingly.

Regards,

Sithara

Hi Sithara,

Thanks for your help.

I didn't find any problem with i2c_transfer function in i2c.c driver. I actually this application looping the AVSERVER_start->OSA_mbxSendMsg function.

which source files are displaying following print statements

CAPTURE: Opening ISIF.                                                        
 CAPTURE: Opening H3A.                                                         
TI Setting Applied                                                             
                                                                               
 H3A Settings,                                                                 
 AEWB Win Start H       = 0                                                    
 AEWB Win Start V       = 2                                                    
 AEWB Win Num H         = 32                                                   
 AEWB Win Num V         = 12                                                   
 AEWB Win Width         = 40                                                   
 AEWB Win Height        = 60                                                   
 AEWB Win Inc H         = 6                                                    
 AEWB Win Inc V         = 6                                                    
 AEWB Win Pixels/Color  = 70                                                   
                                                                               
 CAPTURE: Opening IPIPE.             

Can you suggest me to solve this problem

Regards

venkat

HI Sithara,

I changed dev_i2c.c  driver file in the av_capture application according the to linux-2.6.32 kernel model. I am attaching dev_i2c.c file here is it correct what i changed driver in

dev_i2c.c file

Please help me solve this problem

#include <dev_i2c.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>           /* everything... */
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/i2c.h>
#include <linux/kernel.h>       /* printk() */
#include <linux/slab.h>         /* kmalloc() */
#include <asm/uaccess.h>        /* copy_*_user */


static unsigned short gI2C_curAddr;

typedef struct {

  int devAddr;

  struct i2c_client *client;   //!< Data structure containing general access routines.
  struct i2c_driver driver;   //!< Data structure containing information specific to each client.
 
  char name[20];
  int nameSize;
  int users;
 
} I2C_Obj;

typedef struct {

  struct cdev cdev;             /* Char device structure  */
  int     major;
  struct semaphore semLock;
    
  I2C_Obj *pObj[I2C_DEV_MAX_ADDR];

  uint8_t reg[I2C_TRANSFER_BUF_SIZE_MAX];
  uint8_t buffer[I2C_TRANSFER_BUF_SIZE_MAX*4];
 
} I2C_Dev;

I2C_Dev gI2C_dev;

static int I2C_probe(struct i2c_client *client,const struct i2c_device_id *id)
{
   I2C_Obj *pObj;
   struct device *dev = &client->dev;
   
   pObj = kzalloc(sizeof(I2C_Obj), GFP_KERNEL);
   if (pObj == NULL)
   {
    dev_err(dev, "failed to create our pObj\n");
    return -ENOMEM;
    }

   pObj->client = client;
   i2c_set_clientdata(client, pObj);

   /* rest of the initialisation goes here. */

   dev_info(dev, "example client created\n");
    
   return 0;
}

static int __devexit I2C_remove(struct i2c_client *client)
{
    I2C_Obj *pObj = i2c_get_clientdata(client);

    kfree(pObj);
    return 0;
}

static struct i2c_device_id i2c_idtable[] = {
    { "I2C_AB0", 0x48 },
    { }
};

MODULE_DEVICE_TABLE(i2c, i2c_idtable);

void *I2C_create(int devAddr)
{
    int ret;
    struct i2c_driver *driver;
    struct i2c_client *client = client;
    
    I2C_Obj *pObj;

    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: Driver registration in progress for address %x...\n", devAddr);
    #endif
    
    devAddr >>= 1;
    
    if(devAddr>I2C_DEV_MAX_ADDR)
      return NULL;
   
    if(gI2C_dev.pObj[devAddr]!=NULL)
    {
      // already allocated, increment user count, and return the allocated handle
      
      gI2C_dev.pObj[devAddr]->users++;
      
      return gI2C_dev.pObj[devAddr];
    }
    
    pObj = (void*)kmalloc( sizeof(I2C_Obj), GFP_KERNEL);

    gI2C_dev.pObj[devAddr] = pObj;

    memset(pObj, 0, sizeof(I2C_Obj));
 
    pObj->client->adapter = NULL;
    pObj->users++;
    
    pObj->devAddr = devAddr;
    
    gI2C_curAddr = pObj->devAddr;
    
    driver = &pObj->driver;
     
    pObj->nameSize=0;
    pObj->name[pObj->nameSize++] = 'I';
    pObj->name[pObj->nameSize++] = '2';
    pObj->name[pObj->nameSize++] = 'C';
    pObj->name[pObj->nameSize++] = '_';   
    pObj->name[pObj->nameSize++] = 'A' + ((pObj->devAddr >> 0) & 0xF);
    pObj->name[pObj->nameSize++] = 'B' + ((pObj->devAddr >> 4) & 0xF);
    pObj->name[pObj->nameSize++] = 0;

    //driver->driver.name = "mt9p031";
    driver->driver.name = pObj->name;
    driver->id_table = &i2c_idtable;
    driver->probe = I2C_probe;
    driver->remove = I2C_remove;
    
    if((ret = i2c_add_driver(driver)))
    {
        printk( KERN_ERR "I2C: ERROR: Driver registration failed (address=%x), module not inserted.\n", pObj->devAddr);
    }
    
    #ifdef I2C_DEBUG
    printk(KERN_INFO "I2C: Driver registration successful (address=%x)\n", pObj->devAddr);
    #endif
    
    if(ret<0)
   {

      gI2C_dev.pObj[pObj->devAddr] = NULL;
    
      kfree(pObj);    

      return NULL;
    }
    
    return pObj;
}

int I2C_delete(I2C_Obj *pObj)
{
  if(pObj==NULL)
    return -1;
 
  pObj->users--;
 
  if(pObj->users<=0)
  {
    if(pObj->client->adapter!=NULL)
    {
      //if(i2c_del_driver(&pObj->driver))
      i2c_del_driver(&pObj->driver);
      printk(KERN_ERR "I2C: ERROR: Driver remove failed (address=%x), module not removed.\n", pObj->devAddr);

      pObj->client->adapter = NULL;

      gI2C_dev.pObj[pObj->devAddr] = NULL;
    
      kfree(pObj);    
    }
  }
  return 0;
}

int I2C_read(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
  uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[1];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV;  

  if(dataSize<=0||dataSize>4)
    return -1;
    
  for(i=0; i<count; i++)
  {
        msg->addr  = client->addr;
        msg->flags = 0;
        msg->len   = 1;
        msg->buf   = data;
        data[0]    = reg[i];
        err = i2c_transfer(client->adapter, msg, 1);
        if(err<0) {
          printk( KERN_ERR " i2c_transfer(0x%x, %x)\n", msg->addr, msg->buf[0]);
        }

        if (err >= 0)
        {
            msg->flags = I2C_M_RD;
      msg->len   = dataSize;
            err = i2c_transfer(client->adapter, msg, 1);
            if (err >= 0)
            {
              if(dataSize==1) {
                  buffer[i] = data[0];
            } else
            if(dataSize==2) {
              buffer[2*i]   = data[1];
              buffer[2*i+1] = data[0];              
            }
            }
        }
    if (err<0)
      return -ENODEV;
  }
 
  return 0;
}

int I2C_write(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
{
uint8_t i;
  int err;
  struct i2c_client *client;
    struct i2c_msg msg[1];
    unsigned char data[8];

  if(pObj==NULL)
    return -ENODEV;

  client = &pObj->client;
  if(!client->adapter)
    return -ENODEV;  
 
  if(dataSize<=0||dataSize>4)
    return -1;
    
  for(i=0; i<count; i++) {
 
    msg->addr = client->addr;
        msg->flags= 0;
        msg->buf  = data;
        
        data[0] = reg[i];
        
        if(dataSize==1) {
          data[1]  = buffer[i];
          msg->len = 2;          
    }    else    
        if(dataSize==2) {
          data[1] = buffer[2*i+1];
          data[2] = buffer[2*i];
          msg->len = 3;
        }
        err = i2c_transfer(client->adapter, msg, 1);
    if( err < 0 )
      return err;
  }
 
  return 0;

}

int I2C_devOpen(struct inode *inode, struct file *filp)
{
  int minor, major;

  minor = iminor(inode);
  major = imajor(inode);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devOpen()   , %4d, %2d \n", major, minor);
#endif

  filp->private_data = NULL;


  return 0;                /* success */
}

int I2C_devRelease(struct inode *inode, struct file *filp)
{
 
  I2C_Obj *pObj;

  pObj = (I2C_Obj *)filp->private_data;
 
  if(pObj==NULL)
    return 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devRelease(), %x, %d \n", pObj->devAddr, pObj->users);
#endif

  I2C_delete(pObj);
  return 0;
}

int I2C_devIoctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{

  I2C_Obj *pObj;
  int status=0;
  I2C_TransferPrm transferPrm;
 
  pObj = (I2C_Obj *)filp->private_data;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devIoctl() \n");
#endif

  if(!I2C_IOCTL_CMD_IS_VALID(cmd))
    return -1;

  cmd = I2C_IOCTL_CMD_GET(cmd);

  down_interruptible(&gI2C_dev.semLock);      
 
  switch(cmd)
  {
    case I2C_CMD_SET_DEV_ADDR:
      filp->private_data = I2C_create(arg);
      if(filp->private_data==NULL)
        status = -1;
      break;
      
    case I2C_CMD_WRITE:
      
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);  
        status |= copy_from_user(gI2C_dev.buffer, transferPrm.value, transferPrm.count*transferPrm.dataSize);  
        if(status==0) {
          status = I2C_write(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
        }
      }
            
      break;
    case I2C_CMD_READ:  
    
      status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
      if(status==0) {
        status = copy_from_user(gI2C_dev.reg, transferPrm.reg, transferPrm.count);        
        if(status==0) {
          status = I2C_read(pObj, gI2C_dev.reg, gI2C_dev.buffer, transferPrm.count, transferPrm.dataSize);
          if(status==0) {
            status = copy_to_user(transferPrm.value, gI2C_dev.buffer, transferPrm.count*transferPrm.dataSize);
          }
        }
      }
      
      break;
    default:
      status = -1;
      break;    
  }

  up(&gI2C_dev.semLock);      


  return status;
}


struct file_operations gI2C_devFileOps = {
  .owner = THIS_MODULE,
  .open = I2C_devOpen,
  .release = I2C_devRelease,
  .ioctl = I2C_devIoctl,
};

int I2C_devInit(void)
{
  int     result, i;
  dev_t   dev = 0;

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devInit() \n");
#endif

  result = alloc_chrdev_region(&dev, 0, 1, I2C_DRV_NAME);

  if (result < 0) {
    printk(KERN_WARNING "I2C: can't get device major num \n");
    return result;
  }
 
  for(i=0; i<I2C_DEV_MAX_ADDR; i++)
  {
    gI2C_dev.pObj[i]=NULL;
  }

  gI2C_dev.major = MAJOR(dev);
 
  sema_init(&gI2C_dev.semLock, 1);

  cdev_init(&gI2C_dev.cdev, &gI2C_devFileOps);

  gI2C_dev.cdev.owner = THIS_MODULE;
  gI2C_dev.cdev.ops = &gI2C_devFileOps;

  result = cdev_add(&gI2C_dev.cdev, dev, 1);

  if (result)
    printk(KERN_WARNING "I2C: Error [%d] while adding device [%s] \n", result, I2C_DRV_NAME);

  printk(KERN_INFO "I2C: Module install successful, device major num = %d \n", gI2C_dev.major);

  return result;
}

void I2C_devExit(void)
{
  dev_t   devno = MKDEV(gI2C_dev.major, 0);

#ifdef I2C_DEBUG
  printk(KERN_INFO "I2C: I2C_devExit() \n");
#endif

  cdev_del(&gI2C_dev.cdev);

  unregister_chrdev_region(devno, 1);
}

Regards

Venkat

Hi Venkat or any else,

are you still working at the dev_i2.c file? I have the same problem while porting the ipnc framework from linux kernel version 2.6.18 to the arago tree 2.6.32.

I am not sure if it is really possible to adapt this i2c module to the new kernel version, because the new i2c implementation needs to register statically i2c devices during board setup. This means that during the boot process the kernel will look for any I2C driver which supports the sensor device via i2c. Upon finding such a driver, the kernel will call it's probe function. But in our case the driver isn't loaded and so the probe function cannot be find.

Please tell me how your status porting the i2c driver is and what you think about my thoughts

Kind regards

Patrick

Hi Venkat or anyone else,

are you still working at the dev_i2.c file? I have the same problem while porting the ipnc framework from linux kernel version 2.6.18 to the arago tree 2.6.32.

I am not sure if it is really possible to adapt this i2c module to the new kernel version, because the new i2c implementation needs to register statically i2c devices during board setup. This means that during the boot process the kernel will look for any I2C driver which supports the sensor device via i2c. Upon finding such a driver, the kernel will call it's probe function. But in our case the driver isn't loaded and so the probe function cannot be find.

Please tell me how your status porting the i2c driver is and what you think about my thoughts

Kind regards

Patrick