1/* SPDX-License-Identifier: GPL-2.0 */
  2
  3/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
  4 * Copyright (C) 2018-2024 Linaro Ltd.
  5 */
  6#ifndef _IPA_INTERRUPT_H_
  7#define _IPA_INTERRUPT_H_
  8
  9#include <linux/types.h>
 10
 11struct platform_device;
 12
 13struct ipa;
 14struct ipa_interrupt;
 15
 16enum ipa_irq_id;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 17
 18/**
 19 * ipa_interrupt_suspend_enable - Enable TX_SUSPEND for an endpoint
 20 * @interrupt:		IPA interrupt structure
 21 * @endpoint_id:	Endpoint whose interrupt should be enabled
 22 *
 23 * Note:  The "TX" in the name is from the perspective of the IPA hardware.
 24 * A TX_SUSPEND interrupt arrives on an AP RX enpoint when packet data can't
 25 * be delivered to the endpoint because it is suspended (or its underlying
 26 * channel is stopped).
 27 */
 28void ipa_interrupt_suspend_enable(struct ipa_interrupt *interrupt,
 29				  u32 endpoint_id);
 30
 31/**
 32 * ipa_interrupt_suspend_disable - Disable TX_SUSPEND for an endpoint
 33 * @interrupt:		IPA interrupt structure
 34 * @endpoint_id:	Endpoint whose interrupt should be disabled
 35 */
 36void ipa_interrupt_suspend_disable(struct ipa_interrupt *interrupt,
 37				   u32 endpoint_id);
 38
 39/**
 
 
 
 
 
 
 
 
 40 * ipa_interrupt_simulate_suspend() - Simulate TX_SUSPEND IPA interrupt
 41 * @interrupt:	IPA interrupt structure
 42 *
 43 * This calls the TX_SUSPEND interrupt handler, as if such an interrupt
 44 * had been signaled.  This is needed to work around a hardware quirk
 45 * that occurs if aggregation is active on an endpoint when its underlying
 46 * channel is suspended.
 47 */
 48void ipa_interrupt_simulate_suspend(struct ipa_interrupt *interrupt);
 49
 50/**
 51 * ipa_interrupt_enable() - Enable an IPA interrupt type
 52 * @ipa:	IPA pointer
 53 * @ipa_irq:	IPA interrupt ID
 54 */
 55void ipa_interrupt_enable(struct ipa *ipa, enum ipa_irq_id ipa_irq);
 56
 57/**
 58 * ipa_interrupt_disable() - Disable an IPA interrupt type
 59 * @ipa:	IPA pointer
 60 * @ipa_irq:	IPA interrupt ID
 61 */
 62void ipa_interrupt_disable(struct ipa *ipa, enum ipa_irq_id ipa_irq);
 63
 64/**
 65 * ipa_interrupt_irq_enable() - Enable IPA interrupts
 66 * @ipa:	IPA pointer
 67 *
 68 * This enables the IPA interrupt line
 69 */
 70void ipa_interrupt_irq_enable(struct ipa *ipa);
 71
 72/**
 73 * ipa_interrupt_irq_disable() - Disable IPA interrupts
 74 * @ipa:	IPA pointer
 75 *
 76 * This disables the IPA interrupt line
 77 */
 78void ipa_interrupt_irq_disable(struct ipa *ipa);
 79
 80/**
 81 * ipa_interrupt_config() - Configure IPA interrupts
 82 * @ipa:	IPA pointer
 83 *
 84 * Return:	0 if successful, or a negative error code
 85 */
 86int ipa_interrupt_config(struct ipa *ipa);
 87
 88/**
 89 * ipa_interrupt_deconfig() - Inverse of ipa_interrupt_config()
 90 * @ipa:	IPA pointer
 91 */
 92void ipa_interrupt_deconfig(struct ipa *ipa);
 93
 94/**
 95 * ipa_interrupt_init() - Initialize the IPA interrupt structure
 96 * @pdev:	IPA platform device pointer
 97 *
 98 * Return:	Pointer to an IPA interrupt structure, or a pointer-coded error
 99 */
100struct ipa_interrupt *ipa_interrupt_init(struct platform_device *pdev);
101
102/**
103 * ipa_interrupt_exit() - Inverse of ipa_interrupt_init()
104 * @interrupt:	IPA interrupt structure
105 */
106void ipa_interrupt_exit(struct ipa_interrupt *interrupt);
107
108#endif /* _IPA_INTERRUPT_H_ */

  1/* SPDX-License-Identifier: GPL-2.0 */
  2
  3/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
  4 * Copyright (C) 2018-2020 Linaro Ltd.
  5 */
  6#ifndef _IPA_INTERRUPT_H_
  7#define _IPA_INTERRUPT_H_
  8
  9#include <linux/types.h>
 10#include <linux/bits.h>
 
 11
 12struct ipa;
 13struct ipa_interrupt;
 14
 15/**
 16 * typedef ipa_irq_handler_t - IPA interrupt handler function type
 17 * @ipa:	IPA pointer
 18 * @irq_id:	interrupt type
 19 *
 20 * Callback function registered by ipa_interrupt_add() to handle a specific
 21 * IPA interrupt type
 22 */
 23typedef void (*ipa_irq_handler_t)(struct ipa *ipa, enum ipa_irq_id irq_id);
 24
 25/**
 26 * ipa_interrupt_add() - Register a handler for an IPA interrupt type
 27 * @interrupt:	IPA interrupt structure
 28 * @irq_id:	IPA interrupt type
 29 * @handler:	Handler function for the interrupt
 30 *
 31 * Add a handler for an IPA interrupt and enable it.  IPA interrupt
 32 * handlers are run in threaded interrupt context, so are allowed to
 33 * block.
 34 */
 35void ipa_interrupt_add(struct ipa_interrupt *interrupt, enum ipa_irq_id irq_id,
 36		       ipa_irq_handler_t handler);
 37
 38/**
 39 * ipa_interrupt_remove() - Remove the handler for an IPA interrupt type
 40 * @interrupt:	IPA interrupt structure
 41 * @irq_id:	IPA interrupt type
 42 *
 43 * Remove an IPA interrupt handler and disable it.
 44 */
 45void ipa_interrupt_remove(struct ipa_interrupt *interrupt,
 46			  enum ipa_irq_id irq_id);
 47
 48/**
 49 * ipa_interrupt_suspend_enable - Enable TX_SUSPEND for an endpoint
 50 * @interrupt:		IPA interrupt structure
 51 * @endpoint_id:	Endpoint whose interrupt should be enabled
 52 *
 53 * Note:  The "TX" in the name is from the perspective of the IPA hardware.
 54 * A TX_SUSPEND interrupt arrives on an AP RX enpoint when packet data can't
 55 * be delivered to the endpoint because it is suspended (or its underlying
 56 * channel is stopped).
 57 */
 58void ipa_interrupt_suspend_enable(struct ipa_interrupt *interrupt,
 59				  u32 endpoint_id);
 60
 61/**
 62 * ipa_interrupt_suspend_disable - Disable TX_SUSPEND for an endpoint
 63 * @interrupt:		IPA interrupt structure
 64 * @endpoint_id:	Endpoint whose interrupt should be disabled
 65 */
 66void ipa_interrupt_suspend_disable(struct ipa_interrupt *interrupt,
 67				   u32 endpoint_id);
 68
 69/**
 70 * ipa_interrupt_suspend_clear_all - clear all suspend interrupts
 71 * @interrupt:	IPA interrupt structure
 72 *
 73 * Clear the TX_SUSPEND interrupt for all endpoints that signaled it.
 74 */
 75void ipa_interrupt_suspend_clear_all(struct ipa_interrupt *interrupt);
 76
 77/**
 78 * ipa_interrupt_simulate_suspend() - Simulate TX_SUSPEND IPA interrupt
 79 * @interrupt:	IPA interrupt structure
 80 *
 81 * This calls the TX_SUSPEND interrupt handler, as if such an interrupt
 82 * had been signaled.  This is needed to work around a hardware quirk
 83 * that occurs if aggregation is active on an endpoint when its underlying
 84 * channel is suspended.
 85 */
 86void ipa_interrupt_simulate_suspend(struct ipa_interrupt *interrupt);
 87
 88/**
 89 * ipa_interrupt_setup() - Set up the IPA interrupt framework
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 90 * @ipa:	IPA pointer
 91 *
 92 * Return:	Pointer to IPA SMP2P info, or a pointer-coded error
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 93 */
 94struct ipa_interrupt *ipa_interrupt_setup(struct ipa *ipa);
 95
 96/**
 97 * ipa_interrupt_teardown() - Tear down the IPA interrupt framework
 98 * @interrupt:	IPA interrupt structure
 99 */
100void ipa_interrupt_teardown(struct ipa_interrupt *interrupt);
101
102#endif /* _IPA_INTERRUPT_H_ */