Added missing tegra files.HEADmaster

1 files changed, 331 insertions, 0 deletions

diff --git a/drivers/misc/mpu3050/mlsl-kernel.c b/drivers/misc/mpu3050/mlsl-kernel.c
new file mode 100644
index 00000000000..cb1605131cb
--- /dev/null
+++ b/drivers/misc/mpu3050/mlsl-kernel.c
@@ -0,0 +1,331 @@
+/*
+ $License:
+    Copyright (C) 2010 InvenSense Corporation, All Rights Reserved.
+
+    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, see <http://www.gnu.org/licenses/>.
+  $
+ */
+
+#include "mlsl.h"
+#include "mpu-i2c.h"
+
+/* ------------ */
+/* - Defines. - */
+/* ------------ */
+
+/* ---------------------- */
+/* - Types definitions. - */
+/* ---------------------- */
+
+/* --------------------- */
+/* - Function p-types. - */
+/* --------------------- */
+
+/**
+ *  @brief  used to open the I2C or SPI serial port.
+ *          This port is used to send and receive data to the MPU device.
+ *  @param  portNum
+ *              The COM port number associated with the device in use.
+ *  @return ML_SUCCESS if successful, a non-zero error code otherwise.
+ */
+tMLError MLSLSerialOpen(char const *port, void **sl_handle)
+{
+        return ML_SUCCESS;
+}
+
+/**
+ *  @brief  used to reset any buffering the driver may be doing
+ *  @return ML_SUCCESS if successful, a non-zero error code otherwise.
+ */
+tMLError MLSLSerialReset(void *sl_handle)
+{
+        return ML_SUCCESS;
+}
+
+/**
+ *  @brief  used to close the I2C or SPI serial port.
+ *          This port is used to send and receive data to the MPU device.
+ *  @return ML_SUCCESS if successful, a non-zero error code otherwise.
+ */
+tMLError MLSLSerialClose(void *sl_handle)
+{
+        return ML_SUCCESS;
+}
+
+/**
+ *  @brief  used to read a single byte of data.
+ *          This should be sent by I2C or SPI.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  registerAddr    Register address to read.
+ *  @param  data            Single byte of data to read.
+ *
+ *  @return ML_SUCCESS if the command is successful, an error code otherwise.
+ */
+tMLError MLSLSerialWriteSingle(void *sl_handle,
+                               unsigned char slaveAddr,
+                               unsigned char registerAddr,
+                               unsigned char data)
+{
+        return sensor_i2c_write_register((struct i2c_adapter *) sl_handle,
+                                         slaveAddr, registerAddr, data);
+}
+
+
+/**
+ *  @brief  used to write multiple bytes of data from registers.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  registerAddr    Register address to write.
+ *  @param  length          Length of burst of data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return ML_SUCCESS if successful, a non-zero error code otherwise.
+ */
+tMLError MLSLSerialWrite(void *sl_handle,
+                         unsigned char slaveAddr,
+                         unsigned short length,
+                         unsigned char const *data)
+{
+        tMLError result;
+        const unsigned short dataLength = length - 1;
+        const unsigned char startRegAddr = data[0];
+        unsigned char i2cWrite[SERIAL_MAX_TRANSFER_SIZE + 1];
+        unsigned short bytesWritten = 0;
+
+        while (bytesWritten < dataLength) {
+                unsigned short thisLen = min(SERIAL_MAX_TRANSFER_SIZE,
+                                             dataLength - bytesWritten);
+                if (bytesWritten == 0) {
+                        result = sensor_i2c_write((struct i2c_adapter *)
+                                                  sl_handle, slaveAddr,
+                                                  1 + thisLen, data);
+                } else {
+                        /* manually increment register addr between chunks */
+                        i2cWrite[0] = startRegAddr + bytesWritten;
+                        memcpy(&i2cWrite[1], &data[1 + bytesWritten],
+                               thisLen);
+                        result = sensor_i2c_write((struct i2c_adapter *)
+                                                  sl_handle, slaveAddr,
+                                                  1 + thisLen, i2cWrite);
+                }
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesWritten += thisLen;
+        }
+        return ML_SUCCESS;
+}
+
+
+/**
+ *  @brief  used to read multiple bytes of data from registers.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  registerAddr    Register address to read.
+ *  @param  length          Length of burst of data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return Zero if successful; an error code otherwise
+ */
+tMLError MLSLSerialRead(void *sl_handle,
+                        unsigned char slaveAddr,
+                        unsigned char registerAddr,
+                        unsigned short length, unsigned char *data)
+{
+        tMLError result;
+        unsigned short bytesRead = 0;
+
+        if (registerAddr == MPUREG_FIFO_R_W
+            || registerAddr == MPUREG_MEM_R_W) {
+                return ML_ERROR_INVALID_PARAMETER;
+        }
+        while (bytesRead < length) {
+                unsigned short thisLen =
+                    min(SERIAL_MAX_TRANSFER_SIZE, length - bytesRead);
+                result =
+                    sensor_i2c_read((struct i2c_adapter *) sl_handle,
+                                    slaveAddr, registerAddr + bytesRead,
+                                    thisLen, &data[bytesRead]);
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesRead += thisLen;
+        }
+        return ML_SUCCESS;
+}
+
+
+/**
+ *  @brief  used to write multiple bytes of data to the memory.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  memAddr         The location in the memory to write to.
+ *  @param  length          Length of burst data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return Zero if successful; an error code otherwise
+ */
+tMLError MLSLSerialWriteMem(void *sl_handle,
+                            unsigned char slaveAddr,
+                            unsigned short memAddr,
+                            unsigned short length,
+                            unsigned char const *data)
+{
+        tMLError result;
+        unsigned short bytesWritten = 0;
+
+        if ((memAddr & 0xFF) + length > MPU_MEM_BANK_SIZE) {
+                pr_err("memory read length (%d B) extends beyond its"
+                        " limits (%d) if started at location %d\n", length,
+                        MPU_MEM_BANK_SIZE, memAddr & 0xFF);
+                return ML_ERROR_INVALID_PARAMETER;
+        }
+        while (bytesWritten < length) {
+                unsigned short thisLen =
+                    min(SERIAL_MAX_TRANSFER_SIZE, length - bytesWritten);
+                result =
+                    mpu_memory_write((struct i2c_adapter *) sl_handle,
+                                     slaveAddr, memAddr + bytesWritten,
+                                     thisLen, &data[bytesWritten]);
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesWritten += thisLen;
+        }
+        return ML_SUCCESS;
+}
+
+
+/**
+ *  @brief  used to read multiple bytes of data from the memory.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  memAddr         The location in the memory to read from.
+ *  @param  length          Length of burst data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return Zero if successful; an error code otherwise
+ */
+tMLError MLSLSerialReadMem(void *sl_handle,
+                           unsigned char slaveAddr,
+                           unsigned short memAddr,
+                           unsigned short length, unsigned char *data)
+{
+        tMLError result;
+        unsigned short bytesRead = 0;
+
+        if ((memAddr & 0xFF) + length > MPU_MEM_BANK_SIZE) {
+                printk
+                    ("memory read length (%d B) extends beyond its limits (%d) "
+                     "if started at location %d\n", length,
+                     MPU_MEM_BANK_SIZE, memAddr & 0xFF);
+                return ML_ERROR_INVALID_PARAMETER;
+        }
+        while (bytesRead < length) {
+                unsigned short thisLen =
+                    min(SERIAL_MAX_TRANSFER_SIZE, length - bytesRead);
+                result =
+                    mpu_memory_read((struct i2c_adapter *) sl_handle,
+                                    slaveAddr, memAddr + bytesRead,
+                                    thisLen, &data[bytesRead]);
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesRead += thisLen;
+        }
+        return ML_SUCCESS;
+}
+
+
+/**
+ *  @brief  used to write multiple bytes of data to the fifo.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  length          Length of burst of data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return Zero if successful; an error code otherwise
+ */
+tMLError MLSLSerialWriteFifo(void *sl_handle,
+                             unsigned char slaveAddr,
+                             unsigned short length,
+                             unsigned char const *data)
+{
+        tMLError result;
+        unsigned char i2cWrite[SERIAL_MAX_TRANSFER_SIZE + 1];
+        unsigned short bytesWritten = 0;
+
+        if (length > FIFO_HW_SIZE) {
+                printk(KERN_ERR
+                       "maximum fifo write length is %d\n", FIFO_HW_SIZE);
+                return ML_ERROR_INVALID_PARAMETER;
+        }
+        while (bytesWritten < length) {
+                unsigned short thisLen =
+                    min(SERIAL_MAX_TRANSFER_SIZE, length - bytesWritten);
+                i2cWrite[0] = MPUREG_FIFO_R_W;
+                memcpy(&i2cWrite[1], &data[bytesWritten], thisLen);
+                result = sensor_i2c_write((struct i2c_adapter *) sl_handle,
+                                          slaveAddr, thisLen + 1,
+                                          i2cWrite);
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesWritten += thisLen;
+        }
+        return ML_SUCCESS;
+}
+
+
+/**
+ *  @brief  used to read multiple bytes of data from the fifo.
+ *          This should be sent by I2C.
+ *
+ *  @param  slaveAddr       I2C slave address of device.
+ *  @param  length          Length of burst of data.
+ *  @param  data            Pointer to block of data.
+ *
+ *  @return Zero if successful; an error code otherwise
+ */
+tMLError MLSLSerialReadFifo(void *sl_handle,
+                            unsigned char slaveAddr,
+                            unsigned short length, unsigned char *data)
+{
+        tMLError result;
+        unsigned short bytesRead = 0;
+
+        if (length > FIFO_HW_SIZE) {
+                printk(KERN_ERR
+                       "maximum fifo read length is %d\n", FIFO_HW_SIZE);
+                return ML_ERROR_INVALID_PARAMETER;
+        }
+        while (bytesRead < length) {
+                unsigned short thisLen =
+                    min(SERIAL_MAX_TRANSFER_SIZE, length - bytesRead);
+                result =
+                    sensor_i2c_read((struct i2c_adapter *) sl_handle,
+                                    slaveAddr, MPUREG_FIFO_R_W, thisLen,
+                                    &data[bytesRead]);
+                if (ML_SUCCESS != result)
+                        return result;
+                bytesRead += thisLen;
+        }
+
+        return ML_SUCCESS;
+}
+
+/**
+ *  @}
+ */