drivers/input/sensors/accel/dmard10.c

   1 /* drivers/input/sensors/access/dmard10.c\r
   2  *\r
   3  * Copyright (C) 2012-2015 ROCKCHIP.\r
   4  * Author: guoyi <gy@rock-chips.com>\r
   5  *\r
   6  * This software is licensed under the terms of the GNU General Public\r
   7  * License version 2, as published by the Free Software Foundation, and\r
   8  * may be copied, distributed, and modified under those terms.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  */\r
  16 #include <linux/interrupt.h>\r
  17 #include <linux/i2c.h>\r
  18 #include <linux/slab.h>\r
  19 #include <linux/irq.h>\r
  20 #include <linux/miscdevice.h>\r
  21 #include <linux/gpio.h>\r
  22 #include <asm/uaccess.h>\r
  23 #include <asm/atomic.h>\r
  24 #include <linux/delay.h>\r
  25 #include <linux/input.h>\r
  26 #include <linux/workqueue.h>\r
  27 #include <linux/freezer.h>\r
  28 #include <linux/of_gpio.h>\r
  29 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  30 #include <linux/earlysuspend.h>\r
  31 #endif\r
  32 #include <linux/sensor-dev.h>\r
  33 \r
  34 /* Default register settings */\r
  35 #define RBUFF_SIZE              12      /* Rx buffer size */\r
  36 \r
  37 #define REG_ACTR                                0x00\r
  38 #define REG_WDAL                                0x01\r
  39 #define REG_TAPNS                               0x0f\r
  40 #define REG_MISC2                               0x1f\r
  41 #define REG_AFEM                                0x0c\r
  42 #define REG_CKSEL                               0x0d\r
  43 #define REG_INTC                                0x0e\r
  44 #define REG_STADR                               0x12\r
  45 #define REG_STAINT                              0x1C\r
  46 #define REG_PD                                  0x21\r
  47 #define REG_TCGYZ                               0x26\r
  48 #define REG_X_OUT                               0x41\r
  49 \r
  50 #define MODE_Off                                0x00\r
  51 #define MODE_ResetAtOff                 0x01\r
  52 #define MODE_Standby                    0x02\r
  53 #define MODE_ResetAtStandby             0x03\r
  54 #define MODE_Active                             0x06\r
  55 #define MODE_Trigger                    0x0a\r
  56 #define MODE_ReadOTP                    0x12\r
  57 #define MODE_WriteOTP                   0x22\r
  58 #define MODE_WriteOTPBuf                0x42\r
  59 #define MODE_ResetDataPath              0x82\r
  60 \r
  61 #define VALUE_STADR                                     0x55\r
  62 #define VALUE_STAINT                            0xAA\r
  63 #define VALUE_AFEM_AFEN_Normal          0x8f// AFEN set 1 , ATM[2:0]=b'000(normal),EN_Z/Y/X/T=1\r
  64 #define VALUE_AFEM_Normal                       0x0f// AFEN set 0 , ATM[2:0]=b'000(normal),EN_Z/Y/X/T=1\r
  65 #define VALUE_INTC                                      0x00// INTC[6:5]=b'00 \r
  66 #define VALUE_INTC_Interrupt_En         0x20// INTC[6:5]=b'01 (Data ready interrupt enable, active high at INT0)\r
  67 #define VALUE_CKSEL_ODR_0_204           0x04// ODR[3:0]=b'0000 (0.78125Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  68 #define VALUE_CKSEL_ODR_1_204           0x14// ODR[3:0]=b'0001 (1.5625Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  69 #define VALUE_CKSEL_ODR_3_204           0x24// ODR[3:0]=b'0010 (3.125Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  70 #define VALUE_CKSEL_ODR_6_204           0x34// ODR[3:0]=b'0011 (6.25Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  71 #define VALUE_CKSEL_ODR_12_204          0x44// ODR[3:0]=b'0100 (12.5Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  72 #define VALUE_CKSEL_ODR_25_204          0x54// ODR[3:0]=b'0101 (25Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  73 #define VALUE_CKSEL_ODR_50_204          0x64// ODR[3:0]=b'0110 (50Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  74 #define VALUE_CKSEL_ODR_100_204         0x74// ODR[3:0]=b'0111 (100Hz), CCK[3:0]=b'0100 (204.8kHZ)\r
  75 \r
  76 #define VALUE_TAPNS_NoFilter    0x00    // TAP1/TAP2    NO FILTER\r
  77 #define VALUE_TAPNS_Ave_2               0x11    // TAP1/TAP2    Average 2\r
  78 #define VALUE_TAPNS_Ave_4               0x22    // TAP1/TAP2    Average 4\r
  79 #define VALUE_TAPNS_Ave_8               0x33    // TAP1/TAP2    Average 8\r
  80 #define VALUE_TAPNS_Ave_16              0x44    // TAP1/TAP2    Average 16\r
  81 #define VALUE_TAPNS_Ave_32              0x55    // TAP1/TAP2    Average 32\r
  82 #define VALUE_MISC2_OSCA_EN             0x08\r
  83 #define VALUE_PD_RST                    0x52\r
  84 \r
  85 \r
  86 //#define DMARD10_REG_INTSU        0x47\r
  87 //#define DMARD10_REG_MODE        0x44\r
  88 //#define DMARD10_REG_SR               0x44\r
  89 \r
  90 \r
  91 #define DMARD10_REG_DS      0X49\r
  92 #define DMARD10_REG_ID       0X0F\r
  93 #define DMARD10_REG_IT       0X4D\r
  94 #define DMARD10_REG_INTSRC1_C       0X4A\r
  95 #define DMARD10_REG_INTSRC1_S       0X4B\r
  96 #define MMAIO                           0xA1\r
  97 \r
  98 // IOCTLs for DMARD10 library \r
  99 #define ECS_IOCTL_INIT                  _IO(MMAIO, 0x01)\r
 100 #define ECS_IOCTL_RESET                 _IO(MMAIO, 0x04)\r
 101 #define ECS_IOCTL_CLOSE                 _IO(MMAIO, 0x02)\r
 102 #define ECS_IOCTL_START                 _IO(MMAIO, 0x03)\r
 103 #define ECS_IOCTL_GETDATA               _IOR(MMAIO, 0x08, char[RBUFF_SIZE+1])\r
 104 #define SENSOR_CALIBRATION              _IOWR(MMAIO, 0x05 , int[SENSOR_DATA_SIZE])\r
 105          \r
 106 // IOCTLs for APPs \r
 107 #define ECS_IOCTL_APP_SET_RATE          _IOW(MMAIO, 0x10, char)\r
 108 \r
 109  //rate\r
 110 #define DMARD10_RANGE                                           2000000\r
 111 \r
 112 #define DMARD10_RATE_32         32\r
 113 /*\r
 114 #define DMARD10_RATE_64         64\r
 115 #define DMARD10_RATE_120        128\r
 116 #define DMARD10_RATE_MIN                DMARD10_RATE_1\r
 117 #define DMARD10_RATE_MAX                DMARD10_RATE_120\r
 118 */\r
 119 /*status*/\r
 120 #define DMARD10_OPEN               1\r
 121 #define DMARD10_CLOSE              0\r
 122 #define DMARD10_NORMAL             2\r
 123 #define DMARD10_LOWPOWER           3\r
 124 \r
 125 \r
 126 \r
 127 #define DMARD10_IIC_ADDR            0x18  \r
 128 #define DMARD10_REG_LEN         11\r
 129 \r
 130 \r
 131 #define DMARD10_FATOR   15 \r
 132 \r
 133 \r
 134 #define DMARD10_X_OUT           0x41\r
 135 #define SENSOR_DATA_SIZE 3\r
 136 #define DMARD10_SENSOR_RATE_1   0\r
 137 #define DMARD10_SENSOR_RATE_2   1\r
 138 #define DMARD10_SENSOR_RATE_3   2\r
 139 #define DMARD10_SENSOR_RATE_4   3\r
 140 \r
 141 #define POWER_OR_RATE 1\r
 142 #define SW_RESET 1\r
 143 #define DMARD10_INTERRUPUT 1\r
 144 #define DMARD10_POWERDOWN 0 \r
 145 #define DMARD10_POWERON 1 \r
 146 \r
 147 //g-senor layout configuration, choose one of the following configuration\r
 148 \r
 149 #define AVG_NUM                         16\r
 150 #define SENSOR_DATA_SIZE                3 \r
 151 #define DEFAULT_SENSITIVITY             1024\r
 152 \r
 153 \r
 154 \r
 155 #define DMARD10_ENABLE          1\r
 156 \r
 157 #define DMARD10_REG_X_OUT       0x12\r
 158 #define DMARD10_REG_Y_OUT       0x1\r
 159 #define DMARD10_REG_Z_OUT       0x2\r
 160 #define DMARD10_REG_TILT        0x3\r
 161 #define DMARD10_REG_SRST        0x4\r
 162 #define DMARD10_REG_SPCNT       0x5\r
 163 #define DMARD10_REG_INTSU       0x6\r
 164 #define DMARD10_REG_MODE        0x7\r
 165 #define DMARD10_REG_SR          0x8\r
 166 #define DMARD10_REG_PDET        0x9\r
 167 #define DMARD10_REG_PD          0xa\r
 168 \r
 169 #define DMARD10_RANGE                   4000000\r
 170 #define DMARD10_PRECISION       10\r
 171 #define DMARD10_BOUNDARY        (0x1 << (DMARD10_PRECISION  - 1)) \r
 172 #define DMARD10_GRAVITY_STEP    (DMARD10_RANGE / DMARD10_BOUNDARY)\r
 173 \r
 174 \r
 175 struct sensor_axis_average {\r
 176                 int x_average;\r
 177                 int y_average;\r
 178                 int z_average;\r
 179                 int count;\r
 180 };\r
 181 \r
 182 static struct sensor_axis_average axis_average;\r
 183 int gsensor_reset(struct i2c_client *client){\r
 184         struct sensor_private_data *sensor =\r
 185             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 186         \r
 187         char buffer[7], buffer2[2];\r
 188         /* 1. check D10 , VALUE_STADR = 0x55 , VALUE_STAINT = 0xAA */\r
 189         buffer[0] = REG_STADR;\r
 190         buffer2[0] = REG_STAINT;\r
 191         \r
 192         sensor_rx_data(client, buffer, 2);\r
 193         sensor_rx_data(client, buffer2, 2);\r
 194                 \r
 195         if( buffer[0] == VALUE_STADR || buffer2[0] == VALUE_STAINT){\r
 196                 DBG(KERN_INFO " REG_STADR_VALUE = %d , REG_STAINT_VALUE = %d\n", buffer[0], buffer2[0]);\r
 197                 DBG(KERN_INFO " %s DMT_DEVICE_NAME registered I2C driver!\n",__FUNCTION__);\r
 198         }\r
 199         else{\r
 200                 DBG(KERN_INFO " %s gsensor I2C err @@@ REG_STADR_VALUE = %d , REG_STAINT_VALUE = %d \n", __func__, buffer[0], buffer2[0]);\r
 201                 return -1;\r
 202         }\r
 203         /* 2. Powerdown reset */\r
 204         buffer[0] = REG_PD;\r
 205         buffer[1] = VALUE_PD_RST;\r
 206         sensor_tx_data(client, buffer, 2);\r
 207         /* 3. ACTR => Standby mode => Download OTP to parameter reg => Standby mode => Reset data path => Standby mode */\r
 208         buffer[0] = REG_ACTR;\r
 209         buffer[1] = MODE_Standby;\r
 210         buffer[2] = MODE_ReadOTP;\r
 211         buffer[3] = MODE_Standby;\r
 212         buffer[4] = MODE_ResetDataPath;\r
 213         buffer[5] = MODE_Standby;\r
 214         sensor_tx_data(client, buffer, 6);\r
 215         /* 4. OSCA_EN = 1 ,TSTO = b'000(INT1 = normal, TEST0 = normal) */\r
 216         buffer[0] = REG_MISC2;\r
 217         buffer[1] = VALUE_MISC2_OSCA_EN;\r
 218         sensor_tx_data(client, buffer, 2);\r
 219         /* 5. AFEN = 1(AFE will powerdown after ADC) */\r
 220         buffer[0] = REG_AFEM;\r
 221         buffer[1] = VALUE_AFEM_AFEN_Normal;     \r
 222         buffer[2] = VALUE_CKSEL_ODR_100_204;    \r
 223         buffer[3] = VALUE_INTC; \r
 224         buffer[4] = VALUE_TAPNS_Ave_2;\r
 225         buffer[5] = 0x00;       // DLYC, no delay timing\r
 226         buffer[6] = 0x07;       // INTD=1 (push-pull), INTA=1 (active high), AUTOT=1 (enable T)\r
 227         sensor_tx_data(client, buffer, 7);\r
 228         /* 6. write TCGYZ & TCGX */\r
 229         buffer[0] = REG_WDAL;   // REG:0x01\r
 230         buffer[1] = 0x00;               // set TC of Y,Z gain value\r
 231         buffer[2] = 0x00;               // set TC of X gain value\r
 232         buffer[3] = 0x03;               // Temperature coefficient of X,Y,Z gain\r
 233         sensor_tx_data(client, buffer, 4);\r
 234         \r
 235         buffer[0] = REG_ACTR;                   // REG:0x00\r
 236         buffer[1] = MODE_Standby;               // Standby\r
 237         buffer[2] = MODE_WriteOTPBuf;   // WriteOTPBuf \r
 238         buffer[3] = MODE_Standby;               // Standby\r
 239         \r
 240         /* 7. Activation mode */\r
 241         buffer[0] = REG_ACTR;\r
 242         buffer[1] = MODE_Active;\r
 243         sensor_tx_data(client, buffer, 2);\r
 244         printk("\n dmard10 gsensor _reset SUCCESS!!\n");\r
 245         return 0;\r
 246 }\r
 247 \r
 248 /****************operate according to sensor chip:start************/\r
 249 \r
 250 static int sensor_active(struct i2c_client *client, int enable, int rate)\r
 251 {\r
 252         struct sensor_private_data *sensor =\r
 253             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 254         int result = 0;\r
 255         int status = 0;\r
 256                 gsensor_reset(client);\r
 257         sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);\r
 258         //register setting according to chip datasheet          \r
 259         if(enable)\r
 260         {       \r
 261                 status = DMARD10_ENABLE;        //dmard10\r
 262                 sensor->ops->ctrl_data |= status;       \r
 263         }\r
 264         else\r
 265         {\r
 266                 status = ~DMARD10_ENABLE;       //dmard10\r
 267                 sensor->ops->ctrl_data &= status;\r
 268         }\r
 269 \r
 270         DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);\r
 271         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);\r
 272         if(result)\r
 273                 printk("%s:fail to active sensor\n",__func__);\r
 274         \r
 275         return result;\r
 276 \r
 277 }\r
 278 \r
 279 static int sensor_init(struct i2c_client *client)\r
 280 {       \r
 281         struct sensor_private_data *sensor =\r
 282             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 283         int result = 0;\r
 284         \r
 285         result = sensor->ops->active(client,0,0);\r
 286         if(result)\r
 287         {\r
 288                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 289                 return result;\r
 290         }\r
 291         \r
 292         sensor->status_cur = SENSOR_OFF;\r
 293 \r
 294         DBG("%s:DMARD10_REG_TILT=0x%x\n",__func__,sensor_read_reg(client, DMARD10_REG_TILT));\r
 295 \r
 296         result = sensor_write_reg(client, DMARD10_REG_SR, (0x01<<5)| 0x02);     //32 Samples/Second Active and Auto-Sleep Mode\r
 297         if(result)\r
 298         {\r
 299                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 300                 return result;\r
 301         }\r
 302 \r
 303         if(sensor->pdata->irq_enable)   //open interrupt\r
 304         {\r
 305                 result = sensor_write_reg(client, DMARD10_REG_INTSU, 1<<4);//enable int,GINT=1\r
 306                 if(result)\r
 307                 {\r
 308                         printk("%s:line=%d,error\n",__func__,__LINE__);\r
 309                         return result;\r
 310                 }\r
 311         }\r
 312         \r
 313         sensor->ops->ctrl_data = 1<<6;  //Interrupt output INT is push-pull\r
 314         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);\r
 315         if(result)\r
 316         {\r
 317                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 318                 return result;\r
 319         }\r
 320 \r
 321         \r
 322         memset(&axis_average, 0, sizeof(struct sensor_axis_average));\r
 323 \r
 324         return result;\r
 325 }\r
 326 \r
 327 \r
 328 static int sensor_convert_data(struct i2c_client *client, char high_byte, char low_byte)\r
 329 {\r
 330     s64 result;\r
 331         \r
 332          \r
 333                 result = ((int)high_byte << 8)|((int)low_byte);\r
 334         \r
 335                 if (result < DMARD10_BOUNDARY){\r
 336                         result = result* DMARD10_GRAVITY_STEP;\r
 337                 }else{\r
 338                         result = ~( ((~result & (0x7fff>>(16-DMARD10_PRECISION)) ) + 1)* DMARD10_GRAVITY_STEP) + 1;\r
 339                 }\r
 340                         \r
 341                 return result;\r
 342 \r
 343 }\r
 344 \r
 345 static int gsensor_report_value(struct i2c_client *client, struct sensor_axis *axis)\r
 346 {\r
 347         struct sensor_private_data *sensor =\r
 348             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 349 \r
 350         /* Report acceleration sensor information */\r
 351         input_report_abs(sensor->input_dev, ABS_X, axis->x);\r
 352         input_report_abs(sensor->input_dev, ABS_Y, axis->y);\r
 353         input_report_abs(sensor->input_dev, ABS_Z, axis->z);\r
 354         input_sync(sensor->input_dev);\r
 355         DBG("Gsensor x==%d  y==%d z==%d\n",axis->x,axis->y,axis->z);\r
 356 \r
 357         return 0;\r
 358 }\r
 359 #define DMARD10_COUNT_AVERAGE 2\r
 360 #define GSENSOR_MIN             2\r
 361 static int sensor_report_value(struct i2c_client *client)\r
 362 {\r
 363         struct sensor_private_data *sensor =\r
 364                 (struct sensor_private_data *) i2c_get_clientdata(client);      \r
 365         struct sensor_platform_data *pdata = sensor->pdata;\r
 366         int ret = 0;\r
 367         int x,y,z;\r
 368         struct sensor_axis axis;\r
 369         char buffer[8] = {0};   \r
 370         char value = 0;\r
 371         \r
 372         if(sensor->ops->read_len < 3)   //sensor->ops->read_len = 3\r
 373         {\r
 374                 printk("%s:lenth is error,len=%d\n",__func__,sensor->ops->read_len);\r
 375                 return -1;\r
 376         }\r
 377         \r
 378         memset(buffer, 0, 8);\r
 379         /* Data bytes from hardware xL, xH, yL, yH, zL, zH */   \r
 380         do {\r
 381                 *buffer = sensor->ops->read_reg;\r
 382                 ret = sensor_rx_data(client, buffer, sensor->ops->read_len);\r
 383                 if (ret < 0)\r
 384                 return ret;\r
 385         } while (0);\r
 386 \r
 387         //this gsensor need 6 bytes buffer\r
 388         x = sensor_convert_data(sensor->client, buffer[3], buffer[2]);  //buffer[1]:high bit \r
 389         y = sensor_convert_data(sensor->client, buffer[5], buffer[4]);\r
 390         z = sensor_convert_data(sensor->client, buffer[7], buffer[6]);          \r
 391                 \r
 392         axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;\r
 393         axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z; \r
 394         axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;\r
 395 \r
 396         \r
 397         axis_average.x_average += axis.x;\r
 398         axis_average.y_average += axis.y;\r
 399         axis_average.z_average += axis.z;\r
 400         axis_average.count++;\r
 401         \r
 402         if(axis_average.count >= DMARD10_COUNT_AVERAGE)\r
 403         {\r
 404                 axis.x = axis_average.x_average / axis_average.count;   \r
 405                 axis.y = axis_average.y_average / axis_average.count;   \r
 406                 axis.z = axis_average.z_average / axis_average.count;\r
 407                 \r
 408                 DBG( "%s: axis = %d  %d  %d \n", __func__, axis.x, axis.y, axis.z);\r
 409                 \r
 410                 memset(&axis_average, 0, sizeof(struct sensor_axis_average));\r
 411                 \r
 412                 //Report event only while value is changed to save some power\r
 413                 if((abs(sensor->axis.x - axis.x) > GSENSOR_MIN) || (abs(sensor->axis.y - axis.y) > GSENSOR_MIN) || (abs(sensor->axis.z - axis.z) > GSENSOR_MIN))\r
 414                 {\r
 415                         gsensor_report_value(client, &axis);\r
 416 \r
 417                         /* »¥³âµØ»º´æÊý¾Ý. */\r
 418                         mutex_lock(&(sensor->data_mutex) );\r
 419                         sensor->axis = axis;\r
 420                         mutex_unlock(&(sensor->data_mutex) );\r
 421                 }\r
 422         }\r
 423         \r
 424         if((sensor->pdata->irq_enable)&& (sensor->ops->int_status_reg >= 0))    //read sensor intterupt status register\r
 425         {\r
 426                 \r
 427                 value = sensor_read_reg(client, sensor->ops->int_status_reg);\r
 428                 DBG("%s:sensor int status :0x%x\n",__func__,value);\r
 429         }\r
 430         \r
 431         return ret;\r
 432 }\r
 433 \r
 434 \r
 435 struct sensor_operate gsensor_dmard10_ops = {\r
 436         .name                           = "gs_dmard10",\r
 437         .type                           = SENSOR_TYPE_ACCEL,                    //sensor type and it should be correct\r
 438         .id_i2c                         = ACCEL_ID_DMARD10,                     //i2c id number\r
 439         .read_reg                       = DMARD10_REG_X_OUT,                    //read data\r
 440         .read_len                       = 8,                                    //data length\r
 441         .id_reg                         = SENSOR_UNKNOW_DATA,                   //read device id from this register\r
 442         .id_data                        = SENSOR_UNKNOW_DATA,                   //device id\r
 443         .precision                      = DMARD10_PRECISION,                    //12 bit\r
 444         .ctrl_reg                       = DMARD10_REG_MODE,                     //enable or disable     \r
 445         .int_status_reg         = SENSOR_UNKNOW_DATA,                   //intterupt status register\r
 446         .range                          = {-DMARD10_RANGE,DMARD10_RANGE},       //range\r
 447         .trig                           = IRQF_TRIGGER_LOW|IRQF_ONESHOT,                \r
 448         .active                         = sensor_active,        \r
 449         .init                           = sensor_init,\r
 450         .report                         = sensor_report_value,\r
 451 };\r
 452 \r
 453 /****************operate according to sensor chip:end************/\r
 454 \r
 455 //function name should not be changed\r
 456 static struct sensor_operate *gsensor_get_ops(void)\r
 457 {\r
 458         return &gsensor_dmard10_ops;\r
 459 }\r
 460 \r
 461 \r
 462 static int __init gsensor_dmard10_init(void)\r
 463 {\r
 464         struct sensor_operate *ops = gsensor_get_ops();\r
 465         int result = 0;\r
 466         int type = ops->type;\r
 467         result = sensor_register_slave(type, NULL, NULL, gsensor_get_ops);      \r
 468         return result;\r
 469 }\r
 470 \r
 471 static void __exit gsensor_dmard10_exit(void)\r
 472 {\r
 473         struct sensor_operate *ops = gsensor_get_ops();\r
 474         int type = ops->type;\r
 475         sensor_unregister_slave(type, NULL, NULL, gsensor_get_ops);\r
 476 }\r
 477 \r
 478 \r
 479 module_init(gsensor_dmard10_init);\r
 480 module_exit(gsensor_dmard10_exit);\r
 481 \r
 482 \r
 483 \r