frodovdr/satip-axe
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
0825c29009
satip-axe/kernel/sound/stm/reg_aud_spdif.h

1891 lines
72 KiB
C
Raw Normal View History

add idl4k kernel firmware version 1.13.0.105
2015-03-26 17:22:37 +01:00
#ifndef __SND_STM_AUD_SPDIF_H
#define __SND_STM_AUD_SPDIF_H
/*
* AUD_SPDIF_RST
*/
#define offset__AUD_SPDIF_RST(ip) 0x00
#define get__AUD_SPDIF_RST(ip) readl(ip->base + \
offset__AUD_SPDIF_RST(ip))
#define set__AUD_SPDIF_RST(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_RST(ip))
/* SRSTP */
#define shift__AUD_SPDIF_RST__SRSTP(ip) 0
#define mask__AUD_SPDIF_RST__SRSTP(ip) 0x1
#define get__AUD_SPDIF_RST__SRSTP(ip) ((readl(ip->base + \
offset__AUD_SPDIF_RST(ip)) >> shift__AUD_SPDIF_RST__SRSTP(ip)) & \
mask__AUD_SPDIF_RST__SRSTP(ip))
#define set__AUD_SPDIF_RST__SRSTP(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_RST(ip)) & ~(mask__AUD_SPDIF_RST__SRSTP(ip) << \
shift__AUD_SPDIF_RST__SRSTP(ip))) | (((value) & \
mask__AUD_SPDIF_RST__SRSTP(ip)) << shift__AUD_SPDIF_RST__SRSTP(ip)), \
ip->base + offset__AUD_SPDIF_RST(ip))
#define value__AUD_SPDIF_RST__SRSTP__RUNNING(ip) 0x0
#define mask__AUD_SPDIF_RST__SRSTP__RUNNING(ip) \
(value__AUD_SPDIF_RST__SRSTP__RUNNING(ip) << \
shift__AUD_SPDIF_RST__SRSTP(ip))
#define set__AUD_SPDIF_RST__SRSTP__RUNNING(ip) \
set__AUD_SPDIF_RST__SRSTP(ip, \
value__AUD_SPDIF_RST__SRSTP__RUNNING(ip))
#define value__AUD_SPDIF_RST__SRSTP__RESET(ip) 0x1
#define mask__AUD_SPDIF_RST__SRSTP__RESET(ip) \
(value__AUD_SPDIF_RST__SRSTP__RESET(ip) << \
shift__AUD_SPDIF_RST__SRSTP(ip))
#define set__AUD_SPDIF_RST__SRSTP__RESET(ip) \
set__AUD_SPDIF_RST__SRSTP(ip, value__AUD_SPDIF_RST__SRSTP__RESET(ip))
/*
* AUD_SPDIF_DATA
*/
#define offset__AUD_SPDIF_DATA(ip) 0x04
#define get__AUD_SPDIF_DATA(ip) readl(ip->base + \
offset__AUD_SPDIF_DATA(ip))
#define set__AUD_SPDIF_DATA(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_DATA(ip))
/* DATA */
#define shift__AUD_SPDIF_DATA__DATA(ip) 0
#define mask__AUD_SPDIF_DATA__DATA(ip) 0xffffffff
#define get__AUD_SPDIF_DATA__DATA(ip) ((readl(ip->base + \
offset__AUD_SPDIF_DATA(ip)) >> shift__AUD_SPDIF_DATA__DATA(ip)) & \
mask__AUD_SPDIF_DATA__DATA(ip))
#define set__AUD_SPDIF_DATA__DATA(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_DATA(ip)) & ~(mask__AUD_SPDIF_DATA__DATA(ip) << \
shift__AUD_SPDIF_DATA__DATA(ip))) | (((value) & \
mask__AUD_SPDIF_DATA__DATA(ip)) << shift__AUD_SPDIF_DATA__DATA(ip)), \
ip->base + offset__AUD_SPDIF_DATA(ip))
/*
* AUD_SPDIF_ITS
*/
#define offset__AUD_SPDIF_ITS(ip) 0x08
#define get__AUD_SPDIF_ITS(ip) readl(ip->base + \
offset__AUD_SPDIF_ITS(ip))
#define set__AUD_SPDIF_ITS(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_ITS(ip))
/* UNF */
#define shift__AUD_SPDIF_ITS__UNF(ip) 0
#define mask__AUD_SPDIF_ITS__UNF(ip) 0x1
#define get__AUD_SPDIF_ITS__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__UNF(ip)) & \
mask__AUD_SPDIF_ITS__UNF(ip))
#define set__AUD_SPDIF_ITS__UNF(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) & ~(mask__AUD_SPDIF_ITS__UNF(ip) << \
shift__AUD_SPDIF_ITS__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__UNF(ip)) << shift__AUD_SPDIF_ITS__UNF(ip)), \
ip->base + offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__UNF__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__UNF__PENDING(ip) \
(value__AUD_SPDIF_ITS__UNF__PENDING(ip) << \
shift__AUD_SPDIF_ITS__UNF(ip))
#define set__AUD_SPDIF_ITS__UNF__PENDING(ip) \
set__AUD_SPDIF_ITS__UNF(ip, value__AUD_SPDIF_ITS__UNF__PENDING(ip))
/* EOBURST */
#define shift__AUD_SPDIF_ITS__EOBURST(ip) 1
#define mask__AUD_SPDIF_ITS__EOBURST(ip) 0x1
#define get__AUD_SPDIF_ITS__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__EOBURST(ip)) & \
mask__AUD_SPDIF_ITS__EOBURST(ip))
#define set__AUD_SPDIF_ITS__EOBURST(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_ITS(ip)) & ~(mask__AUD_SPDIF_ITS__EOBURST(ip) << \
shift__AUD_SPDIF_ITS__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__EOBURST(ip)) << \
shift__AUD_SPDIF_ITS__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__EOBURST__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__EOBURST__PENDING(ip) \
(value__AUD_SPDIF_ITS__EOBURST__PENDING(ip) << \
shift__AUD_SPDIF_ITS__EOBURST(ip))
#define set__AUD_SPDIF_ITS__EOBURST__PENDING(ip) \
set__AUD_SPDIF_ITS__EOBURST(ip, \
value__AUD_SPDIF_ITS__EOBURST__PENDING(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_ITS__EOBLOCK(ip) 2
#define mask__AUD_SPDIF_ITS__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_ITS__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__EOBLOCK(ip)) & \
mask__AUD_SPDIF_ITS__EOBLOCK(ip))
#define set__AUD_SPDIF_ITS__EOBLOCK(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_ITS(ip)) & ~(mask__AUD_SPDIF_ITS__EOBLOCK(ip) << \
shift__AUD_SPDIF_ITS__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__EOBLOCK(ip)) << \
shift__AUD_SPDIF_ITS__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__EOBLOCK__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__EOBLOCK__PENDING(ip) \
(value__AUD_SPDIF_ITS__EOBLOCK__PENDING(ip) << \
shift__AUD_SPDIF_ITS__EOBLOCK(ip))
#define set__AUD_SPDIF_ITS__EOBLOCK__PENDING(ip) \
set__AUD_SPDIF_ITS__EOBLOCK(ip, \
value__AUD_SPDIF_ITS__EOBLOCK__PENDING(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_ITS__EOLATENCY(ip) 3
#define mask__AUD_SPDIF_ITS__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_ITS__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__EOLATENCY(ip)) & \
mask__AUD_SPDIF_ITS__EOLATENCY(ip))
#define set__AUD_SPDIF_ITS__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_ITS(ip)) & \
~(mask__AUD_SPDIF_ITS__EOLATENCY(ip) << \
shift__AUD_SPDIF_ITS__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__EOLATENCY(ip)) << \
shift__AUD_SPDIF_ITS__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__EOLATENCY__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__EOLATENCY__PENDING(ip) \
(value__AUD_SPDIF_ITS__EOLATENCY__PENDING(ip) << \
shift__AUD_SPDIF_ITS__EOLATENCY(ip))
#define set__AUD_SPDIF_ITS__EOLATENCY__PENDING(ip) \
set__AUD_SPDIF_ITS__EOLATENCY(ip, \
value__AUD_SPDIF_ITS__EOLATENCY__PENDING(ip))
/* EOPD */
#define shift__AUD_SPDIF_ITS__EOPD(ip) 4
#define mask__AUD_SPDIF_ITS__EOPD(ip) 0x1
#define get__AUD_SPDIF_ITS__EOPD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__EOPD(ip)) & \
mask__AUD_SPDIF_ITS__EOPD(ip))
#define set__AUD_SPDIF_ITS__EOPD(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) & ~(mask__AUD_SPDIF_ITS__EOPD(ip) << \
shift__AUD_SPDIF_ITS__EOPD(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__EOPD(ip)) << shift__AUD_SPDIF_ITS__EOPD(ip)), \
ip->base + offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__EOPD__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__EOPD__PENDING(ip) \
(value__AUD_SPDIF_ITS__EOPD__PENDING(ip) << \
shift__AUD_SPDIF_ITS__EOPD(ip))
#define set__AUD_SPDIF_ITS__EOPD__PENDING(ip) \
set__AUD_SPDIF_ITS__EOPD(ip, value__AUD_SPDIF_ITS__EOPD__PENDING(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_ITS__NSAMPLE(ip) 5
#define mask__AUD_SPDIF_ITS__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_ITS__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS(ip)) >> shift__AUD_SPDIF_ITS__NSAMPLE(ip)) & \
mask__AUD_SPDIF_ITS__NSAMPLE(ip))
#define set__AUD_SPDIF_ITS__NSAMPLE(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_ITS(ip)) & ~(mask__AUD_SPDIF_ITS__NSAMPLE(ip) << \
shift__AUD_SPDIF_ITS__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_ITS__NSAMPLE(ip)) << \
shift__AUD_SPDIF_ITS__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_ITS(ip))
#define value__AUD_SPDIF_ITS__NSAMPLE__PENDING(ip) 0x1
#define mask__AUD_SPDIF_ITS__NSAMPLE__PENDING(ip) \
(value__AUD_SPDIF_ITS__NSAMPLE__PENDING(ip) << \
shift__AUD_SPDIF_ITS__NSAMPLE(ip))
#define set__AUD_SPDIF_ITS__NSAMPLE__PENDING(ip) \
set__AUD_SPDIF_ITS__NSAMPLE(ip, \
value__AUD_SPDIF_ITS__NSAMPLE__PENDING(ip))
/*
* AUD_SPDIF_ITS_CLR
*/
#define offset__AUD_SPDIF_ITS_CLR(ip) 0x0c
#define get__AUD_SPDIF_ITS_CLR(ip) readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define set__AUD_SPDIF_ITS_CLR(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
/* UNF */
#define shift__AUD_SPDIF_ITS_CLR__UNF(ip) 0
#define mask__AUD_SPDIF_ITS_CLR__UNF(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> shift__AUD_SPDIF_ITS_CLR__UNF(ip)) & \
mask__AUD_SPDIF_ITS_CLR__UNF(ip))
#define set__AUD_SPDIF_ITS_CLR__UNF(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_ITS_CLR(ip)) & ~(mask__AUD_SPDIF_ITS_CLR__UNF(ip) \
<< shift__AUD_SPDIF_ITS_CLR__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__UNF(ip)) << \
shift__AUD_SPDIF_ITS_CLR__UNF(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__UNF__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__UNF__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__UNF__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__UNF(ip))
#define set__AUD_SPDIF_ITS_CLR__UNF__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__UNF(ip, \
value__AUD_SPDIF_ITS_CLR__UNF__CLEAR(ip))
/* EOBURST */
#define shift__AUD_SPDIF_ITS_CLR__EOBURST(ip) 1
#define mask__AUD_SPDIF_ITS_CLR__EOBURST(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> \
shift__AUD_SPDIF_ITS_CLR__EOBURST(ip)) & \
mask__AUD_SPDIF_ITS_CLR__EOBURST(ip))
#define set__AUD_SPDIF_ITS_CLR__EOBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_ITS_CLR(ip)) & \
~(mask__AUD_SPDIF_ITS_CLR__EOBURST(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__EOBURST(ip)) << \
shift__AUD_SPDIF_ITS_CLR__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__EOBURST__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__EOBURST__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__EOBURST__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOBURST(ip))
#define set__AUD_SPDIF_ITS_CLR__EOBURST__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__EOBURST(ip, \
value__AUD_SPDIF_ITS_CLR__EOBURST__CLEAR(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_ITS_CLR__EOBLOCK(ip) 2
#define mask__AUD_SPDIF_ITS_CLR__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> \
shift__AUD_SPDIF_ITS_CLR__EOBLOCK(ip)) & \
mask__AUD_SPDIF_ITS_CLR__EOBLOCK(ip))
#define set__AUD_SPDIF_ITS_CLR__EOBLOCK(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_ITS_CLR(ip)) & \
~(mask__AUD_SPDIF_ITS_CLR__EOBLOCK(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__EOBLOCK(ip)) << \
shift__AUD_SPDIF_ITS_CLR__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__EOBLOCK__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__EOBLOCK__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__EOBLOCK__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOBLOCK(ip))
#define set__AUD_SPDIF_ITS_CLR__EOBLOCK__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__EOBLOCK(ip, \
value__AUD_SPDIF_ITS_CLR__EOBLOCK__CLEAR(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_ITS_CLR__EOLATENCY(ip) 3
#define mask__AUD_SPDIF_ITS_CLR__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> \
shift__AUD_SPDIF_ITS_CLR__EOLATENCY(ip)) & \
mask__AUD_SPDIF_ITS_CLR__EOLATENCY(ip))
#define set__AUD_SPDIF_ITS_CLR__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_ITS_CLR(ip)) & \
~(mask__AUD_SPDIF_ITS_CLR__EOLATENCY(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__EOLATENCY(ip)) << \
shift__AUD_SPDIF_ITS_CLR__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__EOLATENCY__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__EOLATENCY__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__EOLATENCY__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOLATENCY(ip))
#define set__AUD_SPDIF_ITS_CLR__EOLATENCY__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__EOLATENCY(ip, \
value__AUD_SPDIF_ITS_CLR__EOLATENCY__CLEAR(ip))
/* EOPD */
#define shift__AUD_SPDIF_ITS_CLR__EOPD(ip) 4
#define mask__AUD_SPDIF_ITS_CLR__EOPD(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__EOPD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> shift__AUD_SPDIF_ITS_CLR__EOPD(ip)) \
& mask__AUD_SPDIF_ITS_CLR__EOPD(ip))
#define set__AUD_SPDIF_ITS_CLR__EOPD(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_ITS_CLR(ip)) & ~(mask__AUD_SPDIF_ITS_CLR__EOPD(ip) \
<< shift__AUD_SPDIF_ITS_CLR__EOPD(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__EOPD(ip)) << \
shift__AUD_SPDIF_ITS_CLR__EOPD(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__EOPD__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__EOPD__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__EOPD__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__EOPD(ip))
#define set__AUD_SPDIF_ITS_CLR__EOPD__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__EOPD(ip, \
value__AUD_SPDIF_ITS_CLR__EOPD__CLEAR(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_ITS_CLR__NSAMPLE(ip) 5
#define mask__AUD_SPDIF_ITS_CLR__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_ITS_CLR__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip)) >> \
shift__AUD_SPDIF_ITS_CLR__NSAMPLE(ip)) & \
mask__AUD_SPDIF_ITS_CLR__NSAMPLE(ip))
#define set__AUD_SPDIF_ITS_CLR__NSAMPLE(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_ITS_CLR(ip)) & \
~(mask__AUD_SPDIF_ITS_CLR__NSAMPLE(ip) << \
shift__AUD_SPDIF_ITS_CLR__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_ITS_CLR__NSAMPLE(ip)) << \
shift__AUD_SPDIF_ITS_CLR__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_ITS_CLR(ip))
#define value__AUD_SPDIF_ITS_CLR__NSAMPLE__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_ITS_CLR__NSAMPLE__CLEAR(ip) \
(value__AUD_SPDIF_ITS_CLR__NSAMPLE__CLEAR(ip) << \
shift__AUD_SPDIF_ITS_CLR__NSAMPLE(ip))
#define set__AUD_SPDIF_ITS_CLR__NSAMPLE__CLEAR(ip) \
set__AUD_SPDIF_ITS_CLR__NSAMPLE(ip, \
value__AUD_SPDIF_ITS_CLR__NSAMPLE__CLEAR(ip))
/*
* AUD_SPDIF_IT_EN
*/
#define offset__AUD_SPDIF_IT_EN(ip) 0x10
#define get__AUD_SPDIF_IT_EN(ip) readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
#define set__AUD_SPDIF_IT_EN(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
/* UNF */
#define shift__AUD_SPDIF_IT_EN__UNF(ip) 0
#define mask__AUD_SPDIF_IT_EN__UNF(ip) 0x1
#define get__AUD_SPDIF_IT_EN__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__UNF(ip)) & \
mask__AUD_SPDIF_IT_EN__UNF(ip))
#define set__AUD_SPDIF_IT_EN__UNF(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) & ~(mask__AUD_SPDIF_IT_EN__UNF(ip) << \
shift__AUD_SPDIF_IT_EN__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__UNF(ip)) << shift__AUD_SPDIF_IT_EN__UNF(ip)), \
ip->base + offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__UNF__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__UNF__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__UNF__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__UNF(ip))
#define set__AUD_SPDIF_IT_EN__UNF__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__UNF(ip, \
value__AUD_SPDIF_IT_EN__UNF__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__UNF__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__UNF__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__UNF__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__UNF(ip))
#define set__AUD_SPDIF_IT_EN__UNF__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__UNF(ip, \
value__AUD_SPDIF_IT_EN__UNF__ENABLED(ip))
/* EOBURST */
#define shift__AUD_SPDIF_IT_EN__EOBURST(ip) 1
#define mask__AUD_SPDIF_IT_EN__EOBURST(ip) 0x1
#define get__AUD_SPDIF_IT_EN__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__EOBURST(ip)) & \
mask__AUD_SPDIF_IT_EN__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN__EOBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN(ip)) & \
~(mask__AUD_SPDIF_IT_EN__EOBURST(ip) << \
shift__AUD_SPDIF_IT_EN__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__EOBURST(ip)) << \
shift__AUD_SPDIF_IT_EN__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__EOBURST__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__EOBURST__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOBURST__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN__EOBURST__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__EOBURST(ip, \
value__AUD_SPDIF_IT_EN__EOBURST__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__EOBURST__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__EOBURST__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOBURST__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN__EOBURST__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__EOBURST(ip, \
value__AUD_SPDIF_IT_EN__EOBURST__ENABLED(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_IT_EN__EOBLOCK(ip) 2
#define mask__AUD_SPDIF_IT_EN__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_IT_EN__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__EOBLOCK(ip)) & \
mask__AUD_SPDIF_IT_EN__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN__EOBLOCK(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN(ip)) & \
~(mask__AUD_SPDIF_IT_EN__EOBLOCK(ip) << \
shift__AUD_SPDIF_IT_EN__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__EOBLOCK(ip)) << \
shift__AUD_SPDIF_IT_EN__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__EOBLOCK__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__EOBLOCK__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOBLOCK__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN__EOBLOCK__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__EOBLOCK(ip, \
value__AUD_SPDIF_IT_EN__EOBLOCK__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__EOBLOCK__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__EOBLOCK__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOBLOCK__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN__EOBLOCK__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__EOBLOCK(ip, \
value__AUD_SPDIF_IT_EN__EOBLOCK__ENABLED(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_IT_EN__EOLATENCY(ip) 3
#define mask__AUD_SPDIF_IT_EN__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_IT_EN__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__EOLATENCY(ip)) \
& mask__AUD_SPDIF_IT_EN__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN(ip)) & \
~(mask__AUD_SPDIF_IT_EN__EOLATENCY(ip) << \
shift__AUD_SPDIF_IT_EN__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__EOLATENCY(ip)) << \
shift__AUD_SPDIF_IT_EN__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__EOLATENCY__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__EOLATENCY__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOLATENCY__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN__EOLATENCY__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__EOLATENCY(ip, \
value__AUD_SPDIF_IT_EN__EOLATENCY__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__EOLATENCY__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__EOLATENCY__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOLATENCY__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN__EOLATENCY__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__EOLATENCY(ip, \
value__AUD_SPDIF_IT_EN__EOLATENCY__ENABLED(ip))
/* EOPD */
#define shift__AUD_SPDIF_IT_EN__EOPD(ip) 4
#define mask__AUD_SPDIF_IT_EN__EOPD(ip) 0x1
#define get__AUD_SPDIF_IT_EN__EOPD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__EOPD(ip)) & \
mask__AUD_SPDIF_IT_EN__EOPD(ip))
#define set__AUD_SPDIF_IT_EN__EOPD(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) & ~(mask__AUD_SPDIF_IT_EN__EOPD(ip) << \
shift__AUD_SPDIF_IT_EN__EOPD(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__EOPD(ip)) << shift__AUD_SPDIF_IT_EN__EOPD(ip)), \
ip->base + offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__EOPD__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__EOPD__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOPD__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOPD(ip))
#define set__AUD_SPDIF_IT_EN__EOPD__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__EOPD(ip, \
value__AUD_SPDIF_IT_EN__EOPD__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__EOPD__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__EOPD__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__EOPD__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__EOPD(ip))
#define set__AUD_SPDIF_IT_EN__EOPD__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__EOPD(ip, \
value__AUD_SPDIF_IT_EN__EOPD__ENABLED(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_IT_EN__NSAMPLE(ip) 5
#define mask__AUD_SPDIF_IT_EN__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_IT_EN__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN(ip)) >> shift__AUD_SPDIF_IT_EN__NSAMPLE(ip)) & \
mask__AUD_SPDIF_IT_EN__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN__NSAMPLE(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN(ip)) & \
~(mask__AUD_SPDIF_IT_EN__NSAMPLE(ip) << \
shift__AUD_SPDIF_IT_EN__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN__NSAMPLE(ip)) << \
shift__AUD_SPDIF_IT_EN__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN(ip))
#define value__AUD_SPDIF_IT_EN__NSAMPLE__DISABLED(ip) 0x0
#define mask__AUD_SPDIF_IT_EN__NSAMPLE__DISABLED(ip) \
(value__AUD_SPDIF_IT_EN__NSAMPLE__DISABLED(ip) << \
shift__AUD_SPDIF_IT_EN__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN__NSAMPLE__DISABLED(ip) \
set__AUD_SPDIF_IT_EN__NSAMPLE(ip, \
value__AUD_SPDIF_IT_EN__NSAMPLE__DISABLED(ip))
#define value__AUD_SPDIF_IT_EN__NSAMPLE__ENABLED(ip) 0x1
#define mask__AUD_SPDIF_IT_EN__NSAMPLE__ENABLED(ip) \
(value__AUD_SPDIF_IT_EN__NSAMPLE__ENABLED(ip) << \
shift__AUD_SPDIF_IT_EN__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN__NSAMPLE__ENABLED(ip) \
set__AUD_SPDIF_IT_EN__NSAMPLE(ip, \
value__AUD_SPDIF_IT_EN__NSAMPLE__ENABLED(ip))
/*
* AUD_SPDIF_IT_EN_SET
*/
#define offset__AUD_SPDIF_IT_EN_SET(ip) 0x14
#define get__AUD_SPDIF_IT_EN_SET(ip) readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define set__AUD_SPDIF_IT_EN_SET(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
/* UNF */
#define shift__AUD_SPDIF_IT_EN_SET__UNF(ip) 0
#define mask__AUD_SPDIF_IT_EN_SET__UNF(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__UNF(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__UNF(ip))
#define set__AUD_SPDIF_IT_EN_SET__UNF(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__UNF(ip) << \
shift__AUD_SPDIF_IT_EN_SET__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__UNF(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__UNF(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__UNF__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__UNF__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__UNF__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__UNF(ip))
#define set__AUD_SPDIF_IT_EN_SET__UNF__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__UNF(ip, \
value__AUD_SPDIF_IT_EN_SET__UNF__SET(ip))
/* EOBURST */
#define shift__AUD_SPDIF_IT_EN_SET__EOBURST(ip) 1
#define mask__AUD_SPDIF_IT_EN_SET__EOBURST(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__EOBURST(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__EOBURST(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__EOBURST(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__EOBURST__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__EOBURST__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__EOBURST__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOBURST__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__EOBURST(ip, \
value__AUD_SPDIF_IT_EN_SET__EOBURST__SET(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip) 2
#define mask__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__EOBLOCK__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__EOBLOCK__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__EOBLOCK__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOBLOCK__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__EOBLOCK(ip, \
value__AUD_SPDIF_IT_EN_SET__EOBLOCK__SET(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip) 3
#define mask__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__EOLATENCY__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__EOLATENCY__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__EOLATENCY__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOLATENCY__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__EOLATENCY(ip, \
value__AUD_SPDIF_IT_EN_SET__EOLATENCY__SET(ip))
/* EOPD */
#define shift__AUD_SPDIF_IT_EN_SET__EOPD(ip) 4
#define mask__AUD_SPDIF_IT_EN_SET__EOPD(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__EOPD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__EOPD(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__EOPD(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOPD(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__EOPD(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOPD(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__EOPD(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__EOPD(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__EOPD__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__EOPD__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__EOPD__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__EOPD(ip))
#define set__AUD_SPDIF_IT_EN_SET__EOPD__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__EOPD(ip, \
value__AUD_SPDIF_IT_EN_SET__EOPD__SET(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip) 5
#define mask__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip)) >> \
shift__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip)) & \
mask__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_SET(ip)) & \
~(mask__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip) << \
shift__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip)) << \
shift__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_SET(ip))
#define value__AUD_SPDIF_IT_EN_SET__NSAMPLE__SET(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_SET__NSAMPLE__SET(ip) \
(value__AUD_SPDIF_IT_EN_SET__NSAMPLE__SET(ip) << \
shift__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN_SET__NSAMPLE__SET(ip) \
set__AUD_SPDIF_IT_EN_SET__NSAMPLE(ip, \
value__AUD_SPDIF_IT_EN_SET__NSAMPLE__SET(ip))
/*
* AUD_SPDIF_IT_EN_CLR
*/
#define offset__AUD_SPDIF_IT_EN_CLR(ip) 0x18
#define get__AUD_SPDIF_IT_EN_CLR(ip) readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define set__AUD_SPDIF_IT_EN_CLR(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
/* UNF */
#define shift__AUD_SPDIF_IT_EN_CLR__UNF(ip) 0
#define mask__AUD_SPDIF_IT_EN_CLR__UNF(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__UNF(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__UNF(ip))
#define set__AUD_SPDIF_IT_EN_CLR__UNF(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__UNF(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__UNF(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__UNF(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__UNF__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__UNF__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__UNF__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__UNF(ip))
#define set__AUD_SPDIF_IT_EN_CLR__UNF__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__UNF(ip, \
value__AUD_SPDIF_IT_EN_CLR__UNF__CLEAR(ip))
/* EOBURST */
#define shift__AUD_SPDIF_IT_EN_CLR__EOBURST(ip) 1
#define mask__AUD_SPDIF_IT_EN_CLR__EOBURST(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__EOBURST(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__EOBURST(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__EOBURST(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__EOBURST__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__EOBURST__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__EOBURST__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBURST(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOBURST__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__EOBURST(ip, \
value__AUD_SPDIF_IT_EN_CLR__EOBURST__CLEAR(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip) 2
#define mask__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__EOBLOCK__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__EOBLOCK__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__EOBLOCK__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOBLOCK__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__EOBLOCK(ip, \
value__AUD_SPDIF_IT_EN_CLR__EOBLOCK__CLEAR(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip) 3
#define mask__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__EOLATENCY__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__EOLATENCY__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__EOLATENCY__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOLATENCY__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__EOLATENCY(ip, \
value__AUD_SPDIF_IT_EN_CLR__EOLATENCY__CLEAR(ip))
/* EOPD */
#define shift__AUD_SPDIF_IT_EN_CLR__EOPD(ip) 4
#define mask__AUD_SPDIF_IT_EN_CLR__EOPD(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__EOPD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__EOPD(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__EOPD(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOPD(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__EOPD(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOPD(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__EOPD(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__EOPD(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__EOPD__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__EOPD__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__EOPD__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__EOPD(ip))
#define set__AUD_SPDIF_IT_EN_CLR__EOPD__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__EOPD(ip, \
value__AUD_SPDIF_IT_EN_CLR__EOPD__CLEAR(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip) 5
#define mask__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip)) >> \
shift__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip)) & \
mask__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_IT_EN_CLR(ip)) & \
~(mask__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip)) << \
shift__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_IT_EN_CLR(ip))
#define value__AUD_SPDIF_IT_EN_CLR__NSAMPLE__CLEAR(ip) 0x1
#define mask__AUD_SPDIF_IT_EN_CLR__NSAMPLE__CLEAR(ip) \
(value__AUD_SPDIF_IT_EN_CLR__NSAMPLE__CLEAR(ip) << \
shift__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip))
#define set__AUD_SPDIF_IT_EN_CLR__NSAMPLE__CLEAR(ip) \
set__AUD_SPDIF_IT_EN_CLR__NSAMPLE(ip, \
value__AUD_SPDIF_IT_EN_CLR__NSAMPLE__CLEAR(ip))
/*
* AUD_SPDIF_CTRL
*/
#define offset__AUD_SPDIF_CTRL(ip) 0x1c
#define get__AUD_SPDIF_CTRL(ip) readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip))
#define set__AUD_SPDIF_CTRL(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_CTRL(ip))
/* MODE */
#define shift__AUD_SPDIF_CTRL__MODE(ip) 0
#define mask__AUD_SPDIF_CTRL__MODE(ip) 0x7
#define get__AUD_SPDIF_CTRL__MODE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__MODE(ip)) & \
mask__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) & ~(mask__AUD_SPDIF_CTRL__MODE(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__MODE(ip)) << shift__AUD_SPDIF_CTRL__MODE(ip)), \
ip->base + offset__AUD_SPDIF_CTRL(ip))
#define value__AUD_SPDIF_CTRL__MODE__OFF(ip) 0x0
#define mask__AUD_SPDIF_CTRL__MODE__OFF(ip) \
(value__AUD_SPDIF_CTRL__MODE__OFF(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE__OFF(ip) \
set__AUD_SPDIF_CTRL__MODE(ip, value__AUD_SPDIF_CTRL__MODE__OFF(ip))
#define value__AUD_SPDIF_CTRL__MODE__MUTE_PCM_NULL(ip) 0x1
#define mask__AUD_SPDIF_CTRL__MODE__MUTE_PCM_NULL(ip) \
(value__AUD_SPDIF_CTRL__MODE__MUTE_PCM_NULL(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE__MUTE_PCM_NULL(ip) \
set__AUD_SPDIF_CTRL__MODE(ip, \
value__AUD_SPDIF_CTRL__MODE__MUTE_PCM_NULL(ip))
#define value__AUD_SPDIF_CTRL__MODE__MUTE_PAUSE_BURSTS(ip) 0x2
#define mask__AUD_SPDIF_CTRL__MODE__MUTE_PAUSE_BURSTS(ip) \
(value__AUD_SPDIF_CTRL__MODE__MUTE_PAUSE_BURSTS(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE__MUTE_PAUSE_BURSTS(ip) \
set__AUD_SPDIF_CTRL__MODE(ip, \
value__AUD_SPDIF_CTRL__MODE__MUTE_PAUSE_BURSTS(ip))
#define value__AUD_SPDIF_CTRL__MODE__PCM(ip) 0x3
#define mask__AUD_SPDIF_CTRL__MODE__PCM(ip) \
(value__AUD_SPDIF_CTRL__MODE__PCM(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE__PCM(ip) \
set__AUD_SPDIF_CTRL__MODE(ip, value__AUD_SPDIF_CTRL__MODE__PCM(ip))
#define value__AUD_SPDIF_CTRL__MODE__ENCODED(ip) 0x4
#define mask__AUD_SPDIF_CTRL__MODE__ENCODED(ip) \
(value__AUD_SPDIF_CTRL__MODE__ENCODED(ip) << \
shift__AUD_SPDIF_CTRL__MODE(ip))
#define set__AUD_SPDIF_CTRL__MODE__ENCODED(ip) \
set__AUD_SPDIF_CTRL__MODE(ip, \
value__AUD_SPDIF_CTRL__MODE__ENCODED(ip))
/* IDLE */
#define shift__AUD_SPDIF_CTRL__IDLE(ip) 3
#define mask__AUD_SPDIF_CTRL__IDLE(ip) 0x1
#define get__AUD_SPDIF_CTRL__IDLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__IDLE(ip)) & \
mask__AUD_SPDIF_CTRL__IDLE(ip))
#define set__AUD_SPDIF_CTRL__IDLE(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) & ~(mask__AUD_SPDIF_CTRL__IDLE(ip) << \
shift__AUD_SPDIF_CTRL__IDLE(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__IDLE(ip)) << shift__AUD_SPDIF_CTRL__IDLE(ip)), \
ip->base + offset__AUD_SPDIF_CTRL(ip))
#define value__AUD_SPDIF_CTRL__IDLE__NORMAL(ip) 0x0
#define mask__AUD_SPDIF_CTRL__IDLE__NORMAL(ip) \
(value__AUD_SPDIF_CTRL__IDLE__NORMAL(ip) << \
shift__AUD_SPDIF_CTRL__IDLE(ip))
#define set__AUD_SPDIF_CTRL__IDLE__NORMAL(ip) \
set__AUD_SPDIF_CTRL__IDLE(ip, value__AUD_SPDIF_CTRL__IDLE__NORMAL(ip))
#define value__AUD_SPDIF_CTRL__IDLE__IDLE(ip) 0x1
#define mask__AUD_SPDIF_CTRL__IDLE__IDLE(ip) \
(value__AUD_SPDIF_CTRL__IDLE__IDLE(ip) << \
shift__AUD_SPDIF_CTRL__IDLE(ip))
#define set__AUD_SPDIF_CTRL__IDLE__IDLE(ip) \
set__AUD_SPDIF_CTRL__IDLE(ip, value__AUD_SPDIF_CTRL__IDLE__IDLE(ip))
/* RND */
#define shift__AUD_SPDIF_CTRL__RND(ip) 4
#define mask__AUD_SPDIF_CTRL__RND(ip) 0x1
#define get__AUD_SPDIF_CTRL__RND(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__RND(ip)) & \
mask__AUD_SPDIF_CTRL__RND(ip))
#define set__AUD_SPDIF_CTRL__RND(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) & ~(mask__AUD_SPDIF_CTRL__RND(ip) << \
shift__AUD_SPDIF_CTRL__RND(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__RND(ip)) << shift__AUD_SPDIF_CTRL__RND(ip)), \
ip->base + offset__AUD_SPDIF_CTRL(ip))
#define value__AUD_SPDIF_CTRL__RND__NO_ROUNDING(ip) 0x0
#define mask__AUD_SPDIF_CTRL__RND__NO_ROUNDING(ip) \
(value__AUD_SPDIF_CTRL__RND__NO_ROUNDING(ip) << \
shift__AUD_SPDIF_CTRL__RND(ip))
#define set__AUD_SPDIF_CTRL__RND__NO_ROUNDING(ip) \
set__AUD_SPDIF_CTRL__RND(ip, \
value__AUD_SPDIF_CTRL__RND__NO_ROUNDING(ip))
#define value__AUD_SPDIF_CTRL__RND__16_BITS_ROUNDING(ip) 0x1
#define mask__AUD_SPDIF_CTRL__RND__16_BITS_ROUNDING(ip) \
(value__AUD_SPDIF_CTRL__RND__16_BITS_ROUNDING(ip) << \
shift__AUD_SPDIF_CTRL__RND(ip))
#define set__AUD_SPDIF_CTRL__RND__16_BITS_ROUNDING(ip) \
set__AUD_SPDIF_CTRL__RND(ip, \
value__AUD_SPDIF_CTRL__RND__16_BITS_ROUNDING(ip))
/* CLK_DIV */
#define shift__AUD_SPDIF_CTRL__CLK_DIV(ip) 5
#define mask__AUD_SPDIF_CTRL__CLK_DIV(ip) 0xff
#define get__AUD_SPDIF_CTRL__CLK_DIV(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__CLK_DIV(ip)) & \
mask__AUD_SPDIF_CTRL__CLK_DIV(ip))
#define set__AUD_SPDIF_CTRL__CLK_DIV(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_CTRL(ip)) & ~(mask__AUD_SPDIF_CTRL__CLK_DIV(ip) << \
shift__AUD_SPDIF_CTRL__CLK_DIV(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__CLK_DIV(ip)) << \
shift__AUD_SPDIF_CTRL__CLK_DIV(ip)), ip->base + \
offset__AUD_SPDIF_CTRL(ip))
/* STUFFING */
#define shift__AUD_SPDIF_CTRL__STUFFING(ip) 14
#define mask__AUD_SPDIF_CTRL__STUFFING(ip) 0x1
#define get__AUD_SPDIF_CTRL__STUFFING(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__STUFFING(ip)) & \
mask__AUD_SPDIF_CTRL__STUFFING(ip))
#define set__AUD_SPDIF_CTRL__STUFFING(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CTRL(ip)) & \
~(mask__AUD_SPDIF_CTRL__STUFFING(ip) << \
shift__AUD_SPDIF_CTRL__STUFFING(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__STUFFING(ip)) << \
shift__AUD_SPDIF_CTRL__STUFFING(ip)), ip->base + \
offset__AUD_SPDIF_CTRL(ip))
#define value__AUD_SPDIF_CTRL__STUFFING__SOFTWARE(ip) 0x0
#define mask__AUD_SPDIF_CTRL__STUFFING__SOFTWARE(ip) \
(value__AUD_SPDIF_CTRL__STUFFING__SOFTWARE(ip) << \
shift__AUD_SPDIF_CTRL__STUFFING(ip))
#define set__AUD_SPDIF_CTRL__STUFFING__SOFTWARE(ip) \
set__AUD_SPDIF_CTRL__STUFFING(ip, \
value__AUD_SPDIF_CTRL__STUFFING__SOFTWARE(ip))
#define value__AUD_SPDIF_CTRL__STUFFING__HARDWARE(ip) 0x1
#define mask__AUD_SPDIF_CTRL__STUFFING__HARDWARE(ip) \
(value__AUD_SPDIF_CTRL__STUFFING__HARDWARE(ip) << \
shift__AUD_SPDIF_CTRL__STUFFING(ip))
#define set__AUD_SPDIF_CTRL__STUFFING__HARDWARE(ip) \
set__AUD_SPDIF_CTRL__STUFFING(ip, \
value__AUD_SPDIF_CTRL__STUFFING__HARDWARE(ip))
/* MEMREAD */
#define shift__AUD_SPDIF_CTRL__MEMREAD(ip) 15
#define mask__AUD_SPDIF_CTRL__MEMREAD(ip) 0x1ffff
#define get__AUD_SPDIF_CTRL__MEMREAD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CTRL(ip)) >> shift__AUD_SPDIF_CTRL__MEMREAD(ip)) & \
mask__AUD_SPDIF_CTRL__MEMREAD(ip))
#define set__AUD_SPDIF_CTRL__MEMREAD(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_CTRL(ip)) & ~(mask__AUD_SPDIF_CTRL__MEMREAD(ip) << \
shift__AUD_SPDIF_CTRL__MEMREAD(ip))) | (((value) & \
mask__AUD_SPDIF_CTRL__MEMREAD(ip)) << \
shift__AUD_SPDIF_CTRL__MEMREAD(ip)), ip->base + \
offset__AUD_SPDIF_CTRL(ip))
/*
* AUD_SPDIF_STA
*/
#define offset__AUD_SPDIF_STA(ip) 0x20
#define get__AUD_SPDIF_STA(ip) readl(ip->base + \
offset__AUD_SPDIF_STA(ip))
#define set__AUD_SPDIF_STA(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_STA(ip))
/* RUN_STOP */
#define shift__AUD_SPDIF_STA__RUN_STOP(ip) 0
#define mask__AUD_SPDIF_STA__RUN_STOP(ip) 0x1
#define get__AUD_SPDIF_STA__RUN_STOP(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__RUN_STOP(ip)) & \
mask__AUD_SPDIF_STA__RUN_STOP(ip))
#define set__AUD_SPDIF_STA__RUN_STOP(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__RUN_STOP(ip) << \
shift__AUD_SPDIF_STA__RUN_STOP(ip))) | (((value) & \
mask__AUD_SPDIF_STA__RUN_STOP(ip)) << \
shift__AUD_SPDIF_STA__RUN_STOP(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__RUN_STOP__STOPPED(ip) 0x0
#define mask__AUD_SPDIF_STA__RUN_STOP__STOPPED(ip) \
(value__AUD_SPDIF_STA__RUN_STOP__STOPPED(ip) << \
shift__AUD_SPDIF_STA__RUN_STOP(ip))
#define set__AUD_SPDIF_STA__RUN_STOP__STOPPED(ip) \
set__AUD_SPDIF_STA__RUN_STOP(ip, \
value__AUD_SPDIF_STA__RUN_STOP__STOPPED(ip))
#define value__AUD_SPDIF_STA__RUN_STOP__RUNNING(ip) 0x1
#define mask__AUD_SPDIF_STA__RUN_STOP__RUNNING(ip) \
(value__AUD_SPDIF_STA__RUN_STOP__RUNNING(ip) << \
shift__AUD_SPDIF_STA__RUN_STOP(ip))
#define set__AUD_SPDIF_STA__RUN_STOP__RUNNING(ip) \
set__AUD_SPDIF_STA__RUN_STOP(ip, \
value__AUD_SPDIF_STA__RUN_STOP__RUNNING(ip))
/* UNF */
#define shift__AUD_SPDIF_STA__UNF(ip) 1
#define mask__AUD_SPDIF_STA__UNF(ip) 0x1
#define get__AUD_SPDIF_STA__UNF(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__UNF(ip)) & \
mask__AUD_SPDIF_STA__UNF(ip))
#define set__AUD_SPDIF_STA__UNF(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__UNF(ip) << \
shift__AUD_SPDIF_STA__UNF(ip))) | (((value) & \
mask__AUD_SPDIF_STA__UNF(ip)) << shift__AUD_SPDIF_STA__UNF(ip)), \
ip->base + offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__UNF__DETECTED(ip) 0x1
#define mask__AUD_SPDIF_STA__UNF__DETECTED(ip) \
(value__AUD_SPDIF_STA__UNF__DETECTED(ip) << \
shift__AUD_SPDIF_STA__UNF(ip))
#define set__AUD_SPDIF_STA__UNF__DETECTED(ip) \
set__AUD_SPDIF_STA__UNF(ip, value__AUD_SPDIF_STA__UNF__DETECTED(ip))
/* EOBURST */
#define shift__AUD_SPDIF_STA__EOBURST(ip) 2
#define mask__AUD_SPDIF_STA__EOBURST(ip) 0x1
#define get__AUD_SPDIF_STA__EOBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__EOBURST(ip)) & \
mask__AUD_SPDIF_STA__EOBURST(ip))
#define set__AUD_SPDIF_STA__EOBURST(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__EOBURST(ip) << \
shift__AUD_SPDIF_STA__EOBURST(ip))) | (((value) & \
mask__AUD_SPDIF_STA__EOBURST(ip)) << \
shift__AUD_SPDIF_STA__EOBURST(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__EOBURST__END(ip) 0x1
#define mask__AUD_SPDIF_STA__EOBURST__END(ip) \
(value__AUD_SPDIF_STA__EOBURST__END(ip) << \
shift__AUD_SPDIF_STA__EOBURST(ip))
#define set__AUD_SPDIF_STA__EOBURST__END(ip) \
set__AUD_SPDIF_STA__EOBURST(ip, \
value__AUD_SPDIF_STA__EOBURST__END(ip))
/* EOBLOCK */
#define shift__AUD_SPDIF_STA__EOBLOCK(ip) 3
#define mask__AUD_SPDIF_STA__EOBLOCK(ip) 0x1
#define get__AUD_SPDIF_STA__EOBLOCK(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__EOBLOCK(ip)) & \
mask__AUD_SPDIF_STA__EOBLOCK(ip))
#define set__AUD_SPDIF_STA__EOBLOCK(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__EOBLOCK(ip) << \
shift__AUD_SPDIF_STA__EOBLOCK(ip))) | (((value) & \
mask__AUD_SPDIF_STA__EOBLOCK(ip)) << \
shift__AUD_SPDIF_STA__EOBLOCK(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__EOBLOCK__END(ip) 0x1
#define mask__AUD_SPDIF_STA__EOBLOCK__END(ip) \
(value__AUD_SPDIF_STA__EOBLOCK__END(ip) << \
shift__AUD_SPDIF_STA__EOBLOCK(ip))
#define set__AUD_SPDIF_STA__EOBLOCK__END(ip) \
set__AUD_SPDIF_STA__EOBLOCK(ip, \
value__AUD_SPDIF_STA__EOBLOCK__END(ip))
/* EOLATENCY */
#define shift__AUD_SPDIF_STA__EOLATENCY(ip) 4
#define mask__AUD_SPDIF_STA__EOLATENCY(ip) 0x1
#define get__AUD_SPDIF_STA__EOLATENCY(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__EOLATENCY(ip)) & \
mask__AUD_SPDIF_STA__EOLATENCY(ip))
#define set__AUD_SPDIF_STA__EOLATENCY(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_STA(ip)) & \
~(mask__AUD_SPDIF_STA__EOLATENCY(ip) << \
shift__AUD_SPDIF_STA__EOLATENCY(ip))) | (((value) & \
mask__AUD_SPDIF_STA__EOLATENCY(ip)) << \
shift__AUD_SPDIF_STA__EOLATENCY(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__EOLATENCY__END_OF_LATENCY_COUNTER(ip) \
0x1
#define mask__AUD_SPDIF_STA__EOLATENCY__END_OF_LATENCY_COUNTER(ip) \
(value__AUD_SPDIF_STA__EOLATENCY__END_OF_LATENCY_COUNTER(ip) << \
shift__AUD_SPDIF_STA__EOLATENCY(ip))
#define set__AUD_SPDIF_STA__EOLATENCY__END_OF_LATENCY_COUNTER(ip) \
set__AUD_SPDIF_STA__EOLATENCY(ip, \
value__AUD_SPDIF_STA__EOLATENCY__END_OF_LATENCY_COUNTER(ip))
/* PDDATA */
#define shift__AUD_SPDIF_STA__PDDATA(ip) 5
#define mask__AUD_SPDIF_STA__PDDATA(ip) 0x1
#define get__AUD_SPDIF_STA__PDDATA(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__PDDATA(ip)) & \
mask__AUD_SPDIF_STA__PDDATA(ip))
#define set__AUD_SPDIF_STA__PDDATA(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__PDDATA(ip) << \
shift__AUD_SPDIF_STA__PDDATA(ip))) | (((value) & \
mask__AUD_SPDIF_STA__PDDATA(ip)) << shift__AUD_SPDIF_STA__PDDATA(ip)), \
ip->base + offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__PDDATA__SENT(ip) 0x1
#define mask__AUD_SPDIF_STA__PDDATA__SENT(ip) \
(value__AUD_SPDIF_STA__PDDATA__SENT(ip) << \
shift__AUD_SPDIF_STA__PDDATA(ip))
#define set__AUD_SPDIF_STA__PDDATA__SENT(ip) \
set__AUD_SPDIF_STA__PDDATA(ip, value__AUD_SPDIF_STA__PDDATA__SENT(ip))
/* NSAMPLE */
#define shift__AUD_SPDIF_STA__NSAMPLE(ip) 6
#define mask__AUD_SPDIF_STA__NSAMPLE(ip) 0x1
#define get__AUD_SPDIF_STA__NSAMPLE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__NSAMPLE(ip)) & \
mask__AUD_SPDIF_STA__NSAMPLE(ip))
#define set__AUD_SPDIF_STA__NSAMPLE(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__NSAMPLE(ip) << \
shift__AUD_SPDIF_STA__NSAMPLE(ip))) | (((value) & \
mask__AUD_SPDIF_STA__NSAMPLE(ip)) << \
shift__AUD_SPDIF_STA__NSAMPLE(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__NSAMPLE__DONE(ip) 0x1
#define mask__AUD_SPDIF_STA__NSAMPLE__DONE(ip) \
(value__AUD_SPDIF_STA__NSAMPLE__DONE(ip) << \
shift__AUD_SPDIF_STA__NSAMPLE(ip))
#define set__AUD_SPDIF_STA__NSAMPLE__DONE(ip) \
set__AUD_SPDIF_STA__NSAMPLE(ip, \
value__AUD_SPDIF_STA__NSAMPLE__DONE(ip))
/* PABIT */
#define shift__AUD_SPDIF_STA__PABIT(ip) 7
#define mask__AUD_SPDIF_STA__PABIT(ip) 0xff
#define get__AUD_SPDIF_STA__PABIT(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__PABIT(ip)) & \
mask__AUD_SPDIF_STA__PABIT(ip))
#define set__AUD_SPDIF_STA__PABIT(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__PABIT(ip) << \
shift__AUD_SPDIF_STA__PABIT(ip))) | (((value) & \
mask__AUD_SPDIF_STA__PABIT(ip)) << shift__AUD_SPDIF_STA__PABIT(ip)), \
ip->base + offset__AUD_SPDIF_STA(ip))
/* PDPAUSE */
#define shift__AUD_SPDIF_STA__PDPAUSE(ip) 15
#define mask__AUD_SPDIF_STA__PDPAUSE(ip) 0x1
#define get__AUD_SPDIF_STA__PDPAUSE(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> shift__AUD_SPDIF_STA__PDPAUSE(ip)) & \
mask__AUD_SPDIF_STA__PDPAUSE(ip))
#define set__AUD_SPDIF_STA__PDPAUSE(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_STA(ip)) & ~(mask__AUD_SPDIF_STA__PDPAUSE(ip) << \
shift__AUD_SPDIF_STA__PDPAUSE(ip))) | (((value) & \
mask__AUD_SPDIF_STA__PDPAUSE(ip)) << \
shift__AUD_SPDIF_STA__PDPAUSE(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
#define value__AUD_SPDIF_STA__PDPAUSE__SENT(ip) 0x1
#define mask__AUD_SPDIF_STA__PDPAUSE__SENT(ip) \
(value__AUD_SPDIF_STA__PDPAUSE__SENT(ip) << \
shift__AUD_SPDIF_STA__PDPAUSE(ip))
#define set__AUD_SPDIF_STA__PDPAUSE__SENT(ip) \
set__AUD_SPDIF_STA__PDPAUSE(ip, \
value__AUD_SPDIF_STA__PDPAUSE__SENT(ip))
/* SAMPLES_IN_FIFO */
#define shift__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip) (ip->ver < \
4 ? -1 : 16)
#define mask__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip) (ip->ver < \
4 ? -1 : 0x1f)
#define get__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip) ((readl(ip->base + \
offset__AUD_SPDIF_STA(ip)) >> \
shift__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip)) & \
mask__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip))
#define set__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_STA(ip)) & \
~(mask__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip) << \
shift__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip))) | (((value) & \
mask__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip)) << \
shift__AUD_SPDIF_STA__SAMPLES_IN_FIFO(ip)), ip->base + \
offset__AUD_SPDIF_STA(ip))
/*
* AUD_SPDIF_PA_PB
*/
#define offset__AUD_SPDIF_PA_PB(ip) 0x24
#define get__AUD_SPDIF_PA_PB(ip) readl(ip->base + \
offset__AUD_SPDIF_PA_PB(ip))
#define set__AUD_SPDIF_PA_PB(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_PA_PB(ip))
/* PB */
#define shift__AUD_SPDIF_PA_PB__PB(ip) 0
#define mask__AUD_SPDIF_PA_PB__PB(ip) 0xffff
#define get__AUD_SPDIF_PA_PB__PB(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PA_PB(ip)) >> shift__AUD_SPDIF_PA_PB__PB(ip)) & \
mask__AUD_SPDIF_PA_PB__PB(ip))
#define set__AUD_SPDIF_PA_PB__PB(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_PA_PB(ip)) & ~(mask__AUD_SPDIF_PA_PB__PB(ip) << \
shift__AUD_SPDIF_PA_PB__PB(ip))) | (((value) & \
mask__AUD_SPDIF_PA_PB__PB(ip)) << shift__AUD_SPDIF_PA_PB__PB(ip)), \
ip->base + offset__AUD_SPDIF_PA_PB(ip))
/* PA */
#define shift__AUD_SPDIF_PA_PB__PA(ip) 16
#define mask__AUD_SPDIF_PA_PB__PA(ip) 0xffff
#define get__AUD_SPDIF_PA_PB__PA(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PA_PB(ip)) >> shift__AUD_SPDIF_PA_PB__PA(ip)) & \
mask__AUD_SPDIF_PA_PB__PA(ip))
#define set__AUD_SPDIF_PA_PB__PA(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_PA_PB(ip)) & ~(mask__AUD_SPDIF_PA_PB__PA(ip) << \
shift__AUD_SPDIF_PA_PB__PA(ip))) | (((value) & \
mask__AUD_SPDIF_PA_PB__PA(ip)) << shift__AUD_SPDIF_PA_PB__PA(ip)), \
ip->base + offset__AUD_SPDIF_PA_PB(ip))
/*
* AUD_SPDIF_PC_PD
*/
#define offset__AUD_SPDIF_PC_PD(ip) 0x28
#define get__AUD_SPDIF_PC_PD(ip) readl(ip->base + \
offset__AUD_SPDIF_PC_PD(ip))
#define set__AUD_SPDIF_PC_PD(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_PC_PD(ip))
/* PD */
#define shift__AUD_SPDIF_PC_PD__PD(ip) 0
#define mask__AUD_SPDIF_PC_PD__PD(ip) 0xffff
#define get__AUD_SPDIF_PC_PD__PD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PC_PD(ip)) >> shift__AUD_SPDIF_PC_PD__PD(ip)) & \
mask__AUD_SPDIF_PC_PD__PD(ip))
#define set__AUD_SPDIF_PC_PD__PD(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_PC_PD(ip)) & ~(mask__AUD_SPDIF_PC_PD__PD(ip) << \
shift__AUD_SPDIF_PC_PD__PD(ip))) | (((value) & \
mask__AUD_SPDIF_PC_PD__PD(ip)) << shift__AUD_SPDIF_PC_PD__PD(ip)), \
ip->base + offset__AUD_SPDIF_PC_PD(ip))
/* PC */
#define shift__AUD_SPDIF_PC_PD__PC(ip) 16
#define mask__AUD_SPDIF_PC_PD__PC(ip) 0xffff
#define get__AUD_SPDIF_PC_PD__PC(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PC_PD(ip)) >> shift__AUD_SPDIF_PC_PD__PC(ip)) & \
mask__AUD_SPDIF_PC_PD__PC(ip))
#define set__AUD_SPDIF_PC_PD__PC(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_PC_PD(ip)) & ~(mask__AUD_SPDIF_PC_PD__PC(ip) << \
shift__AUD_SPDIF_PC_PD__PC(ip))) | (((value) & \
mask__AUD_SPDIF_PC_PD__PC(ip)) << shift__AUD_SPDIF_PC_PD__PC(ip)), \
ip->base + offset__AUD_SPDIF_PC_PD(ip))
/*
* AUD_SPDIF_CL1
*/
#define offset__AUD_SPDIF_CL1(ip) 0x2c
#define get__AUD_SPDIF_CL1(ip) readl(ip->base + \
offset__AUD_SPDIF_CL1(ip))
#define set__AUD_SPDIF_CL1(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_CL1(ip))
/* CL1 */
#define shift__AUD_SPDIF_CL1__CL1(ip) 0
#define mask__AUD_SPDIF_CL1__CL1(ip) 0xffffffff
#define get__AUD_SPDIF_CL1__CL1(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL1(ip)) >> shift__AUD_SPDIF_CL1__CL1(ip)) & \
mask__AUD_SPDIF_CL1__CL1(ip))
#define set__AUD_SPDIF_CL1__CL1(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_CL1(ip)) & ~(mask__AUD_SPDIF_CL1__CL1(ip) << \
shift__AUD_SPDIF_CL1__CL1(ip))) | (((value) & \
mask__AUD_SPDIF_CL1__CL1(ip)) << shift__AUD_SPDIF_CL1__CL1(ip)), \
ip->base + offset__AUD_SPDIF_CL1(ip))
/*
* AUD_SPDIF_CR1
*/
#define offset__AUD_SPDIF_CR1(ip) 0x30
#define get__AUD_SPDIF_CR1(ip) readl(ip->base + \
offset__AUD_SPDIF_CR1(ip))
#define set__AUD_SPDIF_CR1(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_CR1(ip))
/* CR1 */
#define shift__AUD_SPDIF_CR1__CR1(ip) 0
#define mask__AUD_SPDIF_CR1__CR1(ip) 0xffffffff
#define get__AUD_SPDIF_CR1__CR1(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CR1(ip)) >> shift__AUD_SPDIF_CR1__CR1(ip)) & \
mask__AUD_SPDIF_CR1__CR1(ip))
#define set__AUD_SPDIF_CR1__CR1(ip, value) writel((readl(ip->base + \
offset__AUD_SPDIF_CR1(ip)) & ~(mask__AUD_SPDIF_CR1__CR1(ip) << \
shift__AUD_SPDIF_CR1__CR1(ip))) | (((value) & \
mask__AUD_SPDIF_CR1__CR1(ip)) << shift__AUD_SPDIF_CR1__CR1(ip)), \
ip->base + offset__AUD_SPDIF_CR1(ip))
/*
* AUD_SPDIF_CL2_CR2_UV
*/
#define offset__AUD_SPDIF_CL2_CR2_UV(ip) 0x34
#define get__AUD_SPDIF_CL2_CR2_UV(ip) readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
#define set__AUD_SPDIF_CL2_CR2_UV(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* CL2 */
#define shift__AUD_SPDIF_CL2_CR2_UV__CL2(ip) 0
#define mask__AUD_SPDIF_CL2_CR2_UV__CL2(ip) 0xf
#define get__AUD_SPDIF_CL2_CR2_UV__CL2(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__CL2(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__CL2(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__CL2(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__CL2(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__CL2(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__CL2(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__CL2(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* CR2 */
#define shift__AUD_SPDIF_CL2_CR2_UV__CR2(ip) 8
#define mask__AUD_SPDIF_CL2_CR2_UV__CR2(ip) 0xf
#define get__AUD_SPDIF_CL2_CR2_UV__CR2(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__CR2(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__CR2(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__CR2(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__CR2(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__CR2(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__CR2(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__CR2(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* LU */
#define shift__AUD_SPDIF_CL2_CR2_UV__LU(ip) 16
#define mask__AUD_SPDIF_CL2_CR2_UV__LU(ip) 0x1
#define get__AUD_SPDIF_CL2_CR2_UV__LU(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__LU(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__LU(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__LU(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__LU(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__LU(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__LU(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__LU(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* RU */
#define shift__AUD_SPDIF_CL2_CR2_UV__RU(ip) 17
#define mask__AUD_SPDIF_CL2_CR2_UV__RU(ip) 0x1
#define get__AUD_SPDIF_CL2_CR2_UV__RU(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__RU(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__RU(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__RU(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__RU(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__RU(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__RU(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__RU(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* LV */
#define shift__AUD_SPDIF_CL2_CR2_UV__LV(ip) 18
#define mask__AUD_SPDIF_CL2_CR2_UV__LV(ip) 0x1
#define get__AUD_SPDIF_CL2_CR2_UV__LV(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__LV(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__LV(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__LV(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__LV(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__LV(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__LV(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__LV(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/* RV */
#define shift__AUD_SPDIF_CL2_CR2_UV__RV(ip) 19
#define mask__AUD_SPDIF_CL2_CR2_UV__RV(ip) 0x1
#define get__AUD_SPDIF_CL2_CR2_UV__RV(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip)) >> \
shift__AUD_SPDIF_CL2_CR2_UV__RV(ip)) & \
mask__AUD_SPDIF_CL2_CR2_UV__RV(ip))
#define set__AUD_SPDIF_CL2_CR2_UV__RV(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CL2_CR2_UV(ip)) & \
~(mask__AUD_SPDIF_CL2_CR2_UV__RV(ip) << \
shift__AUD_SPDIF_CL2_CR2_UV__RV(ip))) | (((value) & \
mask__AUD_SPDIF_CL2_CR2_UV__RV(ip)) << \
shift__AUD_SPDIF_CL2_CR2_UV__RV(ip)), ip->base + \
offset__AUD_SPDIF_CL2_CR2_UV(ip))
/*
* AUD_SPDIF_PAU_LAT
*/
#define offset__AUD_SPDIF_PAU_LAT(ip) 0x38
#define get__AUD_SPDIF_PAU_LAT(ip) readl(ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip))
#define set__AUD_SPDIF_PAU_LAT(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip))
/* LAT */
#define shift__AUD_SPDIF_PAU_LAT__LAT(ip) 0
#define mask__AUD_SPDIF_PAU_LAT__LAT(ip) 0xffff
#define get__AUD_SPDIF_PAU_LAT__LAT(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip)) >> shift__AUD_SPDIF_PAU_LAT__LAT(ip)) & \
mask__AUD_SPDIF_PAU_LAT__LAT(ip))
#define set__AUD_SPDIF_PAU_LAT__LAT(ip, value) writel((readl(ip->base \
+ offset__AUD_SPDIF_PAU_LAT(ip)) & ~(mask__AUD_SPDIF_PAU_LAT__LAT(ip) \
<< shift__AUD_SPDIF_PAU_LAT__LAT(ip))) | (((value) & \
mask__AUD_SPDIF_PAU_LAT__LAT(ip)) << \
shift__AUD_SPDIF_PAU_LAT__LAT(ip)), ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip))
/* NPD_BURST */
#define shift__AUD_SPDIF_PAU_LAT__NPD_BURST(ip) 16
#define mask__AUD_SPDIF_PAU_LAT__NPD_BURST(ip) 0xffff
#define get__AUD_SPDIF_PAU_LAT__NPD_BURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip)) >> \
shift__AUD_SPDIF_PAU_LAT__NPD_BURST(ip)) & \
mask__AUD_SPDIF_PAU_LAT__NPD_BURST(ip))
#define set__AUD_SPDIF_PAU_LAT__NPD_BURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_PAU_LAT(ip)) & \
~(mask__AUD_SPDIF_PAU_LAT__NPD_BURST(ip) << \
shift__AUD_SPDIF_PAU_LAT__NPD_BURST(ip))) | (((value) & \
mask__AUD_SPDIF_PAU_LAT__NPD_BURST(ip)) << \
shift__AUD_SPDIF_PAU_LAT__NPD_BURST(ip)), ip->base + \
offset__AUD_SPDIF_PAU_LAT(ip))
/*
* AUD_SPDIF_BST_FL
*/
#define offset__AUD_SPDIF_BST_FL(ip) 0x3c
#define get__AUD_SPDIF_BST_FL(ip) readl(ip->base + \
offset__AUD_SPDIF_BST_FL(ip))
#define set__AUD_SPDIF_BST_FL(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_BST_FL(ip))
/* PDBURST */
#define shift__AUD_SPDIF_BST_FL__PDBURST(ip) 0
#define mask__AUD_SPDIF_BST_FL__PDBURST(ip) 0xffff
#define get__AUD_SPDIF_BST_FL__PDBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_BST_FL(ip)) >> shift__AUD_SPDIF_BST_FL__PDBURST(ip)) \
& mask__AUD_SPDIF_BST_FL__PDBURST(ip))
#define set__AUD_SPDIF_BST_FL__PDBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_BST_FL(ip)) & \
~(mask__AUD_SPDIF_BST_FL__PDBURST(ip) << \
shift__AUD_SPDIF_BST_FL__PDBURST(ip))) | (((value) & \
mask__AUD_SPDIF_BST_FL__PDBURST(ip)) << \
shift__AUD_SPDIF_BST_FL__PDBURST(ip)), ip->base + \
offset__AUD_SPDIF_BST_FL(ip))
/* DBURST */
#define shift__AUD_SPDIF_BST_FL__DBURST(ip) 16
#define mask__AUD_SPDIF_BST_FL__DBURST(ip) 0xffff
#define get__AUD_SPDIF_BST_FL__DBURST(ip) ((readl(ip->base + \
offset__AUD_SPDIF_BST_FL(ip)) >> shift__AUD_SPDIF_BST_FL__DBURST(ip)) \
& mask__AUD_SPDIF_BST_FL__DBURST(ip))
#define set__AUD_SPDIF_BST_FL__DBURST(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_BST_FL(ip)) & \
~(mask__AUD_SPDIF_BST_FL__DBURST(ip) << \
shift__AUD_SPDIF_BST_FL__DBURST(ip))) | (((value) & \
mask__AUD_SPDIF_BST_FL__DBURST(ip)) << \
shift__AUD_SPDIF_BST_FL__DBURST(ip)), ip->base + \
offset__AUD_SPDIF_BST_FL(ip))
/*
* AUD_SPDIF_CONFIG
*/
#define offset__AUD_SPDIF_CONFIG(ip) (ip->ver < 4 \
? -1 : 0x40)
#define get__AUD_SPDIF_CONFIG(ip) readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#define set__AUD_SPDIF_CONFIG(ip, value) writel(value, ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
/* P_BIT */
#define shift__AUD_SPDIF_CONFIG__P_BIT(ip) (ip->ver < \
4 ? -1 : 0)
#define value__AUD_SPDIF_CONFIG__P_BIT__MASK(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__P_BIT__MASK(ip) \
(value__AUD_SPDIF_CONFIG__P_BIT__MASK(ip) << \
shift__AUD_SPDIF_CONFIG__P_BIT(ip))
#define set__AUD_SPDIF_CONFIG__P_BIT__MASK(ip) \
set__AUD_SPDIF_CONFIG__P_BIT(ip, \
value__AUD_SPDIF_CONFIG__P_BIT__MASK(ip))
#define value__AUD_SPDIF_CONFIG__P_BIT__HW(ip) (ip->ver < \
4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__P_BIT__HW(ip) \
(value__AUD_SPDIF_CONFIG__P_BIT__HW(ip) << \
shift__AUD_SPDIF_CONFIG__P_BIT(ip))
#define set__AUD_SPDIF_CONFIG__P_BIT__HW(ip) \
set__AUD_SPDIF_CONFIG__P_BIT(ip, \
value__AUD_SPDIF_CONFIG__P_BIT__HW(ip))
#define value__AUD_SPDIF_CONFIG__P_BIT__FDMA(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__P_BIT__FDMA(ip) \
(value__AUD_SPDIF_CONFIG__P_BIT__FDMA(ip) << \
shift__AUD_SPDIF_CONFIG__P_BIT(ip))
#define set__AUD_SPDIF_CONFIG__P_BIT__FDMA(ip) \
set__AUD_SPDIF_CONFIG__P_BIT(ip, \
value__AUD_SPDIF_CONFIG__P_BIT__FDMA(ip))
/* C_BIT */
#define shift__AUD_SPDIF_CONFIG__C_BIT(ip) (ip->ver < \
4 ? -1 : 1)
#define value__AUD_SPDIF_CONFIG__C_BIT__MASK(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__C_BIT__MASK(ip) \
(value__AUD_SPDIF_CONFIG__C_BIT__MASK(ip) << \
shift__AUD_SPDIF_CONFIG__C_BIT(ip))
#define set__AUD_SPDIF_CONFIG__C_BIT__MASK(ip) \
set__AUD_SPDIF_CONFIG__C_BIT(ip, \
value__AUD_SPDIF_CONFIG__C_BIT__MASK(ip))
#define value__AUD_SPDIF_CONFIG__C_BIT__FDMA(ip) (ip->ver < \
4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__C_BIT__FDMA(ip) \
(value__AUD_SPDIF_CONFIG__C_BIT__FDMA(ip) << \
shift__AUD_SPDIF_CONFIG__C_BIT(ip))
#define set__AUD_SPDIF_CONFIG__C_BIT__FDMA(ip) \
set__AUD_SPDIF_CONFIG__C_BIT(ip, \
value__AUD_SPDIF_CONFIG__C_BIT__FDMA(ip))
#define value__AUD_SPDIF_CONFIG__C_BIT__HW(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__C_BIT__HW(ip) \
(value__AUD_SPDIF_CONFIG__C_BIT__HW(ip) << \
shift__AUD_SPDIF_CONFIG__C_BIT(ip))
#define set__AUD_SPDIF_CONFIG__C_BIT__HW(ip) \
set__AUD_SPDIF_CONFIG__C_BIT(ip, \
value__AUD_SPDIF_CONFIG__C_BIT__HW(ip))
/* U_BIT */
#define shift__AUD_SPDIF_CONFIG__U_BIT(ip) (ip->ver < \
4 ? -1 : 2)
#define value__AUD_SPDIF_CONFIG__U_BIT__MASK(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__U_BIT__MASK(ip) \
(value__AUD_SPDIF_CONFIG__U_BIT__MASK(ip) << \
shift__AUD_SPDIF_CONFIG__U_BIT(ip))
#define set__AUD_SPDIF_CONFIG__U_BIT__MASK(ip) \
set__AUD_SPDIF_CONFIG__U_BIT(ip, \
value__AUD_SPDIF_CONFIG__U_BIT__MASK(ip))
#define value__AUD_SPDIF_CONFIG__U_BIT__FDMA(ip) (ip->ver < \
4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__U_BIT__FDMA(ip) \
(value__AUD_SPDIF_CONFIG__U_BIT__FDMA(ip) << \
shift__AUD_SPDIF_CONFIG__U_BIT(ip))
#define set__AUD_SPDIF_CONFIG__U_BIT__FDMA(ip) \
set__AUD_SPDIF_CONFIG__U_BIT(ip, \
value__AUD_SPDIF_CONFIG__U_BIT__FDMA(ip))
#define value__AUD_SPDIF_CONFIG__U_BIT__HW(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__U_BIT__HW(ip) \
(value__AUD_SPDIF_CONFIG__U_BIT__HW(ip) << \
shift__AUD_SPDIF_CONFIG__U_BIT(ip))
#define set__AUD_SPDIF_CONFIG__U_BIT__HW(ip) \
set__AUD_SPDIF_CONFIG__U_BIT(ip, \
value__AUD_SPDIF_CONFIG__U_BIT__HW(ip))
/* V_BIT */
#define shift__AUD_SPDIF_CONFIG__V_BIT(ip) (ip->ver < \
4 ? -1 : 2)
#define value__AUD_SPDIF_CONFIG__V_BIT__MASK(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__V_BIT__MASK(ip) \
(value__AUD_SPDIF_CONFIG__V_BIT__MASK(ip) << \
shift__AUD_SPDIF_CONFIG__V_BIT(ip))
#define set__AUD_SPDIF_CONFIG__V_BIT__MASK(ip) \
set__AUD_SPDIF_CONFIG__V_BIT(ip, \
value__AUD_SPDIF_CONFIG__V_BIT__MASK(ip))
#define value__AUD_SPDIF_CONFIG__V_BIT__FDMA(ip) (ip->ver < \
4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__V_BIT__FDMA(ip) \
(value__AUD_SPDIF_CONFIG__V_BIT__FDMA(ip) << \
shift__AUD_SPDIF_CONFIG__V_BIT(ip))
#define set__AUD_SPDIF_CONFIG__V_BIT__FDMA(ip) \
set__AUD_SPDIF_CONFIG__V_BIT(ip, \
value__AUD_SPDIF_CONFIG__V_BIT__FDMA(ip))
#define value__AUD_SPDIF_CONFIG__V_BIT__HW(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__V_BIT__HW(ip) \
(value__AUD_SPDIF_CONFIG__V_BIT__HW(ip) << \
shift__AUD_SPDIF_CONFIG__V_BIT(ip))
#define set__AUD_SPDIF_CONFIG__V_BIT__HW(ip) \
set__AUD_SPDIF_CONFIG__V_BIT(ip, \
value__AUD_SPDIF_CONFIG__V_BIT__HW(ip))
/* ONE_BIT_AUDIO */
#define shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip) (ip->ver < \
4 ? -1 : 4)
#define mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip) (ip->ver < \
4 ? -1 : 0x1)
#define get__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip)) >> \
shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip)) & \
mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip))
#define set__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CONFIG(ip)) & \
~(mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip) << \
shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip))) | (((value) & \
mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip)) << \
shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip)), ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#define value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__DISABLED(ip) (ip->ver \
< 4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__DISABLED(ip) \
(value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__DISABLED(ip) << \
shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip))
#define set__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__DISABLED(ip) \
set__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip, \
value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__DISABLED(ip))
#define value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__ENABLED(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__ENABLED(ip) \
(value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__ENABLED(ip) << \
shift__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip))
#define set__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__ENABLED(ip) \
set__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO(ip, \
value__AUD_SPDIF_CONFIG__ONE_BIT_AUDIO__ENABLED(ip))
/* MEM_FMT */
#define shift__AUD_SPDIF_CONFIG__MEM_FMT(ip) (ip->ver < \
4 ? -1 : 5)
#define mask__AUD_SPDIF_CONFIG__MEM_FMT(ip) (ip->ver < \
4 ? -1 : 0x1)
#define get__AUD_SPDIF_CONFIG__MEM_FMT(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip)) >> shift__AUD_SPDIF_CONFIG__MEM_FMT(ip)) \
& mask__AUD_SPDIF_CONFIG__MEM_FMT(ip))
#define set__AUD_SPDIF_CONFIG__MEM_FMT(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CONFIG(ip)) & \
~(mask__AUD_SPDIF_CONFIG__MEM_FMT(ip) << \
shift__AUD_SPDIF_CONFIG__MEM_FMT(ip))) | (((value) & \
mask__AUD_SPDIF_CONFIG__MEM_FMT(ip)) << \
shift__AUD_SPDIF_CONFIG__MEM_FMT(ip)), ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#define value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_0_BITS(ip) (ip->ver \
< 4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_0_BITS(ip) \
(value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_0_BITS(ip) << \
shift__AUD_SPDIF_CONFIG__MEM_FMT(ip))
#define set__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_0_BITS(ip) \
set__AUD_SPDIF_CONFIG__MEM_FMT(ip, \
value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_0_BITS(ip))
#define value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_16_BITS(ip) (ip->ver \
< 4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_16_BITS(ip) \
(value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_16_BITS(ip) << \
shift__AUD_SPDIF_CONFIG__MEM_FMT(ip))
#define set__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_16_BITS(ip) \
set__AUD_SPDIF_CONFIG__MEM_FMT(ip, \
value__AUD_SPDIF_CONFIG__MEM_FMT__16_BITS_16_BITS(ip))
/* DTS_HD */
#define shift__AUD_SPDIF_CONFIG__DTS_HD(ip) (ip->ver < \
4 ? -1 : 6)
#define mask__AUD_SPDIF_CONFIG__DTS_HD(ip) (ip->ver < \
4 ? -1 : 0x1)
#define get__AUD_SPDIF_CONFIG__DTS_HD(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip)) >> shift__AUD_SPDIF_CONFIG__DTS_HD(ip)) \
& mask__AUD_SPDIF_CONFIG__DTS_HD(ip))
#define set__AUD_SPDIF_CONFIG__DTS_HD(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CONFIG(ip)) & \
~(mask__AUD_SPDIF_CONFIG__DTS_HD(ip) << \
shift__AUD_SPDIF_CONFIG__DTS_HD(ip))) | (((value) & \
mask__AUD_SPDIF_CONFIG__DTS_HD(ip)) << \
shift__AUD_SPDIF_CONFIG__DTS_HD(ip)), ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#define value__AUD_SPDIF_CONFIG__DTS_HD__DISABLED(ip) (ip->ver < \
4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__DTS_HD__DISABLED(ip) \
(value__AUD_SPDIF_CONFIG__DTS_HD__DISABLED(ip) << \
shift__AUD_SPDIF_CONFIG__DTS_HD(ip))
#define set__AUD_SPDIF_CONFIG__DTS_HD__DISABLED(ip) \
set__AUD_SPDIF_CONFIG__DTS_HD(ip, \
value__AUD_SPDIF_CONFIG__DTS_HD__DISABLED(ip))
#define value__AUD_SPDIF_CONFIG__DTS_HD__ENABLED(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__DTS_HD__ENABLED(ip) \
(value__AUD_SPDIF_CONFIG__DTS_HD__ENABLED(ip) << \
shift__AUD_SPDIF_CONFIG__DTS_HD(ip))
#define set__AUD_SPDIF_CONFIG__DTS_HD__ENABLED(ip) \
set__AUD_SPDIF_CONFIG__DTS_HD(ip, \
value__AUD_SPDIF_CONFIG__DTS_HD__ENABLED(ip))
/* BACK_STALLING */
#define shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip) (ip->ver < \
4 ? -1 : 7)
#define mask__AUD_SPDIF_CONFIG__BACK_STALLING(ip) (ip->ver < \
4 ? -1 : 0x1)
#define get__AUD_SPDIF_CONFIG__BACK_STALLING(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip)) >> \
shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip)) & \
mask__AUD_SPDIF_CONFIG__BACK_STALLING(ip))
#define set__AUD_SPDIF_CONFIG__BACK_STALLING(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CONFIG(ip)) & \
~(mask__AUD_SPDIF_CONFIG__BACK_STALLING(ip) << \
shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip))) | (((value) & \
mask__AUD_SPDIF_CONFIG__BACK_STALLING(ip)) << \
shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip)), ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#define value__AUD_SPDIF_CONFIG__BACK_STALLING__DISABLED(ip) (ip->ver \
< 4 ? -1 : 0x0)
#define mask__AUD_SPDIF_CONFIG__BACK_STALLING__DISABLED(ip) \
(value__AUD_SPDIF_CONFIG__BACK_STALLING__DISABLED(ip) << \
shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip))
#define set__AUD_SPDIF_CONFIG__BACK_STALLING__DISABLED(ip) \
set__AUD_SPDIF_CONFIG__BACK_STALLING(ip, \
value__AUD_SPDIF_CONFIG__BACK_STALLING__DISABLED(ip))
#define value__AUD_SPDIF_CONFIG__BACK_STALLING__ENABLED(ip) (ip->ver < \
4 ? -1 : 0x1)
#define mask__AUD_SPDIF_CONFIG__BACK_STALLING__ENABLED(ip) \
(value__AUD_SPDIF_CONFIG__BACK_STALLING__ENABLED(ip) << \
shift__AUD_SPDIF_CONFIG__BACK_STALLING(ip))
#define set__AUD_SPDIF_CONFIG__BACK_STALLING__ENABLED(ip) \
set__AUD_SPDIF_CONFIG__BACK_STALLING(ip, \
value__AUD_SPDIF_CONFIG__BACK_STALLING__ENABLED(ip))
/* DMA_REQ_TRIG_LMT */
#define shift__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip) (ip->ver < \
4 ? -1 : 8)
#define mask__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip) (ip->ver < \
4 ? -1 : 0x1f)
#define get__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip) ((readl(ip->base + \
offset__AUD_SPDIF_CONFIG(ip)) >> \
shift__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip)) & \
mask__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip))
#define set__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip, value) \
writel((readl(ip->base + offset__AUD_SPDIF_CONFIG(ip)) & \
~(mask__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip) << \
shift__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip))) | (((value) & \
mask__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip)) << \
shift__AUD_SPDIF_CONFIG__DMA_REQ_TRIG_LMT(ip)), ip->base + \
offset__AUD_SPDIF_CONFIG(ip))
#endif
Reference in New Issue Copy Permalink