/*
 * dvb_demux.h: DVB kernel demux API
 *
 * Copyright (C) 2000-2001 Marcus Metzler & Ralph Metzler
 *                         for convergence integrated media GmbH
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#ifndef _DVB_DEMUX_H_
#define _DVB_DEMUX_H_

#include <linux/time.h>
#include <linux/timer.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>

#include <media/demux.h>

/**
 * enum dvb_dmx_filter_type - type of demux feed.
 *
 * @DMX_TYPE_TS:        feed is in TS mode.
 * @DMX_TYPE_SEC:       feed is in Section mode.
 */
enum dvb_dmx_filter_type {
        DMX_TYPE_TS,
        DMX_TYPE_SEC,
};

/**
 * enum dvb_dmx_state - state machine for a demux filter.
 *
 * @DMX_STATE_FREE:             indicates that the filter is freed.
 * @DMX_STATE_ALLOCATED:        indicates that the filter was allocated
 *                              to be used.
 * @DMX_STATE_READY:            indicates that the filter is ready
 *                              to be used.
 * @DMX_STATE_GO:               indicates that the filter is running.
 */
enum dvb_dmx_state {
        DMX_STATE_FREE,
        DMX_STATE_ALLOCATED,
        DMX_STATE_READY,
        DMX_STATE_GO,
};

#define DVB_DEMUX_MASK_MAX 18

#define MAX_PID 0x1fff

#define SPEED_PKTS_INTERVAL 50000

/**
 * struct dvb_demux_filter - Describes a DVB demux section filter.
 *
 * @filter:             Section filter as defined by &struct dmx_section_filter.
 * @maskandmode:        logical ``and`` bit mask.
 * @maskandnotmode:     logical ``and not`` bit mask.
 * @doneq:              flag that indicates when a filter is ready.
 * @next:               pointer to the next section filter.
 * @feed:               &struct dvb_demux_feed pointer.
 * @index:              index of the used demux filter.
 * @state:              state of the filter as described by &enum dvb_dmx_state.
 * @type:               type of the filter as described
 *                      by &enum dvb_dmx_filter_type.
 */

struct dvb_demux_filter {
        struct dmx_section_filter filter;
        u8 maskandmode[DMX_MAX_FILTER_SIZE];
        u8 maskandnotmode[DMX_MAX_FILTER_SIZE];
        bool doneq;

        struct dvb_demux_filter *next;
        struct dvb_demux_feed *feed;
        int index;
        enum dvb_dmx_state state;
        enum dvb_dmx_filter_type type;

        /* private: used only by av7110 */
        u16 hw_handle;
};

/**
 * struct dvb_demux_feed - describes a DVB field
 *
 * @feed:       a union describing a digital TV feed.
 *              Depending on the feed type, it can be either
 *              @feed.ts or @feed.sec.
 * @feed.ts:    a &struct dmx_ts_feed pointer.
 *              For TS feed only.
 * @feed.sec:   a &struct dmx_section_feed pointer.
 *              For section feed only.
 * @cb:         a union describing digital TV callbacks.
 *              Depending on the feed type, it can be either
 *              @cb.ts or @cb.sec.
 * @cb.ts:      a dmx_ts_cb() calback function pointer.
 *              For TS feed only.
 * @cb.sec:     a dmx_section_cb() callback function pointer.
 *              For section feed only.
 * @demux:      pointer to &struct dvb_demux.
 * @priv:       private data that can optionally be used by a DVB driver.
 * @type:       type of the filter, as defined by &enum dvb_dmx_filter_type.
 * @state:      state of the filter as defined by &enum dvb_dmx_state.
 * @pid:        PID to be filtered.
 * @timeout:    feed timeout.
 * @filter:     pointer to &struct dvb_demux_filter.
 * @buffer_flags: Buffer flags used to report discontinuity users via DVB
 *                memory mapped API, as defined by &enum dmx_buffer_flags.
 * @ts_type:    type of TS, as defined by &enum ts_filter_type.
 * @pes_type:   type of PES, as defined by &enum dmx_ts_pes.
 * @cc:         MPEG-TS packet continuity counter
 * @pusi_seen:  if true, indicates that a discontinuity was detected.
 *              it is used to prevent feeding of garbage from previous section.
 * @peslen:     length of the PES (Packet Elementary Stream).
 * @list_head:  head for the list of digital TV demux feeds.
 * @index:      a unique index for each feed. Can be used as hardware
 *              pid filter index.
 */
struct dvb_demux_feed {
        union {
                struct dmx_ts_feed ts;
                struct dmx_section_feed sec;
        } feed;

        union {
                dmx_ts_cb ts;
                dmx_section_cb sec;
        } cb;

        struct dvb_demux *demux;
        void *priv;
        enum dvb_dmx_filter_type type;
        enum dvb_dmx_state state;
        u16 pid;

        ktime_t timeout;
        struct dvb_demux_filter *filter;

        u32 buffer_flags;

        enum ts_filter_type ts_type;
        enum dmx_ts_pes pes_type;

        int cc;
        bool pusi_seen;

        u16 peslen;

        struct list_head list_head;
        unsigned int index;
};

/**
 * struct dvb_demux - represents a digital TV demux
 * @dmx:                embedded &struct dmx_demux with demux capabilities
 *                      and callbacks.
 * @priv:               private data that can optionally be used by
 *                      a DVB driver.
 * @filternum:          maximum amount of DVB filters.
 * @feednum:            maximum amount of DVB feeds.
 * @start_feed:         callback routine to be called in order to start
 *                      a DVB feed.
 * @stop_feed:          callback routine to be called in order to stop
 *                      a DVB feed.
 * @write_to_decoder:   callback routine to be called if the feed is TS and
 *                      it is routed to an A/V decoder, when a new TS packet
 *                      is received.
 *                      Used only on av7110-av.c.
 * @check_crc32:        callback routine to check CRC. If not initialized,
 *                      dvb_demux will use an internal one.
 * @memcopy:            callback routine to memcopy received data.
 *                      If not initialized, dvb_demux will default to memcpy().
 * @users:              counter for the number of demux opened file descriptors.
 *                      Currently, it is limited to 10 users.
 * @filter:             pointer to &struct dvb_demux_filter.
 * @feed:               pointer to &struct dvb_demux_feed.
 * @frontend_list:      &struct list_head with frontends used by the demux.
 * @pesfilter:          array of &struct dvb_demux_feed with the PES types
 *                      that will be filtered.
 * @pids:               list of filtered program IDs.
 * @feed_list:          &struct list_head with feeds.
 * @tsbuf:              temporary buffer used internally to store TS packets.
 * @tsbufp:             temporary buffer index used internally.
 * @mutex:              pointer to &struct mutex used to protect feed set
 *                      logic.
 * @lock:               pointer to &spinlock_t, used to protect buffer handling.
 * @cnt_storage:        buffer used for TS/TEI continuity check.
 * @speed_last_time:    &ktime_t used for TS speed check.
 * @speed_pkts_cnt:     packets count used for TS speed check.
 */
struct dvb_demux {
        struct dmx_demux dmx;
        void *priv;
        int filternum;
        int feednum;
        int (*start_feed)(struct dvb_demux_feed *feed);
        int (*stop_feed)(struct dvb_demux_feed *feed);
        int (*write_to_decoder)(struct dvb_demux_feed *feed,
                                 const u8 *buf, size_t len);
        u32 (*check_crc32)(struct dvb_demux_feed *feed,
                            const u8 *buf, size_t len);
        void (*memcopy)(struct dvb_demux_feed *feed, u8 *dst,
                         const u8 *src, size_t len);

        int users;
#define MAX_DVB_DEMUX_USERS 10
        struct dvb_demux_filter *filter;
        struct dvb_demux_feed *feed;

        struct list_head frontend_list;

        struct dvb_demux_feed *pesfilter[DMX_PES_OTHER];
        u16 pids[DMX_PES_OTHER];

#define DMX_MAX_PID 0x2000
        struct list_head feed_list;
        u8 tsbuf[204];
        int tsbufp;

        struct mutex mutex;
        spinlock_t lock;

        uint8_t *cnt_storage; /* for TS continuity check */

        ktime_t speed_last_time; /* for TS speed check */
        uint32_t speed_pkts_cnt; /* for TS speed check */

        /* private: used only on av7110 */
        int playing;
        int recording;
};

/**
 * dvb_dmx_init - initialize a digital TV demux struct.
 *
 * @demux: &struct dvb_demux to be initialized.
 *
 * Before being able to register a digital TV demux struct, drivers
 * should call this routine. On its typical usage, some fields should
 * be initialized at the driver before calling it.
 *
 * A typical usecase is::
 *
 *      dvb->demux.dmx.capabilities =
 *              DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 *              DMX_MEMORY_BASED_FILTERING;
 *      dvb->demux.priv       = dvb;
 *      dvb->demux.filternum  = 256;
 *      dvb->demux.feednum    = 256;
 *      dvb->demux.start_feed = driver_start_feed;
 *      dvb->demux.stop_feed  = driver_stop_feed;
 *      ret = dvb_dmx_init(&dvb->demux);
 *      if (ret < 0)
 *              return ret;
 */
int dvb_dmx_init(struct dvb_demux *demux);

/**
 * dvb_dmx_release - releases a digital TV demux internal buffers.
 *
 * @demux: &struct dvb_demux to be released.
 *
 * The DVB core internally allocates data at @demux. This routine
 * releases those data. Please notice that the struct itelf is not
 * released, as it can be embedded on other structs.
 */
void dvb_dmx_release(struct dvb_demux *demux);

/**
 * dvb_dmx_swfilter_packets - use dvb software filter for a buffer with
 *      multiple MPEG-TS packets with 188 bytes each.
 *
 * @demux: pointer to &struct dvb_demux
 * @buf: buffer with data to be filtered
 * @count: number of MPEG-TS packets with size of 188.
 *
 * The routine will discard a DVB packet that don't start with 0x47.
 *
 * Use this routine if the DVB demux fills MPEG-TS buffers that are
 * already aligned.
 *
 * NOTE: The @buf size should have size equal to ``count * 188``.
 */
void dvb_dmx_swfilter_packets(struct dvb_demux *demux, const u8 *buf,
                              size_t count);

/**
 * dvb_dmx_swfilter -  use dvb software filter for a buffer with
 *      multiple MPEG-TS packets with 188 bytes each.
 *
 * @demux: pointer to &struct dvb_demux
 * @buf: buffer with data to be filtered
 * @count: number of MPEG-TS packets with size of 188.
 *
 * If a DVB packet doesn't start with 0x47, it will seek for the first
 * byte that starts with 0x47.
 *
 * Use this routine if the DVB demux fill buffers that may not start with
 * a packet start mark (0x47).
 *
 * NOTE: The @buf size should have size equal to ``count * 188``.
 */
void dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, size_t count);

/**
 * dvb_dmx_swfilter_204 -  use dvb software filter for a buffer with
 *      multiple MPEG-TS packets with 204 bytes each.
 *
 * @demux: pointer to &struct dvb_demux
 * @buf: buffer with data to be filtered
 * @count: number of MPEG-TS packets with size of 204.
 *
 * If a DVB packet doesn't start with 0x47, it will seek for the first
 * byte that starts with 0x47.
 *
 * Use this routine if the DVB demux fill buffers that may not start with
 * a packet start mark (0x47).
 *
 * NOTE: The @buf size should have size equal to ``count * 204``.
 */
void dvb_dmx_swfilter_204(struct dvb_demux *demux, const u8 *buf,
                          size_t count);

/**
 * dvb_dmx_swfilter_raw -  make the raw data available to userspace without
 *      filtering
 *
 * @demux: pointer to &struct dvb_demux
 * @buf: buffer with data
 * @count: number of packets to be passed. The actual size of each packet
 *      depends on the &dvb_demux->feed->cb.ts logic.
 *
 * Use it if the driver needs to deliver the raw payload to userspace without
 * passing through the kernel demux. That is meant to support some
 * delivery systems that aren't based on MPEG-TS.
 *
 * This function relies on &dvb_demux->feed->cb.ts to actually handle the
 * buffer.
 */
void dvb_dmx_swfilter_raw(struct dvb_demux *demux, const u8 *buf,
                          size_t count);

#endif /* _DVB_DEMUX_H_ */