/*
 * Copyright (c) 2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file
 * @brief USB device stack class instances API
 *
 * This file contains the USB device stack class instances API.
 */

#ifndef ZEPHYR_INCLUDE_USBD_CLASS_API_H
#define ZEPHYR_INCLUDE_USBD_CLASS_API_H

#include <zephyr/usb/usbd.h>

/**
 * @brief Endpoint request completion event handler
 *
 * This is the event handler for all endpoint accommodated
 * by a class instance.
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] buf Control Request Data buffer
 * @param[in] err Result of the transfer. 0 if the transfer was successful.
 */
static inline int usbd_class_request(struct usbd_class_data *const c_data,
				     struct net_buf *const buf,
				     int err)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->request != NULL) {
		return api->request(c_data, buf, err);
	}

	return -ENOTSUP;
}


/**
 * @brief USB control request handler
 *
 * Common handler for all control request.
 * Regardless requests recipient, interface or endpoint,
 * the USB device core will identify proper class instance
 * and call this handler.
 * For the vendor type request USBD_VENDOR_REQ macro must be used
 * to identify the class, if more than one class instance is
 * present, only the first one will be called.
 *
 * The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] setup Pointer to USB Setup Packet
 * @param[in] buf Control Request Data buffer
 *
 * @return 0 on success, other values on fail.
 */
static inline int usbd_class_control_to_host(struct usbd_class_data *const c_data,
					     struct usb_setup_packet *const setup,
					     struct net_buf *const buf)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->control_to_host != NULL) {
		return api->control_to_host(c_data, setup, buf);
	}

	errno = -ENOTSUP;
	return 0;
}

/**
 * @brief USB control request handler
 *
 * Common handler for all control request.
 * Regardless requests recipient, interface or endpoint,
 * the USB device core will identify proper class instance
 * and call this handler.
 * For the vendor type request USBD_VENDOR_REQ macro must be used
 * to identify the class, if more than one class instance is
 * present, only the first one will be called.
 *
 * The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] setup Pointer to USB Setup Packet
 * @param[in] buf Control Request Data buffer
 *
 * @return 0 on success, other values on fail.
 */
static inline int usbd_class_control_to_dev(struct usbd_class_data *const c_data,
					    struct usb_setup_packet *const setup,
					    struct net_buf *const buf)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->control_to_dev != NULL) {
		return api->control_to_dev(c_data, setup, buf);
	}

	errno = -ENOTSUP;
	return 0;
}

/**
 * @brief Feature endpoint halt update handler
 *
 * Called when an endpoint of the interface belonging
 * to the instance has been halted or cleared by either
 * a Set Feature Endpoint Halt or Clear Feature Endpoint Halt request.
 *
 * The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] ep Endpoint
 * @param[in] halted True if the endpoint has been halted and false if
 *                   the endpoint halt has been cleared by a Feature request.
 */
static inline void usbd_class_feature_halt(struct usbd_class_data *const c_data,
					   const uint8_t ep,
					   const bool halted)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->feature_halt != NULL) {
		api->feature_halt(c_data, ep, halted);
	}
}

/**
 * @brief Configuration update handler
 *
 * Called when the configuration of the interface belonging
 * to the instance has been changed, either because of
 * Set Configuration or Set Interface request.
 *
 * The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] iface Interface
 * @param[in] alternate Alternate setting
 */
static inline void usbd_class_update(struct usbd_class_data *const c_data,
				     const uint8_t iface,
				     const uint8_t alternate)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->update != NULL) {
		api->update(c_data, iface, alternate);
	}
}


/**
 * @brief USB suspended handler
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_suspended(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->suspended != NULL) {
		api->suspended(c_data);
	}
}


/**
 * @brief USB resumed handler
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_resumed(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->resumed != NULL) {
		api->resumed(c_data);
	}
}

/**
 * @brief USB Start of Frame handler
 *
 * @note The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_sof(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->sof != NULL) {
		api->sof(c_data);
	}
}

/**
 * @brief Class associated configuration active handler
 *
 * @note The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_enable(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->enable != NULL) {
		api->enable(c_data);
	}
}

/**
 * @brief Class associated configuration disable handler
 *
 * @note The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_disable(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->disable != NULL) {
		api->disable(c_data);
	}
}

/**
 * @brief Initialization of the class implementation
 *
 * This is called for each instance during the initialization phase
 * after the interface number and endpoint addresses are assigned
 * to the corresponding instance.
 * It can be used to initialize class specific descriptors or
 * underlying systems.
 *
 * @note If this call fails the core will terminate stack initialization.
 *
 * @param[in] c_data Pointer to USB device class data
 *
 * @return 0 on success, other values on fail.
 */
static inline int usbd_class_init(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->init != NULL) {
		return api->init(c_data);
	}

	return -ENOTSUP;
}

/**
 * @brief Shutdown of the class implementation
 *
 * This is called for each instance during the shutdown phase.
 *
 * @note The execution of the handler must not block.
 *
 * @param[in] c_data Pointer to USB device class data
 */
static inline void usbd_class_shutdown(struct usbd_class_data *const c_data)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->shutdown != NULL) {
		api->shutdown(c_data);
	}
}

/**
 * @brief Get function descriptor
 *
 * @param[in] c_data Pointer to USB device class data
 * @param[in] speed For which speed descriptor is requested.
 *
 * @return Array of struct usb_desc_header pointers with a last element
 *         pointing to a nil descriptor on success, NULL if not available.
 */
static inline void *usbd_class_get_desc(struct usbd_class_data *const c_data,
					const enum usbd_speed speed)
{
	const struct usbd_class_api *api = c_data->api;

	if (api->get_desc != NULL) {
		return api->get_desc(c_data, speed);
	}

	return NULL;
}

#endif /* ZEPHYR_INCLUDE_USBD_CLASS_API_H */