i2c-core.c

2440下的I2C驱动源代码 看了才知道一个驱动可以写的这么结构化！

	dev_dbg(&adapter->dev, "client [%s] registered to adapter\n",
		client->name);

	if (client->flags & I2C_CLIENT_ALLOW_USE)
		client->usage_count = 0;

	client->dev.parent = &client->adapter->dev;
	client->dev.driver = &client->driver->driver;
	client->dev.bus = &i2c_bus_type;
	client->dev.release = &i2c_client_release;
	
	snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
		"%d-%04x", i2c_adapter_id(adapter), client->addr);
	pr_debug("registering %s\n", client->dev.bus_id);
	device_register(&client->dev);
	device_create_file(&client->dev, &dev_attr_client_name);
	
	return 0;
}


int i2c_detach_client(struct i2c_client *client)
{
	struct i2c_adapter *adapter = client->adapter;
	int res = 0;
	
	if ((client->flags & I2C_CLIENT_ALLOW_USE) && (client->usage_count > 0))
		return -EBUSY;

	if (adapter->client_unregister)  {
		res = adapter->client_unregister(client);
		if (res) {
			dev_err(&client->dev,
			       "client_unregister [%s] failed, "
			       "client not detached", client->name);
			goto out;
		}
	}

	down(&adapter->clist_lock);
	list_del(&client->list);
	init_completion(&client->released);
	device_remove_file(&client->dev, &dev_attr_client_name);
	device_unregister(&client->dev);
	up(&adapter->clist_lock);
	wait_for_completion(&client->released);

 out:
	return res;
}

static int i2c_inc_use_client(struct i2c_client *client)
{

	if (!try_module_get(client->driver->owner))
		return -ENODEV;
	if (!try_module_get(client->adapter->owner)) {
		module_put(client->driver->owner);
		return -ENODEV;
	}

	return 0;
}

static void i2c_dec_use_client(struct i2c_client *client)
{
	module_put(client->driver->owner);
	module_put(client->adapter->owner);
}

int i2c_use_client(struct i2c_client *client)
{
	int ret;

	ret = i2c_inc_use_client(client);
	if (ret)
		return ret;

	if (client->flags & I2C_CLIENT_ALLOW_USE) {
		if (client->flags & I2C_CLIENT_ALLOW_MULTIPLE_USE)
			client->usage_count++;
		else if (client->usage_count > 0) 
			goto busy;
		else 
			client->usage_count++;
	}

	return 0;
 busy:
	i2c_dec_use_client(client);
	return -EBUSY;
}

int i2c_release_client(struct i2c_client *client)
{
	if(client->flags & I2C_CLIENT_ALLOW_USE) {
		if(client->usage_count>0)
			client->usage_count--;
		else {
			pr_debug("i2c-core: %s used one too many times\n",
				__FUNCTION__);
			return -EPERM;
		}
	}
	
	i2c_dec_use_client(client);
	
	return 0;
}

void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
{
	struct list_head  *item;
	struct i2c_client *client;

	down(&adap->clist_lock);
	list_for_each(item,&adap->clients) {
		client = list_entry(item, struct i2c_client, list);
		if (!try_module_get(client->driver->owner))
			continue;
		if (NULL != client->driver->command) {
			up(&adap->clist_lock);
			client->driver->command(client,cmd,arg);
			down(&adap->clist_lock);
		}
		module_put(client->driver->owner);
       }
       up(&adap->clist_lock);
}

static int __init i2c_init(void)
{
	int retval;

	retval = bus_register(&i2c_bus_type);
	if (retval)
		return retval;
	retval = driver_register(&i2c_adapter_driver);
	if (retval)
		return retval;
	return class_register(&i2c_adapter_class);
}

static void __exit i2c_exit(void)
{
	class_unregister(&i2c_adapter_class);
	driver_unregister(&i2c_adapter_driver);
	bus_unregister(&i2c_bus_type);
}

subsys_initcall(i2c_init);
module_exit(i2c_exit);

/* ----------------------------------------------------
 * the functional interface to the i2c busses.
 * ----------------------------------------------------
 */

int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
{
	int ret;

	if (adap->algo->master_xfer) {
#ifdef DEBUG
		for (ret = 0; ret < num; ret++) {
			dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
				"len=%d\n", ret, msgs[ret].flags & I2C_M_RD ?
				'R' : 'W', msgs[ret].addr, msgs[ret].len);
		}
#endif

		down(&adap->bus_lock);
		ret = adap->algo->master_xfer(adap,msgs,num);
		up(&adap->bus_lock);

		return ret;
	} else {
		dev_dbg(&adap->dev, "I2C level transfers not supported\n");
		return -ENOSYS;
	}
}

int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
{
	int ret;
	struct i2c_adapter *adap=client->adapter;
	struct i2c_msg msg;

	if (client->adapter->algo->master_xfer) {
		msg.addr   = client->addr;
		msg.flags = client->flags & I2C_M_TEN;
		msg.len = count;
		msg.buf = (char *)buf;
	
		dev_dbg(&client->adapter->dev, "master_send: writing %d bytes.\n",
			count);
	
		down(&adap->bus_lock);
		ret = adap->algo->master_xfer(adap,&msg,1);
		up(&adap->bus_lock);

		/* if everything went ok (i.e. 1 msg transmitted), return #bytes
		 * transmitted, else error code.
		 */
		return (ret == 1 )? count : ret;
	} else {
		dev_err(&client->adapter->dev, "I2C level transfers not supported\n");
		return -ENOSYS;
	}
}

int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
{
	struct i2c_adapter *adap=client->adapter;
	struct i2c_msg msg;
	int ret;
	if (client->adapter->algo->master_xfer) {
		msg.addr   = client->addr;
		msg.flags = client->flags & I2C_M_TEN;
		msg.flags |= I2C_M_RD;
		msg.len = count;
		msg.buf = buf;

		dev_dbg(&client->adapter->dev, "master_recv: reading %d bytes.\n",
			count);
	
		down(&adap->bus_lock);
		ret = adap->algo->master_xfer(adap,&msg,1);
		up(&adap->bus_lock);
	
		dev_dbg(&client->adapter->dev, "master_recv: return:%d (count:%d, addr:0x%02x)\n",
			ret, count, client->addr);
	
		/* if everything went ok (i.e. 1 msg transmitted), return #bytes
	 	* transmitted, else error code.
	 	*/
		return (ret == 1 )? count : ret;
	} else {
		dev_err(&client->adapter->dev, "I2C level transfers not supported\n");
		return -ENOSYS;
	}
}


int i2c_control(struct i2c_client *client,
	unsigned int cmd, unsigned long arg)
{
	int ret = 0;
	struct i2c_adapter *adap = client->adapter;

	dev_dbg(&client->adapter->dev, "i2c ioctl, cmd: 0x%x, arg: %#lx\n", cmd, arg);
	switch (cmd) {
		case I2C_RETRIES:
			adap->retries = arg;
			break;
		case I2C_TIMEOUT:
			adap->timeout = arg;
			break;
		default:
			if (adap->algo->algo_control!=NULL)
				ret = adap->algo->algo_control(adap,cmd,arg);
	}
	return ret;
}

/* ----------------------------------------------------
 * the i2c address scanning function
 * Will not work for 10-bit addresses!
 * ----------------------------------------------------
 */
int i2c_probe(struct i2c_adapter *adapter,
	      struct i2c_client_address_data *address_data,
	      int (*found_proc) (struct i2c_adapter *, int, int))
{
	int addr,i,found,err;
	int adap_id = i2c_adapter_id(adapter);

	/* Forget it if we can't probe using SMBUS_QUICK */
	if (! i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK))
		return -1;

	for (addr = 0x00; addr <= 0x7f; addr++) {

		/* Skip if already in use */
		if (i2c_check_addr(adapter,addr))
			continue;

		/* If it is in one of the force entries, we don't do any detection
		   at all */
		found = 0;

		for (i = 0; !found && (address_data->force[i] != I2C_CLIENT_END); i += 2) {
			if (((adap_id == address_data->force[i]) || 
			     (address_data->force[i] == ANY_I2C_BUS)) &&
			     (addr == address_data->force[i+1])) {
				dev_dbg(&adapter->dev, "found force parameter for adapter %d, addr %04x\n",
					adap_id, addr);
				if ((err = found_proc(adapter,addr,0)))
					return err;
				found = 1;
			}
		}
		if (found) 
			continue;

		/* If this address is in one of the ignores, we can forget about
		   it right now */
		for (i = 0;
		     !found && (address_data->ignore[i] != I2C_CLIENT_END);
		     i += 2) {
			if (((adap_id == address_data->ignore[i]) || 
			    ((address_data->ignore[i] == ANY_I2C_BUS))) &&
			    (addr == address_data->ignore[i+1])) {
				dev_dbg(&adapter->dev, "found ignore parameter for adapter %d, "
					"addr %04x\n", adap_id ,addr);
				found = 1;
			}
		}
		for (i = 0;
		     !found && (address_data->ignore_range[i] != I2C_CLIENT_END);
		     i += 3) {
			if (((adap_id == address_data->ignore_range[i]) ||
			    ((address_data->ignore_range[i]==ANY_I2C_BUS))) &&
			    (addr >= address_data->ignore_range[i+1]) &&
			    (addr <= address_data->ignore_range[i+2])) {
				dev_dbg(&adapter->dev, "found ignore_range parameter for adapter %d, "
					"addr %04x\n", adap_id,addr);
				found = 1;
			}
		}
		if (found) 
			continue;

		/* Now, we will do a detection, but only if it is in the normal or 
		   probe entries */  
		for (i = 0;
		     !found && (address_data->normal_i2c[i] != I2C_CLIENT_END);
		     i += 1) {
			if (addr == address_data->normal_i2c[i]) {
				found = 1;
				dev_dbg(&adapter->dev, "found normal i2c entry for adapter %d, "
					"addr %02x\n", adap_id, addr);
			}
		}

		for (i = 0;
		     !found && (address_data->normal_i2c_range[i] != I2C_CLIENT_END);
		     i += 2) {
			if ((addr >= address_data->normal_i2c_range[i]) &&
			    (addr <= address_data->normal_i2c_range[i+1])) {
				found = 1;
				dev_dbg(&adapter->dev, "found normal i2c_range entry for adapter %d, "
					"addr %04x\n", adap_id,addr);
			}
		}

		for (i = 0;
		     !found && (address_data->probe[i] != I2C_CLIENT_END);
		     i += 2) {
			if (((adap_id == address_data->probe[i]) ||
			    ((address_data->probe[i] == ANY_I2C_BUS))) &&
			    (addr == address_data->probe[i+1])) {
				found = 1;
				dev_dbg(&adapter->dev, "found probe parameter for adapter %d, "
					"addr %04x\n", adap_id,addr);
			}
		}
		for (i = 0;
		     !found && (address_data->probe_range[i] != I2C_CLIENT_END);
		     i += 3) {
			if (((adap_id == address_data->probe_range[i]) ||
			   (address_data->probe_range[i] == ANY_I2C_BUS)) &&
			   (addr >= address_data->probe_range[i+1]) &&
			   (addr <= address_data->probe_range[i+2])) {
				found = 1;
				dev_dbg(&adapter->dev, "found probe_range parameter for adapter %d, "
					"addr %04x\n", adap_id,addr);
			}
		}
		if (!found) 
			continue;

		/* OK, so we really should examine this address. First check
		   whether there is some client here at all! */
		if (i2c_smbus_xfer(adapter,addr,0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
			if ((err = found_proc(adapter,addr,-1)))
				return err;
	}
	return 0;
}

/*
 * return id number for a specific adapter
 */
int i2c_adapter_id(struct i2c_adapter *adap)
{
	return adap->nr;
}

struct i2c_adapter* i2c_get_adapter(int id)
{
	struct list_head   *item;
	struct i2c_adapter *adapter;
	
	down(&core_lists);
	list_for_each(item,&adapters) {
		adapter = list_entry(item, struct i2c_adapter, list);
		if (id == adapter->nr &&
		    try_module_get(adapter->owner)) {
			up(&core_lists);
			return adapter;
		}
	}
	up(&core_lists);
	return NULL;
}

void i2c_put_adapter(struct i2c_adapter *adap)
{
	module_put(adap->owner);
}

/* The SMBus parts */