1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2020, Broadcom */ 3 4 #include <linux/init.h> 5 #include <linux/types.h> 6 #include <linux/module.h> 7 #include <linux/platform_device.h> 8 #include <linux/interrupt.h> 9 #include <linux/io.h> 10 #include <linux/device.h> 11 #include <linux/of.h> 12 #include <linux/kernel.h> 13 #include <linux/kdebug.h> 14 #include <linux/gpio/consumer.h> 15 16 struct out_pin { 17 u32 enable_mask; 18 u32 value_mask; 19 u32 changed_mask; 20 u32 clr_changed_mask; 21 struct gpio_desc *gpiod; 22 const char *name; 23 }; 24 25 struct in_pin { 26 u32 enable_mask; 27 u32 value_mask; 28 struct gpio_desc *gpiod; 29 const char *name; 30 struct brcmstb_usb_pinmap_data *pdata; 31 }; 32 33 struct brcmstb_usb_pinmap_data { 34 void __iomem *regs; 35 int in_count; 36 struct in_pin *in_pins; 37 int out_count; 38 struct out_pin *out_pins; 39 }; 40 41 42 static void pinmap_set(void __iomem *reg, u32 mask) 43 { 44 u32 val; 45 46 val = readl(reg); 47 val |= mask; 48 writel(val, reg); 49 } 50 51 static void pinmap_unset(void __iomem *reg, u32 mask) 52 { 53 u32 val; 54 55 val = readl(reg); 56 val &= ~mask; 57 writel(val, reg); 58 } 59 60 static void sync_in_pin(struct in_pin *pin) 61 { 62 u32 val; 63 64 val = gpiod_get_value(pin->gpiod); 65 if (val) 66 pinmap_set(pin->pdata->regs, pin->value_mask); 67 else 68 pinmap_unset(pin->pdata->regs, pin->value_mask); 69 } 70 71 /* 72 * Interrupt from override register, propagate from override bit 73 * to GPIO. 74 */ 75 static irqreturn_t brcmstb_usb_pinmap_ovr_isr(int irq, void *dev_id) 76 { 77 struct brcmstb_usb_pinmap_data *pdata = dev_id; 78 struct out_pin *pout; 79 u32 val; 80 u32 bit; 81 int x; 82 83 pr_debug("%s: reg: 0x%x\n", __func__, readl(pdata->regs)); 84 pout = pdata->out_pins; 85 for (x = 0; x < pdata->out_count; x++) { 86 val = readl(pdata->regs); 87 if (val & pout->changed_mask) { 88 pinmap_set(pdata->regs, pout->clr_changed_mask); 89 pinmap_unset(pdata->regs, pout->clr_changed_mask); 90 bit = val & pout->value_mask; 91 gpiod_set_value(pout->gpiod, bit ? 1 : 0); 92 pr_debug("%s: %s bit changed state to %d\n", 93 __func__, pout->name, bit ? 1 : 0); 94 } 95 } 96 return IRQ_HANDLED; 97 } 98 99 /* 100 * Interrupt from GPIO, propagate from GPIO to override bit. 101 */ 102 static irqreturn_t brcmstb_usb_pinmap_gpio_isr(int irq, void *dev_id) 103 { 104 struct in_pin *pin = dev_id; 105 106 pr_debug("%s: %s pin changed state\n", __func__, pin->name); 107 sync_in_pin(pin); 108 return IRQ_HANDLED; 109 } 110 111 112 static void get_pin_counts(struct device_node *dn, int *in_count, 113 int *out_count) 114 { 115 int in; 116 int out; 117 118 *in_count = 0; 119 *out_count = 0; 120 in = of_property_count_strings(dn, "brcm,in-functions"); 121 if (in < 0) 122 return; 123 out = of_property_count_strings(dn, "brcm,out-functions"); 124 if (out < 0) 125 return; 126 *in_count = in; 127 *out_count = out; 128 } 129 130 static int parse_pins(struct device *dev, struct device_node *dn, 131 struct brcmstb_usb_pinmap_data *pdata) 132 { 133 struct out_pin *pout; 134 struct in_pin *pin; 135 int index; 136 int res; 137 int x; 138 139 pin = pdata->in_pins; 140 for (x = 0, index = 0; x < pdata->in_count; x++) { 141 pin->gpiod = devm_gpiod_get_index(dev, "in", x, GPIOD_IN); 142 if (IS_ERR(pin->gpiod)) { 143 dev_err(dev, "Error getting gpio %s\n", pin->name); 144 return PTR_ERR(pin->gpiod); 145 146 } 147 res = of_property_read_string_index(dn, "brcm,in-functions", x, 148 &pin->name); 149 if (res < 0) { 150 dev_err(dev, "Error getting brcm,in-functions for %s\n", 151 pin->name); 152 return res; 153 } 154 res = of_property_read_u32_index(dn, "brcm,in-masks", index++, 155 &pin->enable_mask); 156 if (res < 0) { 157 dev_err(dev, "Error getting 1st brcm,in-masks for %s\n", 158 pin->name); 159 return res; 160 } 161 res = of_property_read_u32_index(dn, "brcm,in-masks", index++, 162 &pin->value_mask); 163 if (res < 0) { 164 dev_err(dev, "Error getting 2nd brcm,in-masks for %s\n", 165 pin->name); 166 return res; 167 } 168 pin->pdata = pdata; 169 pin++; 170 } 171 pout = pdata->out_pins; 172 for (x = 0, index = 0; x < pdata->out_count; x++) { 173 pout->gpiod = devm_gpiod_get_index(dev, "out", x, 174 GPIOD_OUT_HIGH); 175 if (IS_ERR(pout->gpiod)) { 176 dev_err(dev, "Error getting gpio %s\n", pin->name); 177 return PTR_ERR(pout->gpiod); 178 } 179 res = of_property_read_string_index(dn, "brcm,out-functions", x, 180 &pout->name); 181 if (res < 0) { 182 dev_err(dev, "Error getting brcm,out-functions for %s\n", 183 pout->name); 184 return res; 185 } 186 res = of_property_read_u32_index(dn, "brcm,out-masks", index++, 187 &pout->enable_mask); 188 if (res < 0) { 189 dev_err(dev, "Error getting 1st brcm,out-masks for %s\n", 190 pout->name); 191 return res; 192 } 193 res = of_property_read_u32_index(dn, "brcm,out-masks", index++, 194 &pout->value_mask); 195 if (res < 0) { 196 dev_err(dev, "Error getting 2nd brcm,out-masks for %s\n", 197 pout->name); 198 return res; 199 } 200 res = of_property_read_u32_index(dn, "brcm,out-masks", index++, 201 &pout->changed_mask); 202 if (res < 0) { 203 dev_err(dev, "Error getting 3rd brcm,out-masks for %s\n", 204 pout->name); 205 return res; 206 } 207 res = of_property_read_u32_index(dn, "brcm,out-masks", index++, 208 &pout->clr_changed_mask); 209 if (res < 0) { 210 dev_err(dev, "Error getting 4th out-masks for %s\n", 211 pout->name); 212 return res; 213 } 214 pout++; 215 } 216 return 0; 217 } 218 219 static void sync_all_pins(struct brcmstb_usb_pinmap_data *pdata) 220 { 221 struct out_pin *pout; 222 struct in_pin *pin; 223 int val; 224 int x; 225 226 /* 227 * Enable the override, clear any changed condition and 228 * propagate the state to the GPIO for all out pins. 229 */ 230 pout = pdata->out_pins; 231 for (x = 0; x < pdata->out_count; x++) { 232 pinmap_set(pdata->regs, pout->enable_mask); 233 pinmap_set(pdata->regs, pout->clr_changed_mask); 234 pinmap_unset(pdata->regs, pout->clr_changed_mask); 235 val = readl(pdata->regs) & pout->value_mask; 236 gpiod_set_value(pout->gpiod, val ? 1 : 0); 237 pout++; 238 } 239 240 /* sync and enable all in pins. */ 241 pin = pdata->in_pins; 242 for (x = 0; x < pdata->in_count; x++) { 243 sync_in_pin(pin); 244 pinmap_set(pdata->regs, pin->enable_mask); 245 pin++; 246 } 247 } 248 249 static int __init brcmstb_usb_pinmap_probe(struct platform_device *pdev) 250 { 251 struct device_node *dn = pdev->dev.of_node; 252 struct brcmstb_usb_pinmap_data *pdata; 253 struct in_pin *pin; 254 struct resource *r; 255 int out_count; 256 int in_count; 257 int err; 258 int irq; 259 int x; 260 261 get_pin_counts(dn, &in_count, &out_count); 262 if ((in_count + out_count) == 0) 263 return -EINVAL; 264 265 r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 266 if (!r) 267 return -EINVAL; 268 269 pdata = devm_kzalloc(&pdev->dev, 270 sizeof(*pdata) + 271 (sizeof(struct in_pin) * in_count) + 272 (sizeof(struct out_pin) * out_count), GFP_KERNEL); 273 if (!pdata) 274 return -ENOMEM; 275 276 pdata->in_count = in_count; 277 pdata->out_count = out_count; 278 pdata->in_pins = (struct in_pin *)(pdata + 1); 279 pdata->out_pins = (struct out_pin *)(pdata->in_pins + in_count); 280 281 pdata->regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 282 if (!pdata->regs) 283 return -ENOMEM; 284 platform_set_drvdata(pdev, pdata); 285 286 err = parse_pins(&pdev->dev, dn, pdata); 287 if (err) 288 return err; 289 290 sync_all_pins(pdata); 291 292 if (out_count) { 293 294 /* Enable interrupt for out pins */ 295 irq = platform_get_irq(pdev, 0); 296 err = devm_request_irq(&pdev->dev, irq, 297 brcmstb_usb_pinmap_ovr_isr, 298 IRQF_TRIGGER_RISING, 299 pdev->name, pdata); 300 if (err < 0) { 301 dev_err(&pdev->dev, "Error requesting IRQ\n"); 302 return err; 303 } 304 } 305 306 for (x = 0, pin = pdata->in_pins; x < pdata->in_count; x++, pin++) { 307 irq = gpiod_to_irq(pin->gpiod); 308 if (irq < 0) { 309 dev_err(&pdev->dev, "Error getting IRQ for %s pin\n", 310 pin->name); 311 return irq; 312 } 313 err = devm_request_irq(&pdev->dev, irq, 314 brcmstb_usb_pinmap_gpio_isr, 315 IRQF_SHARED | IRQF_TRIGGER_RISING | 316 IRQF_TRIGGER_FALLING, 317 pdev->name, pin); 318 if (err < 0) { 319 dev_err(&pdev->dev, "Error requesting IRQ for %s pin\n", 320 pin->name); 321 return err; 322 } 323 } 324 325 dev_dbg(&pdev->dev, "Driver probe succeeded\n"); 326 dev_dbg(&pdev->dev, "In pin count: %d, out pin count: %d\n", 327 pdata->in_count, pdata->out_count); 328 return 0; 329 } 330 331 332 static const struct of_device_id brcmstb_usb_pinmap_of_match[] = { 333 { .compatible = "brcm,usb-pinmap" }, 334 { }, 335 }; 336 337 static struct platform_driver brcmstb_usb_pinmap_driver = { 338 .driver = { 339 .name = "brcm-usb-pinmap", 340 .of_match_table = brcmstb_usb_pinmap_of_match, 341 }, 342 }; 343 344 static int __init brcmstb_usb_pinmap_init(void) 345 { 346 return platform_driver_probe(&brcmstb_usb_pinmap_driver, 347 brcmstb_usb_pinmap_probe); 348 } 349 350 module_init(brcmstb_usb_pinmap_init); 351 MODULE_AUTHOR("Al Cooper <alcooperx@gmail.com>"); 352 MODULE_DESCRIPTION("Broadcom USB Pinmap Driver"); 353 MODULE_LICENSE("GPL"); 354