1 /* 2 * GPIO driver for Exar XR17V35X chip 3 * 4 * Copyright (C) 2015 Sudip Mukherjee <sudip.mukherjee@codethink.co.uk> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/bitops.h> 11 #include <linux/device.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/init.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/pci.h> 17 #include <linux/platform_device.h> 18 19 #define EXAR_OFFSET_MPIOLVL_LO 0x90 20 #define EXAR_OFFSET_MPIOSEL_LO 0x93 21 #define EXAR_OFFSET_MPIOLVL_HI 0x96 22 #define EXAR_OFFSET_MPIOSEL_HI 0x99 23 24 #define DRIVER_NAME "gpio_exar" 25 26 static DEFINE_IDA(ida_index); 27 28 struct exar_gpio_chip { 29 struct gpio_chip gpio_chip; 30 struct mutex lock; 31 int index; 32 void __iomem *regs; 33 char name[20]; 34 }; 35 36 static void exar_update(struct gpio_chip *chip, unsigned int reg, int val, 37 unsigned int offset) 38 { 39 struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); 40 int temp; 41 42 mutex_lock(&exar_gpio->lock); 43 temp = readb(exar_gpio->regs + reg); 44 temp &= ~BIT(offset); 45 if (val) 46 temp |= BIT(offset); 47 writeb(temp, exar_gpio->regs + reg); 48 mutex_unlock(&exar_gpio->lock); 49 } 50 51 static int exar_set_direction(struct gpio_chip *chip, int direction, 52 unsigned int offset) 53 { 54 unsigned int bank = offset / 8; 55 unsigned int addr; 56 57 addr = bank ? EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO; 58 exar_update(chip, addr, direction, offset % 8); 59 return 0; 60 } 61 62 static int exar_get(struct gpio_chip *chip, unsigned int reg) 63 { 64 struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); 65 int value; 66 67 mutex_lock(&exar_gpio->lock); 68 value = readb(exar_gpio->regs + reg); 69 mutex_unlock(&exar_gpio->lock); 70 71 return value; 72 } 73 74 static int exar_get_direction(struct gpio_chip *chip, unsigned int offset) 75 { 76 unsigned int bank = offset / 8; 77 unsigned int addr; 78 int val; 79 80 addr = bank ? EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO; 81 val = exar_get(chip, addr) & BIT(offset % 8); 82 83 return !!val; 84 } 85 86 static int exar_get_value(struct gpio_chip *chip, unsigned int offset) 87 { 88 unsigned int bank = offset / 8; 89 unsigned int addr; 90 int val; 91 92 addr = bank ? EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO; 93 val = exar_get(chip, addr) & BIT(offset % 8); 94 95 return !!val; 96 } 97 98 static void exar_set_value(struct gpio_chip *chip, unsigned int offset, 99 int value) 100 { 101 unsigned int bank = offset / 8; 102 unsigned int addr; 103 104 addr = bank ? EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO; 105 exar_update(chip, addr, value, offset % 8); 106 } 107 108 static int exar_direction_output(struct gpio_chip *chip, unsigned int offset, 109 int value) 110 { 111 exar_set_value(chip, offset, value); 112 return exar_set_direction(chip, 0, offset); 113 } 114 115 static int exar_direction_input(struct gpio_chip *chip, unsigned int offset) 116 { 117 return exar_set_direction(chip, 1, offset); 118 } 119 120 static int gpio_exar_probe(struct platform_device *pdev) 121 { 122 struct pci_dev *pcidev = to_pci_dev(pdev->dev.parent); 123 struct exar_gpio_chip *exar_gpio; 124 void __iomem *p; 125 int index, ret; 126 127 if (pcidev->vendor != PCI_VENDOR_ID_EXAR) 128 return -ENODEV; 129 130 /* 131 * Map the pci device to get the register addresses. 132 * We will need to read and write those registers to control 133 * the GPIO pins. 134 * Using managed functions will save us from unmaping on exit. 135 * As the device is enabled using managed functions by the 136 * UART driver we can also use managed functions here. 137 */ 138 p = pcim_iomap(pcidev, 0, 0); 139 if (!p) 140 return -ENOMEM; 141 142 exar_gpio = devm_kzalloc(&pdev->dev, sizeof(*exar_gpio), GFP_KERNEL); 143 if (!exar_gpio) 144 return -ENOMEM; 145 146 mutex_init(&exar_gpio->lock); 147 148 index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL); 149 150 sprintf(exar_gpio->name, "exar_gpio%d", index); 151 exar_gpio->gpio_chip.label = exar_gpio->name; 152 exar_gpio->gpio_chip.parent = &pcidev->dev; 153 exar_gpio->gpio_chip.direction_output = exar_direction_output; 154 exar_gpio->gpio_chip.direction_input = exar_direction_input; 155 exar_gpio->gpio_chip.get_direction = exar_get_direction; 156 exar_gpio->gpio_chip.get = exar_get_value; 157 exar_gpio->gpio_chip.set = exar_set_value; 158 exar_gpio->gpio_chip.base = -1; 159 exar_gpio->gpio_chip.ngpio = 16; 160 exar_gpio->regs = p; 161 exar_gpio->index = index; 162 163 ret = devm_gpiochip_add_data(&pdev->dev, 164 &exar_gpio->gpio_chip, exar_gpio); 165 if (ret) 166 goto err_destroy; 167 168 platform_set_drvdata(pdev, exar_gpio); 169 170 return 0; 171 172 err_destroy: 173 ida_simple_remove(&ida_index, index); 174 mutex_destroy(&exar_gpio->lock); 175 return ret; 176 } 177 178 static int gpio_exar_remove(struct platform_device *pdev) 179 { 180 struct exar_gpio_chip *exar_gpio = platform_get_drvdata(pdev); 181 182 ida_simple_remove(&ida_index, exar_gpio->index); 183 mutex_destroy(&exar_gpio->lock); 184 185 return 0; 186 } 187 188 static struct platform_driver gpio_exar_driver = { 189 .probe = gpio_exar_probe, 190 .remove = gpio_exar_remove, 191 .driver = { 192 .name = DRIVER_NAME, 193 }, 194 }; 195 196 module_platform_driver(gpio_exar_driver); 197 198 MODULE_ALIAS("platform:" DRIVER_NAME); 199 MODULE_DESCRIPTION("Exar GPIO driver"); 200 MODULE_AUTHOR("Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>"); 201 MODULE_LICENSE("GPL"); 202