| /* |
| * I2C_ALGO_USB.C |
| * i2c algorithm for USB-I2C Bridges |
| * |
| * Copyright (c) 1999-2005 Joerg Heckenbach <joerg@heckenbach-aw.de> |
| * Dwaine Garden <dwainegarden@rogers.com> |
| * |
| * This module is part of usbvision driver project. |
| * Updates to driver completed by Dwaine P. Garden |
| * |
| * 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 2 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, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/delay.h> |
| #include <linux/slab.h> |
| #include <linux/version.h> |
| #include <linux/utsname.h> |
| #include <linux/init.h> |
| #include <asm/uaccess.h> |
| #include <linux/ioport.h> |
| #include <linux/errno.h> |
| #include <linux/sched.h> |
| #include <linux/usb.h> |
| #include <linux/i2c.h> |
| #include "usbvision-i2c.h" |
| |
| static int debug = 0; |
| |
| #if defined(module_param) // Showing parameters under SYSFS |
| module_param (debug, int, 0444); // debug mode of the device driver |
| #else |
| MODULE_PARM(debug, "i"); // debug mode of the device driver |
| #endif |
| |
| MODULE_AUTHOR("Joerg Heckenbach"); |
| MODULE_DESCRIPTION("I2C algorithm for USB-I2C-bridges"); |
| MODULE_LICENSE("GPL"); |
| |
| |
| static inline int try_write_address(struct i2c_adapter *i2c_adap, |
| unsigned char addr, int retries) |
| { |
| struct i2c_algo_usb_data *adap = i2c_adap->algo_data; |
| void *data; |
| int i, ret = -1; |
| char buf[4]; |
| |
| data = i2c_get_adapdata(i2c_adap); |
| buf[0] = 0x00; |
| for (i = 0; i <= retries; i++) { |
| ret = (adap->outb(data, addr, buf, 1)); |
| if (ret == 1) |
| break; /* success! */ |
| udelay(5 /*adap->udelay */ ); |
| if (i == retries) /* no success */ |
| break; |
| udelay(adap->udelay); |
| } |
| if (debug) { |
| if (i) { |
| info("%s: Needed %d retries for address %#2x", __FUNCTION__, i, addr); |
| info("%s: Maybe there's no device at this address", __FUNCTION__); |
| } |
| } |
| return ret; |
| } |
| |
| static inline int try_read_address(struct i2c_adapter *i2c_adap, |
| unsigned char addr, int retries) |
| { |
| struct i2c_algo_usb_data *adap = i2c_adap->algo_data; |
| void *data; |
| int i, ret = -1; |
| char buf[4]; |
| |
| data = i2c_get_adapdata(i2c_adap); |
| for (i = 0; i <= retries; i++) { |
| ret = (adap->inb(data, addr, buf, 1)); |
| if (ret == 1) |
| break; /* success! */ |
| udelay(5 /*adap->udelay */ ); |
| if (i == retries) /* no success */ |
| break; |
| udelay(adap->udelay); |
| } |
| if (debug) { |
| if (i) { |
| info("%s: Needed %d retries for address %#2x", __FUNCTION__, i, addr); |
| info("%s: Maybe there's no device at this address", __FUNCTION__); |
| } |
| } |
| return ret; |
| } |
| |
| static inline int usb_find_address(struct i2c_adapter *i2c_adap, |
| struct i2c_msg *msg, int retries, |
| unsigned char *add) |
| { |
| unsigned short flags = msg->flags; |
| |
| unsigned char addr; |
| int ret; |
| if ((flags & I2C_M_TEN)) { |
| /* a ten bit address */ |
| addr = 0xf0 | ((msg->addr >> 7) & 0x03); |
| /* try extended address code... */ |
| ret = try_write_address(i2c_adap, addr, retries); |
| if (ret != 1) { |
| err("died at extended address code, while writing"); |
| return -EREMOTEIO; |
| } |
| add[0] = addr; |
| if (flags & I2C_M_RD) { |
| /* okay, now switch into reading mode */ |
| addr |= 0x01; |
| ret = try_read_address(i2c_adap, addr, retries); |
| if (ret != 1) { |
| err("died at extended address code, while reading"); |
| return -EREMOTEIO; |
| } |
| } |
| |
| } else { /* normal 7bit address */ |
| addr = (msg->addr << 1); |
| if (flags & I2C_M_RD) |
| addr |= 1; |
| if (flags & I2C_M_REV_DIR_ADDR) |
| addr ^= 1; |
| |
| add[0] = addr; |
| if (flags & I2C_M_RD) |
| ret = try_read_address(i2c_adap, addr, retries); |
| else |
| ret = try_write_address(i2c_adap, addr, retries); |
| |
| if (ret != 1) { |
| return -EREMOTEIO; |
| } |
| } |
| return 0; |
| } |
| |
| static int |
| usb_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num) |
| { |
| struct i2c_msg *pmsg; |
| struct i2c_algo_usb_data *adap = i2c_adap->algo_data; |
| void *data; |
| int i, ret; |
| unsigned char addr; |
| |
| data = i2c_get_adapdata(i2c_adap); |
| |
| for (i = 0; i < num; i++) { |
| pmsg = &msgs[i]; |
| ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr); |
| if (ret != 0) { |
| if (debug) { |
| info("%s: got NAK from device, message #%d\n", __FUNCTION__, i); |
| } |
| return (ret < 0) ? ret : -EREMOTEIO; |
| } |
| |
| if (pmsg->flags & I2C_M_RD) { |
| /* read bytes into buffer */ |
| ret = (adap->inb(data, addr, pmsg->buf, pmsg->len)); |
| if (ret < pmsg->len) { |
| return (ret < 0) ? ret : -EREMOTEIO; |
| } |
| } else { |
| /* write bytes from buffer */ |
| ret = (adap->outb(data, addr, pmsg->buf, pmsg->len)); |
| if (ret < pmsg->len) { |
| return (ret < 0) ? ret : -EREMOTEIO; |
| } |
| } |
| } |
| return num; |
| } |
| |
| static int algo_control(struct i2c_adapter *adapter, unsigned int cmd, unsigned long arg) |
| { |
| return 0; |
| } |
| |
| static u32 usb_func(struct i2c_adapter *adap) |
| { |
| return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING; |
| } |
| |
| |
| /* -----exported algorithm data: ------------------------------------- */ |
| |
| static struct i2c_algorithm i2c_usb_algo = { |
| .master_xfer = usb_xfer, |
| .smbus_xfer = NULL, |
| .slave_send = NULL, |
| .slave_recv = NULL, |
| .algo_control = algo_control, |
| .functionality = usb_func, |
| }; |
| |
| |
| /* |
| * registering functions to load algorithms at runtime |
| */ |
| int usbvision_i2c_usb_add_bus(struct i2c_adapter *adap) |
| { |
| /* register new adapter to i2c module... */ |
| |
| adap->algo = &i2c_usb_algo; |
| |
| adap->timeout = 100; /* default values, should */ |
| adap->retries = 3; /* be replaced by defines */ |
| |
| #ifdef MODULE |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 21) |
| MOD_INC_USE_COUNT; |
| #endif |
| #endif |
| |
| i2c_add_adapter(adap); |
| |
| if (debug) { |
| info("i2c bus for %s registered", adap->name); |
| } |
| |
| return 0; |
| } |
| |
| |
| int usbvision_i2c_usb_del_bus(struct i2c_adapter *adap) |
| { |
| |
| i2c_del_adapter(adap); |
| |
| if (debug) { |
| info("i2c bus for %s unregistered", adap->name); |
| } |
| #ifdef MODULE |
| #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 21) |
| MOD_DEC_USE_COUNT; |
| #endif |
| #endif |
| |
| return 0; |
| } |
| |
| EXPORT_SYMBOL(usbvision_i2c_usb_add_bus); |
| EXPORT_SYMBOL(usbvision_i2c_usb_del_bus); |