Migrate demux driver from kernel 3.18 to 4.4

 * Copyright (c) 2000 Nokia Research Center

 *                    Tampere, FINLAND

 *

 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.

 *

 * 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

 * Common definitions

 */

#define DMX_EVENT_QUEUE_SIZE 500 /* number of events */

/*

 * DMX_MAX_FILTER_SIZE: Maximum length (in bytes) of a section/PES filter.

 */

#define DMX_MAX_SECFEED_SIZE (DMX_MAX_SECTION_SIZE + 188)

#endif

/*

 * enum dmx_success: Success codes for the Demux Callback API.

 */

enum dmx_success {

	DMX_OK = 0, /* Received Ok */

	DMX_OK_PES_END, /* Received OK, data reached end of PES packet */

	DMX_OK_PCR, /* Received OK, data with new PCR/STC pair */

	DMX_OK_EOS, /* Received OK, reached End-of-Stream (EOS) */

	DMX_OK_MARKER, /* Received OK, reached a data Marker */

	DMX_LENGTH_ERROR, /* Incorrect length */

	DMX_OVERRUN_ERROR, /* Receiver ring buffer overrun */

	DMX_CRC_ERROR, /* Incorrect CRC */

	DMX_FRAME_ERROR, /* Frame alignment error */

	DMX_FIFO_ERROR, /* Receiver FIFO overrun */

	DMX_MISSED_ERROR, /* Receiver missed packet */

	DMX_OK_DECODER_BUF, /* Received OK, new ES data in decoder buffer */

	DMX_OK_IDX, /* Received OK, new index event */

	DMX_OK_SCRAMBLING_STATUS, /* Received OK, new scrambling status */

};

/*

 * struct dmx_data_ready: Parameters for event notification callback.

 * Event notification notifies demux device that data is written

 * and available in the device's output buffer or provides

 * notification on errors and other events. In the latter case

 * data_length is zero.

 */

struct dmx_data_ready {

	enum dmx_success status;

	/*

	 * data_length may be 0 in case of DMX_OK_PES_END or DMX_OK_EOS

	 * and in non-DMX_OK_XXX events. In DMX_OK_PES_END,

	 * data_length is for data coming after the end of PES.

	 */

	int data_length;

	union {

		struct {

			int start_gap;

			int actual_length;

			int disc_indicator_set;

			int pes_length_mismatch;

			u64 stc;

			u32 tei_counter;

			u32 cont_err_counter;

			u32 ts_packets_num;

		} pes_end;

		struct {

			u64 pcr;

			u64 stc;

			int disc_indicator_set;

		} pcr;

		struct {

			int handle;

			int cookie;

			u32 offset;

			u32 len;

			int pts_exists;

			u64 pts;

			int dts_exists;

			u64 dts;

			u32 tei_counter;

			u32 cont_err_counter;

			u32 ts_packets_num;

			u32 ts_dropped_bytes;

			u64 stc;

		} buf;

		struct {

			u64 id;

		} marker;

		struct dmx_index_event_info idx_event;

		struct dmx_scrambling_status_event_info scrambling_bits;

	};

};

/*

 * struct data_buffer: Parameters of buffer allocated by

 * demux device for input/output. Can be used to directly map the

 * demux-device buffer to HW output if HW supports it.

 */

struct data_buffer {

	/* dvb_ringbuffer managed by demux-device */

	const struct dvb_ringbuffer *ringbuff;

	/*

	 * Private handle returned by kernel demux when

	 * map_buffer is called in case external buffer

	 * is used. NULL if buffer is allocated internally.

	 */

	void *priv_handle;

};

/*

 * TS packet reception

 */

 * Using this API, the client can set the filtering properties to start/stop

 * filtering TS packets on a particular TS feed.

 */

struct dmx_ts_feed;

typedef int (*dmx_ts_data_ready_cb)(

		struct dmx_ts_feed *source,

		struct dmx_data_ready *dmx_data_ready);

struct dmx_ts_feed {

	int is_filtering;

	struct dmx_demux *parent;

	struct data_buffer buffer;

	void *priv;

	struct dmx_decoder_buffers *decoder_buffers;

	int (*set)(struct dmx_ts_feed *feed,

		   u16 pid,

		   int type,

		   struct timespec timeout);

	int (*start_filtering)(struct dmx_ts_feed *feed);

	int (*stop_filtering)(struct dmx_ts_feed *feed);

	int (*set_video_codec)(struct dmx_ts_feed *feed,

				enum dmx_video_codec video_codec);

	int (*set_idx_params)(struct dmx_ts_feed *feed,

				struct dmx_indexing_params *idx_params);

	int (*get_decoder_buff_status)(

			struct dmx_ts_feed *feed,

			struct dmx_buffer_status *dmx_buffer_status);

	int (*reuse_decoder_buffer)(

			struct dmx_ts_feed *feed,

			int cookie);

	int (*data_ready_cb)(struct dmx_ts_feed *feed,

			dmx_ts_data_ready_cb callback);

	int (*notify_data_read)(struct dmx_ts_feed *feed,

			u32 bytes_num);

	int (*set_tsp_out_format)(struct dmx_ts_feed *feed,

				enum dmx_tsp_format_t tsp_format);

	int (*set_secure_mode)(struct dmx_ts_feed *feed,

				struct dmx_secure_mode *sec_mode);

	int (*set_cipher_ops)(struct dmx_ts_feed *feed,

				struct dmx_cipher_operations *cipher_ops);

	int (*oob_command)(struct dmx_ts_feed *feed,

			struct dmx_oob_command *cmd);

	int (*ts_insertion_init)(struct dmx_ts_feed *feed);

	int (*ts_insertion_terminate)(struct dmx_ts_feed *feed);

	int (*ts_insertion_insert_buffer)(struct dmx_ts_feed *feed,

			char *data, size_t size);

	int (*get_scrambling_bits)(struct dmx_ts_feed *feed, u8 *value);

	int (*flush_buffer)(struct dmx_ts_feed *feed, size_t length);

};

/*

 * corresponding bits are compared. The filter only accepts sections that are

 * equal to filter_value in all the tested bit positions.

 */

struct dmx_section_feed;

struct dmx_section_filter {

	u8 filter_value[DMX_MAX_FILTER_SIZE];

	u8 filter_mask[DMX_MAX_FILTER_SIZE];

	u8 filter_mode[DMX_MAX_FILTER_SIZE];

	struct dmx_section_feed *parent; /* Back-pointer */

	struct data_buffer buffer;

	void *priv; /* Pointer to private data of the API client */

};

typedef int (*dmx_section_data_ready_cb)(

		struct dmx_section_filter *source,

		struct dmx_data_ready *dmx_data_ready);

/**

 * struct dmx_section_feed - Structure that contains a section feed filter

 *

			      struct dmx_section_filter *filter);

	int (*start_filtering)(struct dmx_section_feed *feed);

	int (*stop_filtering)(struct dmx_section_feed *feed);

	int (*data_ready_cb)(struct dmx_section_feed *feed,

			dmx_section_data_ready_cb callback);

	int (*notify_data_read)(struct dmx_section_filter *filter,

			u32 bytes_num);

	int (*set_secure_mode)(struct dmx_section_feed *feed,

				struct dmx_secure_mode *sec_mode);

	int (*set_cipher_ops)(struct dmx_section_feed *feed,

				struct dmx_cipher_operations *cipher_ops);

	int (*oob_command)(struct dmx_section_feed *feed,

				struct dmx_oob_command *cmd);

	int (*get_scrambling_bits)(struct dmx_section_feed *feed, u8 *value);

	int (*flush_buffer)(struct dmx_section_feed *feed, size_t length);

};

/*

			 size_t buffer1_length,

			 const u8 *buffer2,

			 size_t buffer2_length,

			 struct dmx_ts_feed *source);

			 struct dmx_ts_feed *source,

			enum dmx_success success);

/**

 * typedef dmx_section_cb - DVB demux TS filter callback function prototype

			      size_t buffer1_len,

			      const u8 *buffer2,

			      size_t buffer2_len,

			      struct dmx_section_filter *source);

			      struct dmx_section_filter *source,

			enum dmx_success success);

typedef int (*dmx_ts_fullness) (

				struct dmx_ts_feed *source,

				int required_space,

				int wait);

typedef int (*dmx_section_fullness) (

				struct dmx_section_filter *source,

				int required_space,

				int wait);

/*--------------------------------------------------------------------------*/

/* DVB Front-End */

enum dmx_frontend_source {

	DMX_MEMORY_FE,

	DMX_FRONTEND_0,

	DMX_FRONTEND_1,

	DMX_FRONTEND_2,

	DMX_FRONTEND_3,

	DMX_STREAM_0,    /* external stream input, e.g. LVDS */

	DMX_STREAM_1,

	DMX_STREAM_2,

	DMX_STREAM_3

};

/**

 */

enum dmx_demux_caps {

	DMX_TS_FILTERING = 1,

	DMX_PES_FILTERING = 2,

	DMX_SECTION_FILTERING = 4,

	DMX_MEMORY_BASED_FILTERING = 8,

	DMX_CRC_CHECKING = 16,

	DMX_TS_DESCRAMBLING = 32

};

/*

	enum dmx_demux_caps capabilities;

	struct dmx_frontend *frontend;

	void *priv;

	struct data_buffer dvr_input; /* DVR input buffer */

	int dvr_input_protected;

	struct dentry *debugfs_demux_dir; /* debugfs dir */

	int (*open)(struct dmx_demux *demux);

	int (*close)(struct dmx_demux *demux);

	int (*write)(struct dmx_demux *demux, const char __user *buf,

	int (*get_pes_pids)(struct dmx_demux *demux, u16 *pids);

	/* private: Not used upstream and never documented */

#if 0

	int (*get_caps)(struct dmx_demux *demux, struct dmx_caps *caps);

	int (*set_source)(struct dmx_demux *demux, const dmx_source_t *src);

#endif

	/*

	 * private: Only used at av7110, to read some data from firmware.

	 *	As this was never documented, we have no clue about what's

	 *	there, and its usage on other drivers aren't encouraged.

	 */

	int (*set_tsp_format)(struct dmx_demux *demux,

				enum dmx_tsp_format_t tsp_format);

	int (*set_playback_mode)(struct dmx_demux *demux,

				 enum dmx_playback_mode_t mode,

				 dmx_ts_fullness ts_fullness_callback,

				 dmx_section_fullness sec_fullness_callback);

	int (*write_cancel)(struct dmx_demux *demux);

	int (*get_stc)(struct dmx_demux *demux, unsigned int num,

		       u64 *stc, unsigned int *base);

	int (*map_buffer)(struct dmx_demux *demux,

			struct dmx_buffer *dmx_buffer,

			void **priv_handle, void **mem);

	int (*unmap_buffer)(struct dmx_demux *demux,

			void *priv_handle);

	int (*get_tsp_size)(struct dmx_demux *demux);

};

#endif /* #ifndef __DEMUX_H */

#include <linux/string.h>

#include <linux/mutex.h>

#include <linux/slab.h>

#include <linux/kthread.h>

#include <linux/dvb/dmx.h>

#include "dvbdev.h"

struct dmxdev_feed {

	u16 pid;

	struct dmx_indexing_params idx_params;

	struct dmx_cipher_operations cipher_ops;

	struct dmx_ts_feed *ts;

	struct list_head next;

};

struct dmxdev_sec_feed {

	struct dmx_section_feed *feed;

	struct dmx_cipher_operations cipher_ops;

};

struct dmxdev_events_queue {

	/*

	 * indices used to manage events queue.

	 * read_index advanced when relevant data is read

	 * from the buffer.

	 * notified_index is the index from which next events

	 * are returned.

	 * read_index <= notified_index <= write_index

	 *

	 * If user reads the data without getting the respective

	 * event first, the read/notified indices are updated

	 * automatically to reflect the actual data that exist

	 * in the buffer.

	 */

	u32 read_index;

	u32 write_index;

	u32 notified_index;

	/* Bytes read by user without having respective event in the queue */

	u32 bytes_read_no_event;

	/* internal tracking of PES and recording events */

	u32 current_event_data_size;

	u32 current_event_start_offset;

	/* current setting of the events masking */

	struct dmx_events_mask event_mask;

	/*

	 * indicates if an event used for data-reading from demux

	 * filter is enabled or not. These are events on which

	 * user may wait for before calling read() on the demux filter.

	 */

	int data_read_event_masked;

	/*

	 * holds the current number of pending events in the

	 * events queue that are considered as a wake-up source

	 */

	u32 wakeup_events_counter;

	struct dmx_filter_event queue[DMX_EVENT_QUEUE_SIZE];

};

#define DMX_MIN_INSERTION_REPETITION_TIME	25 /* in msec */

struct ts_insertion_buffer {

	/* work scheduled for insertion of this buffer */

	struct delayed_work dwork;

	struct list_head next;

	/* buffer holding TS packets for insertion */

	char *buffer;

	/* buffer size */

	size_t size;

	/* buffer ID from user */

	u32 identifier;

	/* repetition time for the buffer insertion */

	u32 repetition_time;

	/* the recording filter to which this buffer belongs */

	struct dmxdev_filter *dmxdevfilter;

	/* indication whether insertion should be aborted */

	int abort;

};

struct dmxdev_filter {

	union {

		struct dmx_section_filter *sec;

	union {

		/* list of TS and PES feeds (struct dmxdev_feed) */

		struct list_head ts;

		struct dmx_section_feed *sec;

		struct dmxdev_sec_feed sec;

	} feed;

	union {

		struct dmx_pes_filter_params pes;

	} params;

	struct dmxdev_events_queue events;

	enum dmxdev_type type;

	enum dmxdev_state state;

	struct dmxdev *dev;

	struct dvb_ringbuffer buffer;

	void *priv_buff_handle;

	enum dmx_buffer_mode buffer_mode;

	struct mutex mutex;

	/* for recording output */

	enum dmx_tsp_format_t dmx_tsp_format;

	u32 rec_chunk_size;

	/* list of buffers used for insertion (struct ts_insertion_buffer) */

	struct list_head insertion_buffers;

	/* End-of-stream indication has been received */

	int eos_state;

	/* only for sections */

	struct timer_list timer;

	int todo;

	u8 secheader[3];

};

	struct dmx_secure_mode sec_mode;

	/* Decoder buffer(s) related */

	struct dmx_decoder_buffers decoder_buffers;

};

struct dmxdev {

	struct dvb_device *dvbdev;

	int filternum;

	int capabilities;

#define DMXDEV_CAP_DUPLEX	0x01

	enum dmx_playback_mode_t playback_mode;

	dmx_source_t source;

	unsigned int exit:1;

#define DMXDEV_CAP_DUPLEX 1

	unsigned int dvr_in_exit:1;

	unsigned int dvr_processing_input:1;

	struct dmx_frontend *dvr_orig_fe;

	struct dvb_ringbuffer dvr_buffer;

	void *dvr_priv_buff_handle;

	enum dmx_buffer_mode dvr_buffer_mode;

	struct dmxdev_events_queue dvr_output_events;

	struct dmxdev_filter *dvr_feed;

	int dvr_feeds_count;

	struct dvb_ringbuffer dvr_input_buffer;

	enum dmx_buffer_mode dvr_input_buffer_mode;

	struct task_struct *dvr_input_thread;

	/* DVR commands (data feed / OOB command) queue */

	struct dvb_ringbuffer dvr_cmd_buffer;

#define DVR_BUFFER_SIZE (10*188*1024)

	struct mutex mutex;

	spinlock_t lock;

	spinlock_t dvr_in_lock;

};

enum dvr_cmd {

	DVR_DATA_FEED_CMD,

	DVR_OOB_CMD

};

struct dvr_command {

	enum dvr_cmd type;

	union {

		struct dmx_oob_command oobcmd;

		size_t data_feed_count;

	} cmd;

};

#define DVR_CMDS_BUFFER_SIZE (sizeof(struct dvr_command)*500)

int dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *);

void dvb_dmxdev_release(struct dmxdev *dmxdev);

#include <linux/timer.h>

#include <linux/spinlock.h>

#include <linux/mutex.h>

#include <linux/debugfs.h>

#include "demux.h"

#define MAX_PID 0x1fff

#define TIMESTAMP_LEN	4

#define SPEED_PKTS_INTERVAL 50000

struct dvb_demux_filter {

#define DMX_FEED_ENTRY(pos) list_entry(pos, struct dvb_demux_feed, list_head)

struct dmx_index_entry {

	struct dmx_index_event_info event;

	struct list_head next;

};

#define DMX_IDX_EVENT_QUEUE_SIZE	DMX_EVENT_QUEUE_SIZE

struct dvb_demux_rec_info {

	/* Reference counter for number of feeds using this information */

	int ref_count;

	/* Counter for number of TS packets output to recording buffer */

	u64 ts_output_count;

	/* Indexing information */

	struct {

		/*

		 * Minimum TS packet number encountered in recording filter

		 * among all feeds that search for video patterns

		 */

		u64 min_pattern_tsp_num;

		/* Number of indexing-enabled feeds */

		u8 indexing_feeds_num;

		/* Number of feeds with video pattern search request */

		u8 pattern_search_feeds_num;

		/* Index entries pool */

		struct dmx_index_entry events[DMX_IDX_EVENT_QUEUE_SIZE];

		/* List of free entries that can be used for new index events */

		struct list_head free_list;

		/* List holding ready index entries not notified to user yet */

		struct list_head ready_list;

	} idx_info;

};

#define DVB_DMX_MAX_PATTERN_LEN			6

struct dvb_dmx_video_patterns {

	/* the byte pattern to look for */

	u8 pattern[DVB_DMX_MAX_PATTERN_LEN];

	/* the byte mask to use (same length as pattern) */

	u8 mask[DVB_DMX_MAX_PATTERN_LEN];

	/* the length of the pattern, in bytes */

	size_t size;

	/* the type of the pattern. One of DMX_IDX_* definitions */

	u64 type;

};

#define DVB_DMX_MAX_FOUND_PATTERNS					20

#define DVB_DMX_MAX_SEARCH_PATTERN_NUM				20

struct dvb_dmx_video_prefix_size_masks {

	/*

	 * a bit mask (per pattern) of possible prefix sizes to use

	 * when searching for a pattern that started in the previous TS packet.

	 * Updated by dvb_dmx_video_pattern_search for use in the next lookup.

	 */

	u32 size_mask[DVB_DMX_MAX_FOUND_PATTERNS];

};

struct dvb_dmx_video_patterns_results {

	struct {

		/*

		 * The offset in the buffer where the pattern was found.

		 * If a pattern is found using a prefix (i.e. started on the

		 * previous buffer), offset is zero.

		 */

		u32 offset;

		/*

		 * The type of the pattern found.

		 * One of DMX_IDX_* definitions.

		 */

		u64 type;

		/* The prefix size that was used to find this pattern */

		u32 used_prefix_size;

	} info[DVB_DMX_MAX_FOUND_PATTERNS];

};

struct dvb_demux_feed {

	union {

		struct dmx_ts_feed ts;

		dmx_section_cb sec;

	} cb;

	union {

		dmx_ts_data_ready_cb ts;

		dmx_section_data_ready_cb sec;

	} data_ready_cb;

	struct dvb_demux *demux;

	void *priv;

	int type;

	u16 pid;

	u8 *buffer;

	int buffer_size;

	enum dmx_tsp_format_t tsp_out_format;

	struct dmx_secure_mode secure_mode;

	struct dmx_cipher_operations cipher_ops;

	struct timespec timeout;

	struct dvb_demux_filter *filter;

	enum dmx_ts_pes pes_type;

	int cc;

	int first_cc;

	int pusi_seen;		/* prevents feeding of garbage from previous section */

	u8 scrambling_bits;

	struct dvb_demux_rec_info *rec_info;

	u64 prev_tsp_num;

	u64 prev_stc;

	u64 curr_pusi_tsp_num;

	u64 prev_pusi_tsp_num;

	int prev_frame_valid;

	u64 prev_frame_type;

	int first_frame_in_seq;

	int first_frame_in_seq_notified;

	u64 last_pattern_tsp_num;

	int pattern_num;

const struct dvb_dmx_video_patterns *patterns[DVB_DMX_MAX_SEARCH_PATTERN_NUM];

	struct dvb_dmx_video_prefix_size_masks prefix_size;

	u16 peslen;

	u32 pes_tei_counter;

	u32 pes_cont_err_counter;

	u32 pes_ts_packets_num;

	struct list_head list_head;

	unsigned int index;	/* a unique index for each feed (can be used as hardware pid filter index) */

	enum dmx_video_codec video_codec;

	struct dmx_indexing_params idx_params;

};

struct dvb_demux {

	int (*stop_feed)(struct dvb_demux_feed *feed);

	int (*write_to_decoder)(struct dvb_demux_feed *feed,

				 const u8 *buf, size_t len);

	int (*decoder_fullness_init)(struct dvb_demux_feed *feed);

	int (*decoder_fullness_wait)(struct dvb_demux_feed *feed,

				 size_t required_space);

	int (*decoder_fullness_abort)(struct dvb_demux_feed *feed);

	int (*decoder_buffer_status)(struct dvb_demux_feed *feed,

				struct dmx_buffer_status *dmx_buffer_status);

	int (*reuse_decoder_buffer)(struct dvb_demux_feed *feed,

				int cookie);

	int (*set_cipher_op)(struct dvb_demux_feed *feed,

				struct dmx_cipher_operations *cipher_ops);

	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 (*oob_command)(struct dvb_demux_feed *feed,

		struct dmx_oob_command *cmd);

	void (*convert_ts)(struct dvb_demux_feed *feed,

			 const u8 timestamp[TIMESTAMP_LEN],

			 u64 *timestampIn27Mhz);

	int (*set_indexing)(struct dvb_demux_feed *feed);

	int (*flush_decoder_buffer)(struct dvb_demux_feed *feed, size_t length);

	int users;

#define MAX_DVB_DEMUX_USERS 10

	struct timespec speed_last_time; /* for TS speed check */

	uint32_t speed_pkts_cnt; /* for TS speed check */

	enum dmx_tsp_format_t tsp_format;

	size_t ts_packet_size;

	enum dmx_playback_mode_t playback_mode;

	int sw_filter_abort;

	struct {

		dmx_ts_fullness ts;

		dmx_section_fullness sec;

	} buffer_ctrl;

	struct dvb_demux_rec_info *rec_info_pool;

	/*

	 * the following is used for debugfs exposing info

	 * about dvb demux performance.

	 */

#define MAX_DVB_DEMUX_NAME_LEN 10

	char alias[MAX_DVB_DEMUX_NAME_LEN];

	u32 total_process_time;

	u32 total_crc_time;

};

int dvb_dmx_init(struct dvb_demux *dvbdemux);

void dvb_dmx_release(struct dvb_demux *dvbdemux);