1 /* 2 * Copyright (C) 2012 Invensense, Inc. 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/acpi.h> 15 #include <linux/delay.h> 16 #include <linux/err.h> 17 #include <linux/i2c.h> 18 #include <linux/i2c-mux.h> 19 #include <linux/iio/iio.h> 20 #include <linux/module.h> 21 #include "inv_mpu_iio.h" 22 23 static const struct regmap_config inv_mpu_regmap_config = { 24 .reg_bits = 8, 25 .val_bits = 8, 26 }; 27 28 /* 29 * The i2c read/write needs to happen in unlocked mode. As the parent 30 * adapter is common. If we use locked versions, it will fail as 31 * the mux adapter will lock the parent i2c adapter, while calling 32 * select/deselect functions. 33 */ 34 static int inv_mpu6050_write_reg_unlocked(struct i2c_client *client, 35 u8 reg, u8 d) 36 { 37 int ret; 38 u8 buf[2] = {reg, d}; 39 struct i2c_msg msg[1] = { 40 { 41 .addr = client->addr, 42 .flags = 0, 43 .len = sizeof(buf), 44 .buf = buf, 45 } 46 }; 47 48 ret = __i2c_transfer(client->adapter, msg, 1); 49 if (ret != 1) 50 return ret; 51 52 return 0; 53 } 54 55 static int inv_mpu6050_select_bypass(struct i2c_adapter *adap, void *mux_priv, 56 u32 chan_id) 57 { 58 struct i2c_client *client = mux_priv; 59 struct iio_dev *indio_dev = dev_get_drvdata(&client->dev); 60 struct inv_mpu6050_state *st = iio_priv(indio_dev); 61 int ret = 0; 62 63 /* Use the same mutex which was used everywhere to protect power-op */ 64 mutex_lock(&indio_dev->mlock); 65 if (!st->powerup_count) { 66 ret = inv_mpu6050_write_reg_unlocked(client, 67 st->reg->pwr_mgmt_1, 0); 68 if (ret) 69 goto write_error; 70 71 usleep_range(INV_MPU6050_REG_UP_TIME_MIN, 72 INV_MPU6050_REG_UP_TIME_MAX); 73 } 74 if (!ret) { 75 st->powerup_count++; 76 ret = inv_mpu6050_write_reg_unlocked(client, 77 st->reg->int_pin_cfg, 78 INV_MPU6050_INT_PIN_CFG | 79 INV_MPU6050_BIT_BYPASS_EN); 80 } 81 write_error: 82 mutex_unlock(&indio_dev->mlock); 83 84 return ret; 85 } 86 87 static int inv_mpu6050_deselect_bypass(struct i2c_adapter *adap, 88 void *mux_priv, u32 chan_id) 89 { 90 struct i2c_client *client = mux_priv; 91 struct iio_dev *indio_dev = dev_get_drvdata(&client->dev); 92 struct inv_mpu6050_state *st = iio_priv(indio_dev); 93 94 mutex_lock(&indio_dev->mlock); 95 /* It doesn't really mattter, if any of the calls fails */ 96 inv_mpu6050_write_reg_unlocked(client, st->reg->int_pin_cfg, 97 INV_MPU6050_INT_PIN_CFG); 98 st->powerup_count--; 99 if (!st->powerup_count) 100 inv_mpu6050_write_reg_unlocked(client, st->reg->pwr_mgmt_1, 101 INV_MPU6050_BIT_SLEEP); 102 mutex_unlock(&indio_dev->mlock); 103 104 return 0; 105 } 106 107 /** 108 * inv_mpu_probe() - probe function. 109 * @client: i2c client. 110 * @id: i2c device id. 111 * 112 * Returns 0 on success, a negative error code otherwise. 113 */ 114 static int inv_mpu_probe(struct i2c_client *client, 115 const struct i2c_device_id *id) 116 { 117 struct inv_mpu6050_state *st; 118 int result; 119 const char *name = id ? id->name : NULL; 120 struct regmap *regmap; 121 122 if (!i2c_check_functionality(client->adapter, 123 I2C_FUNC_SMBUS_I2C_BLOCK)) 124 return -EOPNOTSUPP; 125 126 regmap = devm_regmap_init_i2c(client, &inv_mpu_regmap_config); 127 if (IS_ERR(regmap)) { 128 dev_err(&client->dev, "Failed to register i2c regmap %d\n", 129 (int)PTR_ERR(regmap)); 130 return PTR_ERR(regmap); 131 } 132 133 result = inv_mpu_core_probe(regmap, client->irq, name, 134 NULL, id->driver_data); 135 if (result < 0) 136 return result; 137 138 st = iio_priv(dev_get_drvdata(&client->dev)); 139 st->mux_adapter = i2c_add_mux_adapter(client->adapter, 140 &client->dev, 141 client, 142 0, 0, 0, 143 inv_mpu6050_select_bypass, 144 inv_mpu6050_deselect_bypass); 145 if (!st->mux_adapter) { 146 result = -ENODEV; 147 goto out_unreg_device; 148 } 149 150 result = inv_mpu_acpi_create_mux_client(client); 151 if (result) 152 goto out_del_mux; 153 154 return 0; 155 156 out_del_mux: 157 i2c_del_mux_adapter(st->mux_adapter); 158 out_unreg_device: 159 inv_mpu_core_remove(&client->dev); 160 return result; 161 } 162 163 static int inv_mpu_remove(struct i2c_client *client) 164 { 165 struct iio_dev *indio_dev = i2c_get_clientdata(client); 166 struct inv_mpu6050_state *st = iio_priv(indio_dev); 167 168 inv_mpu_acpi_delete_mux_client(client); 169 i2c_del_mux_adapter(st->mux_adapter); 170 171 return inv_mpu_core_remove(&client->dev); 172 } 173 174 /* 175 * device id table is used to identify what device can be 176 * supported by this driver 177 */ 178 static const struct i2c_device_id inv_mpu_id[] = { 179 {"mpu6050", INV_MPU6050}, 180 {"mpu6500", INV_MPU6500}, 181 {} 182 }; 183 184 MODULE_DEVICE_TABLE(i2c, inv_mpu_id); 185 186 static const struct acpi_device_id inv_acpi_match[] = { 187 {"INVN6500", 0}, 188 { }, 189 }; 190 191 MODULE_DEVICE_TABLE(acpi, inv_acpi_match); 192 193 static struct i2c_driver inv_mpu_driver = { 194 .probe = inv_mpu_probe, 195 .remove = inv_mpu_remove, 196 .id_table = inv_mpu_id, 197 .driver = { 198 .acpi_match_table = ACPI_PTR(inv_acpi_match), 199 .name = "inv-mpu6050-i2c", 200 .pm = &inv_mpu_pmops, 201 }, 202 }; 203 204 module_i2c_driver(inv_mpu_driver); 205 206 MODULE_AUTHOR("Invensense Corporation"); 207 MODULE_DESCRIPTION("Invensense device MPU6050 driver"); 208 MODULE_LICENSE("GPL"); 209