Thread: [Hackndev-commit] SF.net SVN: hackndev: [1044] linux4palm/linux/trunk/drivers/i2c/chips

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 1044
          http://svn.sourceforge.net/hackndev/?rev=1044&view=rev
Author:   happy-slapin
Date:     2007-06-22 12:19:08 -0700 (Fri, 22 Jun 2007)

Log Message:
-----------
OV9640: Added i2c module code

Added Paths:
-----------
    linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.c
    linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.h

Added: linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.c
===================================================================

--- linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.c	                        (rev 0)
+++ linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.c	2007-06-22 19:19:08 UTC (rev 1044)
@@ -0,0 +1,303 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <asm/hardware.h>
+#include <asm/types.h>
+#include <linux/delay.h>
+
+#include "i2c-ov9640.h"
+
+#define DEBUG 1
+#define DPRINTK(fmt,args...)	do { if (DEBUG) printk("in function %s "fmt,__FUNCTION__,##args);} while(0)
+extern int i2c_adapter_id(struct i2c_adapter *adap);
+
+int  i2c_ov9640_cleanup(void);
+void i2c_ov9640_inc_use (struct i2c_client *client);
+void i2c_ov9640_dec_use (struct i2c_client *client);
+int  i2c_ov9640_attach_adapter(struct i2c_adapter *adapter);
+int  i2c_ov9640_detect_client(struct i2c_adapter *, int, unsigned short, int);
+int  i2c_ov9640_detach_client(struct i2c_client *client);
+
+struct i2c_driver ov9640_driver  = 
+{
+	name:			"ov9640 driver",	            /* name           */
+	id:			I2C_DRIVERID_OV9640,         	    /* id             */
+	flags:			I2C_DF_NOTIFY,        		    /* flags          */
+	attach_adapter:		&i2c_ov9640_attach_adapter,       /* attach_adapter */
+	detach_client:		&i2c_ov9640_detach_client,        /* detach_client  */
+	command:		NULL,
+	inc_use:		&i2c_ov9640_inc_use,
+	dec_use:		&i2c_ov9640_dec_use
+};
+
+extern  struct i2c_adapter *i2cdev_adaps[];
+/* Unique ID allocation */
+static int ov9640_id = 0;
+struct i2c_client *g_client = NULL;
+static unsigned short normal_i2c[] = {OV9640_SLAVE_ADDR ,I2C_CLIENT_END };
+static unsigned short normal_i2c_range[] = { I2C_CLIENT_END }; 
+I2C_CLIENT_INSMOD;
+
+/* 
+ * This call returns a unique low identifier for each registered adapter,
+ * or -1 if the adapter was not registered.
+ */
+void i2c_ov9640_inc_use (struct i2c_client *client)
+{
+	MOD_INC_USE_COUNT;
+#ifdef MODULE
+#endif
+}
+
+void i2c_ov9640_dec_use (struct i2c_client *client)
+{
+	MOD_DEC_USE_COUNT;
+#ifdef MODULE
+#endif
+}
+
+char ov9640_read(u8 addr, u8 *pvalue)
+{
+	int	res=0;
+	char 	buf=0;
+	struct i2c_msg msgs[2] = {
+		{ 0, I2C_M_WR, 1, &addr },
+		{ 0, I2C_M_RD, 1, &buf }};
+	
+	if( g_client == NULL )	
+		return -1;
+	i2c_ov9640_inc_use(g_client);
+	msgs[0].addr=msgs[1].addr=g_client->addr;
+	res=i2c_transfer(g_client->adapter,&msgs[0],1);
+	if (res<=0) 
+		goto out;
+	res=i2c_transfer(g_client->adapter,&msgs[1],1);
+	if (res<=0) 
+		goto out;
+	*pvalue = buf;
+	i2c_ov9640_dec_use(g_client);
+out:
+	DPRINTK(KERN_INFO "In funtion %s addr:%x,value=%x\n", __FUNCTION__, addr,*pvalue);
+	if (res<=0) DPRINTK("res = %d \n",res);
+	return res;
+}	
+
+int ov9640_write(u8 addr, u8 value)
+{
+	int	res=0;
+	if( g_client == NULL )
+		return -1;
+	/*
+	char 	buf=0;
+	struct i2c_msg msgs[2] = {
+		{ 0, I2C_M_WR, 1, &addr },
+		{ 0, I2C_M_WR, 1, &value }};
+	msgs[0].addr=msgs[1].addr=g_client->addr;
+	res=i2c_transfer(g_client->adapter,&msgs[0],1);
+	if (res<=0) return res;
+	res=i2c_transfer(g_client->adapter,&msgs[1],1);
+	if (res<=0) return res;
+
+
+	res=i2c_smbus_write_byte_data(g_client, addr, value );
+	*/
+	char 	buf[2]={addr,value};
+	i2c_ov9640_inc_use(g_client);
+	res = i2c_master_send(g_client, buf, 2);
+	i2c_ov9640_dec_use(g_client);
+	if (res >0) res =0;
+	else res =-1;
+	DPRINTK(KERN_INFO "In funtion %s addr:%x value:%xreturn %d \n", __FUNCTION__, addr,value,res);
+	return res;
+}	
+
+
+int i2c_ov9640_read(struct i2c_client *client, u8 reg)
+{
+	unsigned char msgbuf=0;
+	DPRINTK("in function %s\n",__FUNCTION__);
+	i2c_master_recv(client,&msgbuf,1);
+	return msgbuf;
+	/*
+	*/
+//    return i2c_smbus_read_word_data(client,reg);
+//  return i2c_smbus_read_byte_data(client,reg);
+}
+
+int i2c_ov9640_write(struct i2c_client *client, u8 reg, u16 value)
+{
+    return i2c_smbus_write_word_data(client,reg,value);
+}
+
+
+int i2c_ov9640_attach_adapter(struct i2c_adapter *adap)
+{
+	DPRINTK("In function %s.\n", __FUNCTION__);
+	return i2c_probe(adap,&addr_data,i2c_ov9640_detect_client);
+}
+
+
+int i2c_ov9640_detect_client(struct i2c_adapter *adapter, int address, unsigned short flags, int kind)
+{
+    struct i2c_client *new_client;
+    int err = 0;
+    struct ov9640_data *data;
+    
+    /*check if */
+    if(g_client != NULL) {
+      err = -ENXIO;
+      goto ERROR0;
+    }
+ 
+
+	DPRINTK(KERN_INFO "In funtion %s. address=0X%X\n", __FUNCTION__, address);
+    /* Let's see whether this adapter can support what we need.
+       Please substitute the things you need here!  */
+	if ( !i2c_check_functionality(adapter,I2C_FUNC_SMBUS_WORD_DATA) ) {
+		DPRINTK(KERN_INFO "Word op is not permited.\n");
+		goto ERROR0;
+	}
+
+    /* OK. For now, we presume we have a valid client. We now create the
+       client structure, even though we cannot fill it completely yet.
+       But it allows us to access several i2c functions safely */
+    
+    /* Note that we reserve some space for ov9640_data too. If you don't
+       need it, remove it. We do it here to help to lessen memory
+       fragmentation. */
+
+    new_client=kmalloc(sizeof(struct i2c_client)+sizeof(struct ov9640_data),
+		  				GFP_KERNEL );
+
+    if ( !new_client )  {
+      err = -ENOMEM;
+      goto ERROR0;
+    }
+
+	data = (struct ov9640_data *) (new_client + 1);
+
+	new_client->addr = address;	
+	new_client->data = data;
+	new_client->adapter = adapter;
+	new_client->driver = &ov9640_driver;
+	new_client->flags = 0;
+
+    g_client = new_client;
+
+    /* Now, we do the remaining detection. If no `force' parameter is used. */
+
+    /* First, the generic detection (if any), that is skipped if any force
+       parameter was used. */
+
+	if (kind <= 0) {
+                 char res = -1;
+		mdelay(2000);
+		 ov9640_read(REV,&res);
+		/* The below is of course bogus */
+		DPRINTK("I2C: Probe ov9640 chip..addr=0x%x, REV=%d, res=0x%x\n", address, REV, res);
+                /*ov9640 chip id is 0x9648
+                 if(res != OV9640_CHIP_ID) {
+			DPRINTK(KERN_WARNING "Failed.product id =%d \n",res);
+			goto ERROR1;
+		 }		 
+		else {
+                       DPRINTK("OV9640 chip id is 0X%04X\n", OV9640_CHIP_ID);
+			if ( ov9640_id == 0 )
+				DPRINTK(" detected.\n");
+		}*/
+	}
+
+	strcpy(new_client->name, "ov9640");
+    /* Automatically unique */
+    new_client->id = ov9640_id++; 
+
+    /* Only if you use this field */
+	data->valid = 0; 
+
+    /* Only if you use this field */
+	init_MUTEX(&data->update_lock); 
+
+    /* Tell the i2c layer a new client has arrived */
+    if ((err = i2c_attach_client(new_client)))
+      goto ERROR3;
+
+    /* This function can write default values to the client registers, if
+       needed. */
+	/*	ov9640_init_client(new_client);	*/
+    return 0;
+
+    /* OK, this is not exactly good programming practice, usually. But it is
+       very code-efficient in this case. */
+
+ERROR3:
+ERROR1:
+      kfree(new_client);
+      g_client = NULL;
+ERROR0:
+      return err;
+}
+
+int i2c_ov9640_detach_client(struct i2c_client *client)
+{
+	int err;
+
+    /* Try to detach the client from i2c space */
+    if ((err = i2c_detach_client(client))) {
+      DPRINTK("ov9640.o: Client deregistration failed, client not detached.\n");
+      return err;
+    }
+
+    kfree(client); /* Frees client data too, if allocated at the same time */
+    g_client = NULL;
+    return 0;
+}
+
+/* 	Keep track of how far we got in the initialization process. If several
+	things have to initialized, and we fail halfway, only those things
+	have to be cleaned up! */
+static int ov9640_initialized = 0;
+
+int i2c_ov9640_init(void)
+{
+	int res;
+
+	if (ov9640_initialized) 
+		return 0;
+	DPRINTK("I2C: driver for device ov9640.\n");
+	if ( (res = i2c_add_driver(&ov9640_driver)) ) {
+		DPRINTK("ov9640: Driver registration failed, module not inserted.\n");
+		i2c_ov9640_cleanup();
+		return res;
+	}
+	ov9640_initialized ++;
+        if(g_client != NULL)
+   	   DPRINTK("I2C: driver for device %s registed!.\n", g_client->name);
+        else 
+           DPRINTK("I2C: driver for device unregisted!.\n");
+	return 0;
+}
+
+int i2c_ov9640_cleanup(void)
+{
+	int res;
+
+	if (ov9640_initialized == 1) {
+		if ((res = i2c_del_driver(&ov9640_driver))) {
+			DPRINTK("ov9640: Driver registration failed, module not removed.\n");
+			return res;
+		}
+		ov9640_initialized --;
+	}
+	return 0;
+}
+
+EXPORT_SYMBOL(i2c_ov9640_init);
+EXPORT_SYMBOL(ov9640_write);
+EXPORT_SYMBOL(ov9640_read);
+EXPORT_SYMBOL(i2c_ov9640_cleanup);
+//module_init(i2c_ov9640_init);
+//module_exit(i2c_ov9640_cleanup);
+MODULE_LICENSE("GPL");
+

Added: linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.h
===================================================================
--- linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.h	                        (rev 0)
+++ linux4palm/linux/trunk/drivers/i2c/chips/i2c-ov9640.h	2007-06-22 19:19:08 UTC (rev 1044)
@@ -0,0 +1,42 @@
+#ifndef  __I2C_OV9640_H__
+#define  __I2C_OV9640_H__
+
+#define DEBUG
+
+/* Calculating the Module Block Number */
+#define BLOCK(a)    (u8)((a) >> 7)      /* register's module block address. */
+#define OFFSET(a)   (u8)((a) & 0x7F )   /* register's offset to this block. */
+
+/*  Update the block address.*/
+#define BLOCK_SWITCH_CMD    0xFE
+
+#define OV9640_SLAVE_ADDR (0x60>>1)	/* 60 for write , 61 for read */
+// #define SENSOR_SLAVE_ADDR   0x0055      /* tbd: */
+
+
+#define I2C_DRIVERID_OV9640   I2C_DRIVERID_EXP2
+
+/*ov9640 chip id*/
+#define OV9640_CHIP_ID  0x9648
+
+/* Register definitions in OV9640's chip. */
+#define PID	0xA
+#define REV     0xA
+
+struct ov9640_data {
+    /*
+     *  Because the i2c bus is slow, it is often useful to cache the read
+     *  information of a chip for some time (for example, 1 or 2 seconds).
+     *  It depends of course on the device whether this is really worthwhile
+     *  or even sensible.
+     */
+    struct semaphore update_lock; /* When we are reading lots of information,
+                                     another process should not update the
+                                     below information */
+
+    char valid;                   /* != 0 if the following fields are valid. */
+    int  blockaddr;               /* current using block address.    */
+    unsigned long last_updated;   /* In jiffies */
+};
+#endif
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [Hackndev-commit] SF.net SVN: hackndev: [1044] linux4palm/linux/trunk/drivers/i2c/chips

hackndev-commit