Merge tag 'gpio-v4.20-3' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio

+3 -9

drivers/gpio/gpio-max7301.c

··· 25 25 struct spi_device *spi = to_spi_device(dev); 26 26 u16 word = ((reg & 0x7F) << 8) | (val & 0xFF); 27 27 28 - return spi_write(spi, (const u8 *)&word, sizeof(word)); 28 + return spi_write_then_read(spi, &word, sizeof(word), NULL, 0); 29 29 } 30 30 31 31 /* A read from the MAX7301 means two transfers; here, one message each */ ··· 37 37 struct spi_device *spi = to_spi_device(dev); 38 38 39 39 word = 0x8000 | (reg << 8); 40 - ret = spi_write(spi, (const u8 *)&word, sizeof(word)); 41 - if (ret) 42 - return ret; 43 - /* 44 - * This relies on the fact, that a transfer with NULL tx_buf shifts out 45 - * zero bytes (=NOOP for MAX7301) 46 - */ 47 - ret = spi_read(spi, (u8 *)&word, sizeof(word)); 40 + ret = spi_write_then_read(spi, &word, sizeof(word), &word, 41 + sizeof(word)); 48 42 if (ret) 49 43 return ret; 50 44 return word & 0xff;

+3 -3

drivers/gpio/gpio-mvebu.c

··· 773 773 "marvell,armada-370-gpio")) 774 774 return 0; 775 775 776 - if (IS_ERR(mvchip->clk)) 777 - return PTR_ERR(mvchip->clk); 778 - 779 776 /* 780 777 * There are only two sets of PWM configuration registers for 781 778 * all the GPIO lines on those SoCs which this driver reserves ··· 782 785 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pwm"); 783 786 if (!res) 784 787 return 0; 788 + 789 + if (IS_ERR(mvchip->clk)) 790 + return PTR_ERR(mvchip->clk); 785 791 786 792 /* 787 793 * Use set A for lines of GPIO chip with id 0, B for GPIO chip

+5 -59

drivers/gpio/gpio-omap.c

··· 32 32 #define OMAP4_GPIO_DEBOUNCINGTIME_MASK 0xFF 33 33 34 34 #define OMAP_GPIO_QUIRK_IDLE_REMOVE_TRIGGER BIT(2) 35 - #define OMAP_GPIO_QUIRK_DEFERRED_WKUP_EN BIT(1) 36 35 37 36 struct gpio_regs { 38 37 u32 irqenable1; ··· 378 379 readl_relaxed(bank->base + bank->regs->fallingdetect); 379 380 380 381 if (likely(!(bank->non_wakeup_gpios & gpio_bit))) { 381 - /* Defer wkup_en register update until we idle? */ 382 - if (bank->quirks & OMAP_GPIO_QUIRK_DEFERRED_WKUP_EN) { 383 - if (trigger) 384 - bank->context.wake_en |= gpio_bit; 385 - else 386 - bank->context.wake_en &= ~gpio_bit; 387 - } else { 388 - omap_gpio_rmw(base, bank->regs->wkup_en, gpio_bit, 389 - trigger != 0); 390 - bank->context.wake_en = 391 - readl_relaxed(bank->base + bank->regs->wkup_en); 392 - } 382 + omap_gpio_rmw(base, bank->regs->wkup_en, gpio_bit, trigger != 0); 383 + bank->context.wake_en = 384 + readl_relaxed(bank->base + bank->regs->wkup_en); 393 385 } 394 386 395 387 /* This part needs to be executed always for OMAP{34xx, 44xx} */ ··· 932 942 bank->base + bank->regs->risingdetect); 933 943 } 934 944 935 - /* 936 - * On omap4 and later SoC variants a level interrupt with wkup_en 937 - * enabled blocks the GPIO functional clock from idling until the GPIO 938 - * instance has been reset. To avoid that, we must set wkup_en only for 939 - * idle for level interrupts, and clear level registers for the duration 940 - * of idle. The level interrupts will be still there on wakeup by their 941 - * nature. 942 - */ 943 - static void __maybe_unused 944 - omap4_gpio_enable_level_quirk(struct gpio_bank *bank) 945 - { 946 - /* Update wake register for idle, edge bits might be already set */ 947 - writel_relaxed(bank->context.wake_en, 948 - bank->base + bank->regs->wkup_en); 949 - 950 - /* Clear level registers for idle */ 951 - writel_relaxed(0, bank->base + bank->regs->leveldetect0); 952 - writel_relaxed(0, bank->base + bank->regs->leveldetect1); 953 - } 954 - 955 - static void __maybe_unused 956 - omap4_gpio_disable_level_quirk(struct gpio_bank *bank) 957 - { 958 - /* Restore level registers after idle */ 959 - writel_relaxed(bank->context.leveldetect0, 960 - bank->base + bank->regs->leveldetect0); 961 - writel_relaxed(bank->context.leveldetect1, 962 - bank->base + bank->regs->leveldetect1); 963 - 964 - /* Clear saved wkup_en for level, it will be set for next idle again */ 965 - bank->context.wake_en &= ~(bank->context.leveldetect0 | 966 - bank->context.leveldetect1); 967 - 968 - /* Update wake with only edge configuration */ 969 - writel_relaxed(bank->context.wake_en, 970 - bank->base + bank->regs->wkup_en); 971 - } 972 - 973 945 /*---------------------------------------------------------------------*/ 974 946 975 947 static int omap_mpuio_suspend_noirq(struct device *dev) ··· 1364 1412 omap_set_gpio_dataout_mask_multiple; 1365 1413 } 1366 1414 1367 - if (bank->quirks & OMAP_GPIO_QUIRK_DEFERRED_WKUP_EN) { 1368 - bank->funcs.idle_enable_level_quirk = 1369 - omap4_gpio_enable_level_quirk; 1370 - bank->funcs.idle_disable_level_quirk = 1371 - omap4_gpio_disable_level_quirk; 1372 - } else if (bank->quirks & OMAP_GPIO_QUIRK_IDLE_REMOVE_TRIGGER) { 1415 + if (bank->quirks & OMAP_GPIO_QUIRK_IDLE_REMOVE_TRIGGER) { 1373 1416 bank->funcs.idle_enable_level_quirk = 1374 1417 omap2_gpio_enable_level_quirk; 1375 1418 bank->funcs.idle_disable_level_quirk = ··· 1753 1806 .regs = &omap4_gpio_regs, 1754 1807 .bank_width = 32, 1755 1808 .dbck_flag = true, 1756 - .quirks = OMAP_GPIO_QUIRK_IDLE_REMOVE_TRIGGER | 1757 - OMAP_GPIO_QUIRK_DEFERRED_WKUP_EN, 1809 + .quirks = OMAP_GPIO_QUIRK_IDLE_REMOVE_TRIGGER, 1758 1810 }; 1759 1811 1760 1812 static const struct of_device_id omap_gpio_match[] = {

+94 -70

drivers/gpio/gpiolib-acpi.c

··· 19 19 20 20 #include "gpiolib.h" 21 21 22 + /** 23 + * struct acpi_gpio_event - ACPI GPIO event handler data 24 + * 25 + * @node: list-entry of the events list of the struct acpi_gpio_chip 26 + * @handle: handle of ACPI method to execute when the IRQ triggers 27 + * @handler: irq_handler to pass to request_irq when requesting the IRQ 28 + * @pin: GPIO pin number on the gpio_chip 29 + * @irq: Linux IRQ number for the event, for request_ / free_irq 30 + * @irqflags: flags to pass to request_irq when requesting the IRQ 31 + * @irq_is_wake: If the ACPI flags indicate the IRQ is a wakeup source 32 + * @is_requested: True if request_irq has been done 33 + * @desc: gpio_desc for the GPIO pin for this event 34 + */ 22 35 struct acpi_gpio_event { 23 36 struct list_head node; 24 37 acpi_handle handle; 38 + irq_handler_t handler; 25 39 unsigned int pin; 26 40 unsigned int irq; 41 + unsigned long irqflags; 42 + bool irq_is_wake; 43 + bool irq_requested; 27 44 struct gpio_desc *desc; 28 45 }; 29 46 ··· 66 49 67 50 /* 68 51 * For gpiochips which call acpi_gpiochip_request_interrupts() before late_init 69 - * (so builtin drivers) we register the ACPI GpioInt event handlers from a 52 + * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a 70 53 * late_initcall_sync handler, so that other builtin drivers can register their 71 54 * OpRegions before the event handlers can run. This list contains gpiochips 72 - * for which the acpi_gpiochip_request_interrupts() has been deferred. 55 + * for which the acpi_gpiochip_request_irqs() call has been deferred. 73 56 */ 74 57 static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock); 75 58 static LIST_HEAD(acpi_gpio_deferred_req_irqs_list); ··· 150 133 } 151 134 EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource); 152 135 153 - static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares, 154 - void *context) 136 + static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio, 137 + struct acpi_gpio_event *event) 138 + { 139 + int ret, value; 140 + 141 + ret = request_threaded_irq(event->irq, NULL, event->handler, 142 + event->irqflags, "ACPI:Event", event); 143 + if (ret) { 144 + dev_err(acpi_gpio->chip->parent, 145 + "Failed to setup interrupt handler for %d\n", 146 + event->irq); 147 + return; 148 + } 149 + 150 + if (event->irq_is_wake) 151 + enable_irq_wake(event->irq); 152 + 153 + event->irq_requested = true; 154 + 155 + /* Make sure we trigger the initial state of edge-triggered IRQs */ 156 + value = gpiod_get_raw_value_cansleep(event->desc); 157 + if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) || 158 + ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0)) 159 + event->handler(event->irq, event); 160 + } 161 + 162 + static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio) 163 + { 164 + struct acpi_gpio_event *event; 165 + 166 + list_for_each_entry(event, &acpi_gpio->events, node) 167 + acpi_gpiochip_request_irq(acpi_gpio, event); 168 + } 169 + 170 + static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, 171 + void *context) 155 172 { 156 173 struct acpi_gpio_chip *acpi_gpio = context; 157 174 struct gpio_chip *chip = acpi_gpio->chip; ··· 194 143 struct acpi_gpio_event *event; 195 144 irq_handler_t handler = NULL; 196 145 struct gpio_desc *desc; 197 - unsigned long irqflags; 198 - int ret, pin, irq, value; 146 + int ret, pin, irq; 199 147 200 148 if (!acpi_gpio_get_irq_resource(ares, &agpio)) 201 149 return AE_OK; ··· 225 175 226 176 gpiod_direction_input(desc); 227 177 228 - value = gpiod_get_value_cansleep(desc); 229 - 230 178 ret = gpiochip_lock_as_irq(chip, pin); 231 179 if (ret) { 232 180 dev_err(chip->parent, "Failed to lock GPIO as interrupt\n"); ··· 237 189 goto fail_unlock_irq; 238 190 } 239 191 240 - irqflags = IRQF_ONESHOT; 241 - if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { 242 - if (agpio->polarity == ACPI_ACTIVE_HIGH) 243 - irqflags |= IRQF_TRIGGER_HIGH; 244 - else 245 - irqflags |= IRQF_TRIGGER_LOW; 246 - } else { 247 - switch (agpio->polarity) { 248 - case ACPI_ACTIVE_HIGH: 249 - irqflags |= IRQF_TRIGGER_RISING; 250 - break; 251 - case ACPI_ACTIVE_LOW: 252 - irqflags |= IRQF_TRIGGER_FALLING; 253 - break; 254 - default: 255 - irqflags |= IRQF_TRIGGER_RISING | 256 - IRQF_TRIGGER_FALLING; 257 - break; 258 - } 259 - } 260 - 261 192 event = kzalloc(sizeof(*event), GFP_KERNEL); 262 193 if (!event) 263 194 goto fail_unlock_irq; 264 195 196 + event->irqflags = IRQF_ONESHOT; 197 + if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { 198 + if (agpio->polarity == ACPI_ACTIVE_HIGH) 199 + event->irqflags |= IRQF_TRIGGER_HIGH; 200 + else 201 + event->irqflags |= IRQF_TRIGGER_LOW; 202 + } else { 203 + switch (agpio->polarity) { 204 + case ACPI_ACTIVE_HIGH: 205 + event->irqflags |= IRQF_TRIGGER_RISING; 206 + break; 207 + case ACPI_ACTIVE_LOW: 208 + event->irqflags |= IRQF_TRIGGER_FALLING; 209 + break; 210 + default: 211 + event->irqflags |= IRQF_TRIGGER_RISING | 212 + IRQF_TRIGGER_FALLING; 213 + break; 214 + } 215 + } 216 + 265 217 event->handle = evt_handle; 218 + event->handler = handler; 266 219 event->irq = irq; 220 + event->irq_is_wake = agpio->wake_capable == ACPI_WAKE_CAPABLE; 267 221 event->pin = pin; 268 222 event->desc = desc; 269 223 270 - ret = request_threaded_irq(event->irq, NULL, handler, irqflags, 271 - "ACPI:Event", event); 272 - if (ret) { 273 - dev_err(chip->parent, 274 - "Failed to setup interrupt handler for %d\n", 275 - event->irq); 276 - goto fail_free_event; 277 - } 278 - 279 - if (agpio->wake_capable == ACPI_WAKE_CAPABLE) 280 - enable_irq_wake(irq); 281 - 282 224 list_add_tail(&event->node, &acpi_gpio->events); 283 - 284 - /* 285 - * Make sure we trigger the initial state of the IRQ when using RISING 286 - * or FALLING. Note we run the handlers on late_init, the AML code 287 - * may refer to OperationRegions from other (builtin) drivers which 288 - * may be probed after us. 289 - */ 290 - if (((irqflags & IRQF_TRIGGER_RISING) && value == 1) || 291 - ((irqflags & IRQF_TRIGGER_FALLING) && value == 0)) 292 - handler(event->irq, event); 293 225 294 226 return AE_OK; 295 227 296 - fail_free_event: 297 - kfree(event); 298 228 fail_unlock_irq: 299 229 gpiochip_unlock_as_irq(chip, pin); 300 230 fail_free_desc: ··· 309 283 if (ACPI_FAILURE(status)) 310 284 return; 311 285 286 + acpi_walk_resources(handle, "_AEI", 287 + acpi_gpiochip_alloc_event, acpi_gpio); 288 + 312 289 mutex_lock(&acpi_gpio_deferred_req_irqs_lock); 313 290 defer = !acpi_gpio_deferred_req_irqs_done; 314 291 if (defer) ··· 322 293 if (defer) 323 294 return; 324 295 325 - acpi_walk_resources(handle, "_AEI", 326 - acpi_gpiochip_request_interrupt, acpi_gpio); 296 + acpi_gpiochip_request_irqs(acpi_gpio); 327 297 } 328 298 EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts); 329 299 ··· 359 331 list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) { 360 332 struct gpio_desc *desc; 361 333 362 - if (irqd_is_wakeup_set(irq_get_irq_data(event->irq))) 363 - disable_irq_wake(event->irq); 334 + if (event->irq_requested) { 335 + if (event->irq_is_wake) 336 + disable_irq_wake(event->irq); 364 337 365 - free_irq(event->irq, event); 338 + free_irq(event->irq, event); 339 + } 340 + 366 341 desc = event->desc; 367 342 if (WARN_ON(IS_ERR(desc))) 368 343 continue; ··· 1231 1200 return con_id == NULL; 1232 1201 } 1233 1202 1234 - /* Run deferred acpi_gpiochip_request_interrupts() */ 1235 - static int acpi_gpio_handle_deferred_request_interrupts(void) 1203 + /* Run deferred acpi_gpiochip_request_irqs() */ 1204 + static int acpi_gpio_handle_deferred_request_irqs(void) 1236 1205 { 1237 1206 struct acpi_gpio_chip *acpi_gpio, *tmp; 1238 1207 1239 1208 mutex_lock(&acpi_gpio_deferred_req_irqs_lock); 1240 1209 list_for_each_entry_safe(acpi_gpio, tmp, 1241 1210 &acpi_gpio_deferred_req_irqs_list, 1242 - deferred_req_irqs_list_entry) { 1243 - acpi_handle handle; 1244 - 1245 - handle = ACPI_HANDLE(acpi_gpio->chip->parent); 1246 - acpi_walk_resources(handle, "_AEI", 1247 - acpi_gpiochip_request_interrupt, acpi_gpio); 1248 - 1249 - list_del_init(&acpi_gpio->deferred_req_irqs_list_entry); 1250 - } 1211 + deferred_req_irqs_list_entry) 1212 + acpi_gpiochip_request_irqs(acpi_gpio); 1251 1213 1252 1214 acpi_gpio_deferred_req_irqs_done = true; 1253 1215 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); ··· 1248 1224 return 0; 1249 1225 } 1250 1226 /* We must use _sync so that this runs after the first deferred_probe run */ 1251 - late_initcall_sync(acpi_gpio_handle_deferred_request_interrupts); 1227 + late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);

Configure Feed

Configure Feed