sound/soc/codecs/tfa_container.h

/*
 * Copyright (C) NXP Semiconductors (PLMA)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * 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 __TFA_CONTAINER_H__
#define __TFA_CONTAINER_H__



/*
 * tfa98xx container firmware header
 */

struct nxpTfaDescPtr {
	u32 offset:24;
	u8  type; // (== enum nxpTfaDescriptorType, assure 8bits length)
};


struct nxpTfaDevice {
	u8 length;		// nr of items in the list
	u8 bus;		// bus
	u8 dev;		// device
	u8 func;		// subfunction or subdevice
	u32 devid;		// device  hw fw id
	struct nxpTfaDescPtr name;	// device name
	struct nxpTfaDescPtr list[];	// items list
} __attribute__((packed));


#define HDR(c1,c2) (c2<<8|c1) // little endian
enum tfa_cnt_header_type {
	params		= HDR('P','M'),
	volstep		= HDR('V','P'),
	patch		= HDR('P','A'),
	speaker		= HDR('S','P'),
	preset		= HDR('P','R'),
	config		= HDR('C','O'),
	equalizer	= HDR('E','Q'),
	drc		= HDR('D','R')
};

enum nxpTfaHeaderType {
    paramsHdr	= HDR('P','M'),
    volstepHdr	= HDR('V','P'),
    patchHdr	= HDR('P','A'),
    speakerHdr	= HDR('S','P'),
    presetHdr	= HDR('P','R'),
    configHdr	= HDR('C','O'),
    equalizerHdr = HDR('E','Q'),
    drcHdr	= HDR('D','R')
};


#define TFA_PM_VERSION '1'
#define TFA_PM_SUBVERSION "00"

enum nxpTfaDescriptorType {
	dscDevice,	// device list
	dscProfile,	// profile list
	dscRegister,	// register patch
	dscString,	// ascii, zero terminated string
	dscFile,	// filename + file contents
	dscPatch,	// patch file
	dscMarker,	// marker to indicate end of a list
	dscMode,	// mode support
	dscCfMem,       // coolflux memory x,y,io
	dscFilter,      // filter settings
	dscBitfieldBase=0x80 // start of bitfield enums
};

/*
 * profile descriptor list
 */
struct nxpTfaProfile {
	u8 length;			// nr of items in the list
	u32 ID:24;			// profile ID
	struct nxpTfaDescPtr name;	// profile name
	struct nxpTfaDescPtr list[];	// items list
} __attribute__((packed));
#define TFA_PROFID 0x1234


//static char nostring[]="Undefined string";

/*
 * generic file descriptor
 */
struct nxpTfaFileDsc {
	struct nxpTfaDescPtr name;
	u32 size;	// file data length in bytes
	u8 data[];	//payload
} __attribute__((packed));


struct nxpTfaContainer {
	char id[2];		// "XX" : XX=type
	char version[2];	// "V_" : V=version, vv=subversion
	char subversion[2];	// "vv" : vv=subversion
	u32 size;		// data size in bytes following CRC
	u32 CRC;		// 32-bits CRC for following data
	u16 rev;		// "extra chars for rev nr"
	char customer[8];	// “name of customer”
	char application[8];	// “application name”
	char type[8];		// “application type name”
	u16 ndev;		// "nr of device lists"
	u16 nprof;		// "nr of profile lists"
	struct nxpTfaDescPtr index[]; // start of item index table
} __attribute__((packed));

struct tfa_cnt_header {
	u16	id;
	char	version[2];     /* "V_" : V=version */
	char	subversion[2];  // "vv" : vv=subversion
	u32	size;		// data size in bytes following CRC
	u32	CRC;		// 32-bits CRC for following data
	u16	rev;
	char	customer[8];    // “name of customer”
	char	application[8]; // “application name”
	char	type[8];	// “application type name”
	u16	ndev;		// "nr of device lists"
	u16	nprof;		// "nr of profile lists"
	struct nxpTfaDescPtr index[]; // start of item index table
} __attribute__((packed));


/*
 * the generic header
 *   all char types are in ASCII
 */
struct nxpTfaHeader {
	u16 id;
	char version[2];     // "V_" : V=version, vv=subversion
	char subversion[2];  // "vv" : vv=subversion
	u16 size;       // data size in bytes following CRC
	u32 CRC;        // 32-bits CRC for following data
	char customer[8];    // “name of customer”
	char application[8]; // “application name”
	char type[8];		 // “application type name”
} __attribute__((packed));

#define NXPTFA_PA_VERSION    '1'
#define NXPTFA_PA_SUBVERSION "00"

struct nxpTfaPatch {
	struct nxpTfaHeader hdr;
	u8 data[];
} __attribute__((packed));


/*
 * typedef for 24 bit value using 3 bytes
 */
typedef struct uint24 {
	u8 b[3];
} u24;

/*
 * coolflux direct memory access
 */
struct nxpTfaDspMem {
	u8  type;         /* 0--3: p, x, y, iomem */
	u16 address;      /* target address */
	u8  size;	  /* data size in words */
	s32 words[]; 	  /* payload  in signed 32bit integer (two's complement) */
} __attribute__((packed));

/*
 * the biquad coefficients for the API together with index in filter
 *  the biquad_index is the actual index in the equalizer +1
 */
struct nxpTfaBiquad {
	u8 bytes[6*sizeof(u24)];
} __attribute__((packed));

struct nxpTfaBiquadFloat {
	float headroom;
	float b0;
	float b1;
	float b2;
	float a1;
	float a2;
};

enum nxpTfaFilterType {
	fCustom,         //User defined biquad coefficients
	fFlat,           //Vary only gain
	fLowpass,        //2nd order Butterworth low pass
	fHighpass,       //2nd order Butterworth high pass
	fLowshelf,
	fHighshelf,
	fNotch,
	fPeak,
	fBandpass,
	f1stLP,
	f1stHP,
	fCount
};

/*
 * filter parameters for biquad (re-)calculation
 */
struct nxpTfaFilter {
	struct nxpTfaBiquad biquad;
	u8 enabled;
	u8 type; // (== enum FilterTypes, assure 8bits length)
	float frequency;
	float Q;
	float gain;
} __attribute__((packed));  //8 * float + int32 + byte == 37

/**
 * standalone filter data in container file
 *  contains data for recalculation and payload data
 */
struct nxpTfaBiquadSettings {
	int8_t index; 	/**< index determines destination type; anti-alias, integrator,eq */
	uint8_t type;
	float cutOffFreq;   // cut off frequency
	float samplingFreq;
	float rippleDb_leakage;     // rippleDb or integrator leakage
	float rolloff;
	uint8_t bytes[5*3];	// payload 5*24bits coeffs
} __attribute__((packed));



#define TFA98XX_MAX_EQ 10

struct nxpTfaEqualizer {
	struct nxpTfaFilter filter[TFA98XX_MAX_EQ];// note: API index counts from 1..10
};




/*
 * equalizer file
 */
#define NXPTFA_EQ_VERSION    '1'
#define NXPTFA_EQ_SUBVERSION "00"

struct nxpTfaEqualizerFile {
	struct nxpTfaHeader hdr;
	u8 samplerate;				 // ==enum samplerates, assure 8 bits
	struct nxpTfaFilter filter[TFA98XX_MAX_EQ];// note: API index counts from 1..10
} __attribute__((packed));

/*
 * config file
 */
#define NXPTFA_CO_VERSION    '1'
#define NXPTFA_CO_SUBVERSION "00"

struct nxpTfaConfigFile {
	struct nxpTfaHeader hdr;
	u8 data[];
} __attribute__((packed));

/*
 * preset file
 */
#define NXPTFA_PR_VERSION    '1'
#define NXPTFA_PR_SUBVERSION "00"

struct nxpTfaPresetFile {
	struct nxpTfaHeader hdr;
	u8 data[];
} __attribute__((packed));

/*
 * drc file
 * TODO: Add DRC filter data, treshold ...
 */
#define NXPTFA_DR_VERSION    '1'
#define NXPTFA_DR_SUBVERSION "00"

struct nxpTfaDrcFile {
	struct nxpTfaHeader hdr;
	u8 data[];
}  __attribute__((packed));

/*
 * volume step structures
 */

/* VP01 */
#define NXPTFA_VP1_VERSION    '1'
#define NXPTFA_VP1_SUBVERSION "01"

struct nxpTfaVolumeStep1 {
	u32 attenuation;		// contain IEEE single float
	u8 preset[TFA98XX_PRESET_LENGTH];
} __attribute__((packed));

/* VP02 */
#define NXPTFA_VP2_VERSION    '2'
#define NXPTFA_VP2_SUBVERSION "01"

struct nxpTfaVolumeStep2 {
	u32 attenuation;		// contain IEEE single float
	u8 preset[TFA98XX_PRESET_LENGTH];
	struct nxpTfaFilter filter[TFA98XX_MAX_EQ];// note: API index counts from 1..10
} __attribute__((packed));


/*
 * Register patch descriptor
 */
struct nxpTfaRegpatch {
	u8   address;	// register address
	u16  value;	// value to write
	u16  mask;	// mask of bits to write
} __attribute__((packed));

/*
 * Mode descriptor
 */
struct nxpTfaMode {
	u32  value;	// mode value, maps to enum Tfa98xx_Mode
} __attribute__((packed));


/*
 * volumestep file
 */
struct nxpTfaVolumeStepFile {
	struct nxpTfaHeader hdr;
	u8 vsteps;	// can also be calulated from size+type
	u8 samplerate;	// ==enum samplerates, assure 8 bits
	u8 payload;	//start of variable length contents:N times volsteps
} __attribute__((packed));

/*
 * volumestep2 file
 */
struct nxpTfaVolumeStep2File {
	struct nxpTfaHeader hdr;
	u8 vsteps;	// can also be calulated from size+type
	u8 samplerate;	// ==enum samplerates, assure 8 bits
	struct nxpTfaVolumeStep2 vstep[];	//start of variable length contents:N times volsteps
} __attribute__((packed));

/*
 * speaker file
 */
#define NXPTFA_SP_VERSION    '1'
#define NXPTFA_SP_SUBVERSION "00"

struct nxpTfaSpeakerFile {
	struct nxpTfaHeader hdr;
	char name[8];	// speaker nick name (e.g. “dumbo”)
	char vendor[16];
	char type[8];
	/* dimensions (mm) */
	u8 height;
	u8 width;
	u8 depth;
	u16 ohm;
	u8 data[]; //payload TFA98XX_SPEAKERPARAMETER_LENGTH
} __attribute__((packed));

/*
 * Bitfield descriptor
 */
struct nxpTfaBitfield {
	u16  value;
	u16  field; // ==datasheet defined, 16 bits
} __attribute__((packed));

/*
 * Bitfield enumuration bits descriptor
 */
struct nxpTfaBfEnum {
	u16  len:4;		// this is the actual length-1
	u16  pos:4;
	u16  address:8;
} __attribute__((packed));


struct drcBiquad {
	u24 freq;		// center frequency
	u24 Q;			// Q factor
	u24 gain;		// gain in dB
	u24 type;		// filter type (= enum dspBqFiltType_t)
};

struct drc {
	u24 enabled;	// drc enabled
	u24 sidechain;	// side chain usage
	u24 kneetype;	// knee type enum
	u24 env;		// envelope
	u24 attack;		// attack time in ms
	u24 release;	// release time in ms;
	u24 thresDb;	// threshold in dB;
	u24 ratio;
	u24 makeupGain;	// make up gain in dB
};

struct drcBandLimited {
	u24 enabled;			// band limted drc enabled (0 = off)
	struct drcBiquad biquad;	// biquad for band
	struct drc limiter;			// band limiter
};

struct drcParamBlock {
	u24 drcOn;			// drc module enabled. 0 == off
	struct drcBiquad hi1bq;	// high band biquads
	struct drcBiquad hi2bq;
	struct drcBiquad mi1bq;	// mid band biqauds
	struct drcBiquad mi2bq;
	struct drcBiquad mi3bq;
	struct drcBiquad mi4bq;
	struct drcBiquad lo1bq;	// low band biquads
	struct drcBiquad lo2bq;
	struct drcBiquad po1bq;	// post biquads
	struct drcBiquad po2bq;
	struct drc hi1drc;		// high compressors
	struct drc hi2drc;
	struct drc mi1drc;		// mid compressors
	struct drc mi2drc;
	struct drc lo1drc;		// low compressors
	struct drc lo2drc;
	struct drc po1drc;		// post compressors
	struct drc po2drc;
	struct drcBandLimited bl;// band limited compressor
};



int tfa98xx_cnt_loadfile(struct tfa98xx *tfa98xx, int index);
char *tfaContBfName(u16 num);
int tfaContWriteRegsProf(struct tfa98xx *tfa98xx, int profile);
int tfaContWriteRegsDev(struct tfa98xx *tfa98xx);
void tfaContShowHeader(struct tfa98xx *tfa98xx, struct nxpTfaHeader *hdr);
int tfaContWritePatch(struct tfa98xx *tfa98xx);
int tfaContWriteFilterbank(struct tfa98xx *tfa98xx, struct nxpTfaFilter *filter);
int tfaContWriteEq(struct tfa98xx *tfa98xx, struct nxpTfaEqualizerFile *eqf);
int tfaContWriteVstep(struct tfa98xx *tfa98xx, struct nxpTfaVolumeStep2File *vp);
int tfaContWriteFile(struct tfa98xx *tfa98xx, struct nxpTfaFileDsc *file);
int tfaContWriteItem(struct tfa98xx *tfa98xx, struct nxpTfaDescPtr * dsc);
int tfaContWriteProfile(struct tfa98xx *tfa98xx, int profile, int vstep);
int tfaContWriteFilesProf(struct tfa98xx *tfa98xx, int profile, int vstep);
int tfaContWriteFiles(struct tfa98xx *tfa98xx);
int tfa98xx_dsp_write_drc(struct tfa98xx *tfa98xx, int len, const u8 *data);
int tfaContWriteFilesVstep(struct tfa98xx *tfa98xx, int profile, int vstep);

#endif