| /****************************************************************************** |
| * $Id: AK8975Driver.c 580 2012-03-29 09:56:21Z yamada.rj $ |
| ****************************************************************************** |
| * |
| * Copyright (C) 2012 Asahi Kasei Microdevices Corporation, Japan |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <fcntl.h> |
| #include "AKFS_Common.h" |
| #include "AK8975Driver.h" |
| |
| #define MSENSOR_NAME "/dev/akm8975_dev" |
| |
| static int s_fdDev = -1; |
| |
| /*! |
| Open device driver. |
| This function opens both device drivers of magnetic sensor and acceleration |
| sensor. Additionally, some initial hardware settings are done, such as |
| measurement range, built-in filter function and etc. |
| @return If this function succeeds, the return value is #AKD_SUCCESS. |
| Otherwise the return value is #AKD_FAIL. |
| */ |
| int16_t AKD_InitDevice(void) |
| { |
| if (s_fdDev < 0) { |
| /* Open magnetic sensor's device driver. */ |
| if ((s_fdDev = open(MSENSOR_NAME, O_RDWR)) < 0) { |
| AKMERROR_STR("open"); |
| return AKD_FAIL; |
| } |
| } |
| |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| Close device driver. |
| This function closes both device drivers of magnetic sensor and acceleration |
| sensor. |
| */ |
| void AKD_DeinitDevice(void) |
| { |
| if (s_fdDev >= 0) { |
| close(s_fdDev); |
| s_fdDev = -1; |
| } |
| } |
| |
| /*! |
| Writes data to a register of the AK8975. When more than one byte of data is |
| specified, the data is written in contiguous locations starting at an address |
| specified in \a address. |
| @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise |
| the return value is #AKD_FAIL. |
| @param[in] address Specify the address of a register in which data is to be |
| written. |
| @param[in] data Specify data to write or a pointer to a data array containing |
| the data. When specifying more than one byte of data, specify the starting |
| address of the array. |
| @param[in] numberOfBytesToWrite Specify the number of bytes that make up the |
| data to write. When a pointer to an array is specified in data, this argument |
| equals the number of elements of the array. |
| */ |
| int16_t AKD_TxData( |
| const BYTE address, |
| const BYTE * data, |
| const uint16_t numberOfBytesToWrite) |
| { |
| int i; |
| char buf[RWBUF_SIZE]; |
| |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (numberOfBytesToWrite > (RWBUF_SIZE-2)) { |
| ALOGE("%s: Tx size is too large.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| |
| buf[0] = numberOfBytesToWrite + 1; |
| buf[1] = address; |
| |
| for (i = 0; i < numberOfBytesToWrite; i++) { |
| buf[i + 2] = data[i]; |
| } |
| if (ioctl(s_fdDev, ECS_IOCTL_WRITE, buf) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } else { |
| |
| #if ENABLE_AKMDEBUG |
| AKMDATA(AKMDATA_DRV, "addr(HEX)=%02x data(HEX)=", address); |
| for (i = 0; i < numberOfBytesToWrite; i++) { |
| AKMDATA(AKMDATA_DRV, " %02x", data[i]); |
| } |
| AKMDATA(AKMDATA_DRV, "\n"); |
| #endif |
| return AKD_SUCCESS; |
| } |
| } |
| |
| /*! |
| Acquires data from a register or the EEPROM of the AK8975. |
| @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise |
| the return value is #AKD_FAIL. |
| @param[in] address Specify the address of a register from which data is to be |
| read. |
| @param[out] data Specify a pointer to a data array which the read data are |
| stored. |
| @param[in] numberOfBytesToRead Specify the number of bytes that make up the |
| data to read. When a pointer to an array is specified in data, this argument |
| equals the number of elements of the array. |
| */ |
| int16_t AKD_RxData( |
| const BYTE address, |
| BYTE * data, |
| const uint16_t numberOfBytesToRead) |
| { |
| int i; |
| char buf[RWBUF_SIZE]; |
| |
| memset(data, 0, numberOfBytesToRead); |
| |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (numberOfBytesToRead > (RWBUF_SIZE-1)) { |
| ALOGE("%s: Rx size is too large.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| |
| buf[0] = numberOfBytesToRead; |
| buf[1] = address; |
| |
| if (ioctl(s_fdDev, ECS_IOCTL_READ, buf) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } else { |
| for (i = 0; i < numberOfBytesToRead; i++) { |
| data[i] = buf[i + 1]; |
| } |
| #if ENABLE_AKMDEBUG |
| AKMDATA(AKMDATA_DRV, "addr(HEX)=%02x len=%d data(HEX)=", |
| address, numberOfBytesToRead); |
| for (i = 0; i < numberOfBytesToRead; i++) { |
| AKMDATA(AKMDATA_DRV, " %02x", data[i]); |
| } |
| AKMDATA(AKMDATA_DRV, "\n"); |
| #endif |
| return AKD_SUCCESS; |
| } |
| } |
| |
| /*! |
| Acquire magnetic data from AK8975. If measurement is not done, this function |
| waits until measurement completion. |
| @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise |
| the return value is #AKD_FAIL. |
| @param[out] data A magnetic data array. The size should be larger than #SENSOR_DATA_SIZE. |
| */ |
| int16_t AKD_GetMagneticData(BYTE data[SENSOR_DATA_SIZE]) |
| { |
| memset(data, 0, SENSOR_DATA_SIZE); |
| |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| |
| if (ioctl(s_fdDev, ECS_IOCTL_GETDATA, data) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| |
| AKMDATA(AKMDATA_DRV, |
| "bdata(HEX)= %02x %02x %02x %02x %02x %02x %02x %02x\n", |
| data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); |
| |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| Set calculated data to device driver. |
| @param[in] buf The order of input data depends on driver's specification. |
| */ |
| void AKD_SetYPR(const int buf[YPR_DATA_SIZE]) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| } else { |
| if (ioctl(s_fdDev, ECS_IOCTL_SET_YPR, buf) < 0) { |
| AKMERROR_STR("ioctl"); |
| } |
| } |
| } |
| |
| /*! |
| */ |
| int AKD_GetOpenStatus(int* status) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (ioctl(s_fdDev, ECS_IOCTL_GET_OPEN_STATUS, status) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| */ |
| int AKD_GetCloseStatus(int* status) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (ioctl(s_fdDev, ECS_IOCTL_GET_CLOSE_STATUS, status) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| Set AK8975 to the specific mode. |
| @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise |
| the return value is #AKD_FAIL. |
| @param[in] mode This value should be one of the AK8975_Mode which is defined in |
| akm8975.h file. |
| */ |
| int16_t AKD_SetMode(const BYTE mode) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| |
| if (ioctl(s_fdDev, ECS_IOCTL_SET_MODE, &mode) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| Acquire delay |
| @return If this function succeeds, the return value is #AKD_SUCCESS. Otherwise |
| the return value is #AKD_FAIL. |
| @param[out] delay A delay in nanosecond. |
| */ |
| int16_t AKD_GetDelay(int64_t delay[AKM_NUM_SENSORS]) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.\n", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (ioctl(s_fdDev, ECS_IOCTL_GET_DELAY, delay) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| return AKD_SUCCESS; |
| } |
| |
| /*! |
| Get layout information from device driver, i.e. platform data. |
| */ |
| int16_t AKD_GetLayout(int16_t* layout) |
| { |
| char tmp; |
| |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| |
| if (ioctl(s_fdDev, ECS_IOCTL_GET_LAYOUT, &tmp) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| |
| *layout = tmp; |
| return AKD_SUCCESS; |
| } |
| |
| /* Get acceleration data. */ |
| int16_t AKD_GetAccelerationData(int16_t data[3]) |
| { |
| if (s_fdDev < 0) { |
| ALOGE("%s: Device file is not opened.", __FUNCTION__); |
| return AKD_FAIL; |
| } |
| if (ioctl(s_fdDev, ECS_IOCTL_GET_ACCEL, data) < 0) { |
| AKMERROR_STR("ioctl"); |
| return AKD_FAIL; |
| } |
| |
| AKMDATA(AKMDATA_DRV, "%s: acc=%d, %d, %d\n", |
| __FUNCTION__, data[0], data[1], data[2]); |
| |
| return AKD_SUCCESS; |
| } |