// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#pragma once

#include <zircon/compiler.h>
#include <zircon/device/ethernet.h>
#include <zircon/listnode.h>
#include <zircon/types.h>

__BEGIN_CDECLS;

#define ETH_MAC_SIZE 6

// The ethermac interface supports both synchronous and asynchronous transmissions using the
// proto->queue_tx() and ifc->complete_tx() methods.
//
// Receive operations are supported with the ifc->recv() interface.
// TODO: implement netbuf-based receive operations by implementing proto->queue_rx() and
// ifc->complete_rx()
//
// The FEATURE_WLAN flag indicates a device that supports wlan operations.
//
// The FEATURE_SYNTH flag indicates a device that is not backed by hardware.
//
// The FEATURE_DMA flag indicates that the device can copy the buffer data using DMA and will ensure
// that physical addresses are provided in netbufs.

#define ETHMAC_FEATURE_WLAN     (1u)
#define ETHMAC_FEATURE_SYNTH    (2u)
#define ETHMAC_FEATURE_DMA      (4u)

typedef struct ethmac_info {
    uint32_t features;
    uint32_t mtu;
    uint8_t mac[ETH_MAC_SIZE];
    uint8_t reserved0[2];
    uint32_t reserved1[4];
} ethmac_info_t;

typedef struct ethmac_netbuf {
    // Provided by the generic ethernet driver
    void* data;
    zx_paddr_t phys;  // Only used if ETHMAC_FEATURE_DMA is available
    uint16_t len;
    uint16_t reserved;
    uint32_t flags;

    // Shared between the generic ethernet and ethmac drivers
    list_node_t node;

    // For use by the ethmac driver
    union {
        uint64_t val;
        void* ptr;
    };
} ethmac_netbuf_t;

typedef struct ethmac_ifc_virt {
    void (*status)(void* cookie, uint32_t status);

    void (*recv)(void* cookie, void* data, size_t length, uint32_t flags);

    // complete_tx() is called to return ownership of a netbuf to the generic ethernet driver.
    void (*complete_tx)(void* cookie, ethmac_netbuf_t* netbuf, zx_status_t status);
} ethmac_ifc_t;

// Indicates that additional data is available to be sent after this call finishes. Allows a ethmac
// driver to batch tx to hardware if possible.
#define ETHMAC_TX_OPT_MORE (1u)

// SETPARAM_ values identify the parameter to set. Each call to set_param()
// takes an int32_t |value| and void* |data| which have meaning specific to
// the parameter being set.

// |value| is bool. |data| is unused.
#define ETHMAC_SETPARAM_PROMISC (1u)

// |value| is bool. |data| is unused.
#define ETHMAC_SETPARAM_MULTICAST_PROMISC (2u)

#define ETHMAC_MULTICAST_FILTER_OVERFLOW -1

// |value| is number of addresses, or ETHMAC_MULTICAST_FILTER_OVERFLOW for "too many to count."
// |data| is |value|*6 bytes of MAC addresses. Caller retains ownership.
// If |value| is _OVERFLOW, |data| is ignored.
#define ETHMAC_SETPARAM_MULTICAST_FILTER (3u)

#define ETHMAC_SETPARAM_DUMP_REGS (4u)

// The ethernet midlayer will never call ethermac_protocol
// methods from multiple threads simultaneously, but it
// can call send() methods at the same time as non-send
// methods.
typedef struct ethmac_protocol_ops {
    // Obtain information about the ethermac device and supported features
    // Safe to call at any time.
    zx_status_t (*query)(void* ctx, uint32_t options, ethmac_info_t* info);

    // Shut down a running ethermac
    // Safe to call if the ethermac is already stopped.
    void (*stop)(void* ctx);

    // Start ethermac running with ifc_virt
    // Callbacks on ifc may be invoked from now until stop() is called
    zx_status_t (*start)(void* ctx, ethmac_ifc_t* ifc, void* cookie);

    // Request transmission of the packet in netbuf. Return status indicates disposition:
    //   ZX_ERR_SHOULD_WAIT: Packet is being transmitted
    //   ZX_OK: Packet has been transmitted
    //   Other: Packet could not be transmitted
    //
    // In the SHOULD_WAIT case the driver takes ownership of the netbuf and must call complete_tx()
    // to return it once the transmission is complete. complete_tx() MUST NOT be called from within
    // the queue_tx() implementation.
    //
    // queue_tx() may be called at any time after start() is called including from multiple threads
    // simultaneously.
    zx_status_t (*queue_tx)(void* ctx, uint32_t options, ethmac_netbuf_t* netbuf);

    // Request a settings change for the driver. Return status indicates disposition:
    //   ZX_OK: Request has been handled.
    //   ZX_ERR_NOT_SUPPORTED: Driver does not support this setting.
    //   Other: Error trying to support this request.
    //
    // |value| and |data| usage are defined for each |param|; see comments above.
    //
    // set_param() may be called at any time after start() is called including from multiple threads
    // simultaneously.
    zx_status_t (*set_param)(void* ctx, uint32_t param, int32_t value, void* data);

    // Get the BTI handle (needed to pin DMA memory) for this device.
    // This method is only valid on devices that advertise ETHMAC_FEATURE_DMA
    // The caller does *not* take ownership of the BTI handle and must never close
    // the handle.
    zx_handle_t (*get_bti)(void* ctx);
} ethmac_protocol_ops_t;

typedef struct ethmac_protocol {
    ethmac_protocol_ops_t* ops;
    void* ctx;
} ethmac_protocol_t;

__END_CDECLS;