1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * TI/National Semiconductor LP3943 GPIO driver 4 * 5 * Copyright 2013 Texas Instruments 6 * 7 * Author: Milo Kim <milo.kim@ti.com> 8 */ 9 10 #include <linux/bitops.h> 11 #include <linux/err.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/i2c.h> 14 #include <linux/mfd/lp3943.h> 15 #include <linux/module.h> 16 #include <linux/platform_device.h> 17 #include <linux/slab.h> 18 19 enum lp3943_gpios { 20 LP3943_GPIO1, 21 LP3943_GPIO2, 22 LP3943_GPIO3, 23 LP3943_GPIO4, 24 LP3943_GPIO5, 25 LP3943_GPIO6, 26 LP3943_GPIO7, 27 LP3943_GPIO8, 28 LP3943_GPIO9, 29 LP3943_GPIO10, 30 LP3943_GPIO11, 31 LP3943_GPIO12, 32 LP3943_GPIO13, 33 LP3943_GPIO14, 34 LP3943_GPIO15, 35 LP3943_GPIO16, 36 LP3943_MAX_GPIO, 37 }; 38 39 struct lp3943_gpio { 40 struct gpio_chip chip; 41 struct lp3943 *lp3943; 42 u16 input_mask; /* 1 = GPIO is input direction, 0 = output */ 43 }; 44 45 static int lp3943_gpio_request(struct gpio_chip *chip, unsigned int offset) 46 { 47 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 48 struct lp3943 *lp3943 = lp3943_gpio->lp3943; 49 50 /* Return an error if the pin is already assigned */ 51 if (test_and_set_bit(offset, &lp3943->pin_used)) 52 return -EBUSY; 53 54 return 0; 55 } 56 57 static void lp3943_gpio_free(struct gpio_chip *chip, unsigned int offset) 58 { 59 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 60 struct lp3943 *lp3943 = lp3943_gpio->lp3943; 61 62 clear_bit(offset, &lp3943->pin_used); 63 } 64 65 static int lp3943_gpio_set_mode(struct lp3943_gpio *lp3943_gpio, u8 offset, 66 u8 val) 67 { 68 struct lp3943 *lp3943 = lp3943_gpio->lp3943; 69 const struct lp3943_reg_cfg *mux = lp3943->mux_cfg; 70 71 return lp3943_update_bits(lp3943, mux[offset].reg, mux[offset].mask, 72 val << mux[offset].shift); 73 } 74 75 static int lp3943_gpio_direction_input(struct gpio_chip *chip, unsigned int offset) 76 { 77 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 78 79 lp3943_gpio->input_mask |= BIT(offset); 80 81 return lp3943_gpio_set_mode(lp3943_gpio, offset, LP3943_GPIO_IN); 82 } 83 84 static int lp3943_get_gpio_in_status(struct lp3943_gpio *lp3943_gpio, 85 struct gpio_chip *chip, unsigned int offset) 86 { 87 u8 addr, read; 88 int err; 89 90 switch (offset) { 91 case LP3943_GPIO1 ... LP3943_GPIO8: 92 addr = LP3943_REG_GPIO_A; 93 break; 94 case LP3943_GPIO9 ... LP3943_GPIO16: 95 addr = LP3943_REG_GPIO_B; 96 offset = offset - 8; 97 break; 98 default: 99 return -EINVAL; 100 } 101 102 err = lp3943_read_byte(lp3943_gpio->lp3943, addr, &read); 103 if (err) 104 return err; 105 106 return !!(read & BIT(offset)); 107 } 108 109 static int lp3943_get_gpio_out_status(struct lp3943_gpio *lp3943_gpio, 110 struct gpio_chip *chip, unsigned int offset) 111 { 112 struct lp3943 *lp3943 = lp3943_gpio->lp3943; 113 const struct lp3943_reg_cfg *mux = lp3943->mux_cfg; 114 u8 read; 115 int err; 116 117 err = lp3943_read_byte(lp3943, mux[offset].reg, &read); 118 if (err) 119 return err; 120 121 read = (read & mux[offset].mask) >> mux[offset].shift; 122 123 if (read == LP3943_GPIO_OUT_HIGH) 124 return 1; 125 else if (read == LP3943_GPIO_OUT_LOW) 126 return 0; 127 else 128 return -EINVAL; 129 } 130 131 static int lp3943_gpio_get(struct gpio_chip *chip, unsigned int offset) 132 { 133 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 134 135 /* 136 * Limitation: 137 * LP3943 doesn't have the GPIO direction register. It provides 138 * only input and output status registers. 139 * So, direction info is required to handle the 'get' operation. 140 * This variable is updated whenever the direction is changed and 141 * it is used here. 142 */ 143 144 if (lp3943_gpio->input_mask & BIT(offset)) 145 return lp3943_get_gpio_in_status(lp3943_gpio, chip, offset); 146 else 147 return lp3943_get_gpio_out_status(lp3943_gpio, chip, offset); 148 } 149 150 static int lp3943_gpio_set(struct gpio_chip *chip, unsigned int offset, 151 int value) 152 { 153 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 154 u8 data; 155 156 if (value) 157 data = LP3943_GPIO_OUT_HIGH; 158 else 159 data = LP3943_GPIO_OUT_LOW; 160 161 return lp3943_gpio_set_mode(lp3943_gpio, offset, data); 162 } 163 164 static int lp3943_gpio_direction_output(struct gpio_chip *chip, unsigned int offset, 165 int value) 166 { 167 struct lp3943_gpio *lp3943_gpio = gpiochip_get_data(chip); 168 int ret; 169 170 ret = lp3943_gpio_set(chip, offset, value); 171 if (ret) 172 return ret; 173 174 lp3943_gpio->input_mask &= ~BIT(offset); 175 176 return 0; 177 } 178 179 static const struct gpio_chip lp3943_gpio_chip = { 180 .label = "lp3943", 181 .owner = THIS_MODULE, 182 .request = lp3943_gpio_request, 183 .free = lp3943_gpio_free, 184 .direction_input = lp3943_gpio_direction_input, 185 .get = lp3943_gpio_get, 186 .direction_output = lp3943_gpio_direction_output, 187 .set = lp3943_gpio_set, 188 .base = -1, 189 .ngpio = LP3943_MAX_GPIO, 190 .can_sleep = 1, 191 }; 192 193 static int lp3943_gpio_probe(struct platform_device *pdev) 194 { 195 struct lp3943 *lp3943 = dev_get_drvdata(pdev->dev.parent); 196 struct lp3943_gpio *lp3943_gpio; 197 198 lp3943_gpio = devm_kzalloc(&pdev->dev, sizeof(*lp3943_gpio), 199 GFP_KERNEL); 200 if (!lp3943_gpio) 201 return -ENOMEM; 202 203 lp3943_gpio->lp3943 = lp3943; 204 lp3943_gpio->chip = lp3943_gpio_chip; 205 lp3943_gpio->chip.parent = &pdev->dev; 206 207 return devm_gpiochip_add_data(&pdev->dev, &lp3943_gpio->chip, 208 lp3943_gpio); 209 } 210 211 static const struct of_device_id lp3943_gpio_of_match[] = { 212 { .compatible = "ti,lp3943-gpio", }, 213 { } 214 }; 215 MODULE_DEVICE_TABLE(of, lp3943_gpio_of_match); 216 217 static struct platform_driver lp3943_gpio_driver = { 218 .probe = lp3943_gpio_probe, 219 .driver = { 220 .name = "lp3943-gpio", 221 .of_match_table = lp3943_gpio_of_match, 222 }, 223 }; 224 module_platform_driver(lp3943_gpio_driver); 225 226 MODULE_DESCRIPTION("LP3943 GPIO driver"); 227 MODULE_ALIAS("platform:lp3943-gpio"); 228 MODULE_AUTHOR("Milo Kim"); 229 MODULE_LICENSE("GPL"); 230