int tsif_control_open(struct inode *inode, struct file *file)
{
unsigned int index, minor = iminor(inode);
struct tsif_control_dev *tsif_dev;
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
tsif_dev->tsif_clk = clk_get(NULL, *(tsif_clk_name + index));
if (IS_ERR(tsif_dev->tsif_clk)) {
printk(KERN_ERR "Cannot get TSIF clock\n");
return -1;
}
clk_enable(tsif_dev->tsif_clk);
tsif_int_status = 0;
davinci_writel(0x00000001, tsif_dev->base + EMULATION_CTRL);
/* Enable the interrupt to arm */
davinci_writel((davinci_readl(tsif_dev->base + CTRL1) | 0x8000),
tsif_dev->base + CTRL1);
return 0;
}
/* Enable or disable a PSC domain */
void davinci_psc_config(unsigned int domain, unsigned int id, char enable)
{
u32 epcpr, ptcmd, ptstat, pdstat, pdctl1, mdstat, mdctl, mdstat_mask;
if (id < 0)
return;
mdctl = davinci_readl(MDCTL + 4 * id);
if (enable)
mdctl |= 0x00000003; /* Enable Module */
else
mdctl &= 0xFFFFFFF2; /* Disable Module */
davinci_writel(mdctl, MDCTL + 4 * id);
pdstat = davinci_readl(PDSTAT);
if ((pdstat & 0x00000001) == 0) {
pdctl1 = davinci_readl(PDCTL1);
pdctl1 |= 0x1;
davinci_writel(pdctl1, PDCTL1);
ptcmd = 1 << domain;
davinci_writel(ptcmd, PTCMD);
do {
epcpr = davinci_readl(EPCPR);
} while ((((epcpr >> domain) & 1) == 0));
pdctl1 = davinci_readl(PDCTL1);
pdctl1 |= 0x100;
davinci_writel(pdctl1, PDCTL1);
do {
ptstat = davinci_readl(PTSTAT);
} while (!(((ptstat >> domain) & 1) == 0));
} else {
static void davinci_psc_mux(unsigned int id)
{
switch (id) {
case DAVINCI_LPSC_ATA:
davinci_mux_peripheral(DAVINCI_MUX_HDIREN, 1);
davinci_mux_peripheral(DAVINCI_MUX_ATAEN, 1);
break;
case DAVINCI_LPSC_MMC_SD:
/* VDD power manupulations are done in U-Boot for CPMAC
* so applies to MMC as well
*/
/*Set up the pull regiter for MMC */
davinci_writel(0, VDD3P3V_PWDN);
davinci_mux_peripheral(DAVINCI_MUX_MSTK, 0);
break;
case DAVINCI_LPSC_I2C:
davinci_mux_peripheral(DAVINCI_MUX_I2C, 1);
break;
case DAVINCI_LPSC_McBSP:
davinci_mux_peripheral(DAVINCI_MUX_ASP, 1);
break;
default:
break;
}
}
static void board_init(void)
{
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_VPSSMSTR, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_VPSSSLV, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPCC, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPTC0, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TPTC1, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_GPIO, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_McBSP1, 1);
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_SPI, 1);
/* Turn on WatchDog timer LPSC. Needed for RESET to work */
board_setup_psc(DAVINCI_GPSC_ARMDOMAIN, DAVINCI_LPSC_TIMER2, 1);
davinci_serial_init(&serial_device);
davinci_writel(0x56837210, DAVINCI_VPSS_REGS_BASE + 0x810);
davinci_writel(0x7b3c0004, DAVINCI_VPSS_REGS_BASE + 0x814);
}
/*
* Sets the DAVINCI MUX register based on the table
*/
int __init_or_module davinci_cfg_reg(const unsigned long index)
{
static DEFINE_SPINLOCK(mux_spin_lock);
unsigned long flags;
struct pin_config *cfg;
unsigned int reg_orig = 0, reg = 0;
unsigned int mask, warn = 0;
if (!pin_table)
BUG();
if (index >= pin_table_sz) {
printk(KERN_ERR "Invalid pin mux index: %lu (%lu)\n",
index, pin_table_sz);
dump_stack();
return -ENODEV;
}
cfg = (struct pin_config *)&pin_table[index];
/* Check the mux register in question */
if (cfg->mux_reg) {
unsigned tmp1, tmp2;
spin_lock_irqsave(&mux_spin_lock, flags);
reg_orig = davinci_readl(cfg->mux_reg);
mask = (cfg->mask << cfg->mask_offset);
tmp1 = reg_orig & mask;
reg = reg_orig & ~mask;
tmp2 = (cfg->mode << cfg->mask_offset);
reg |= tmp2;
if (tmp1 != tmp2)
warn = 1;
davinci_writel(reg, cfg->mux_reg);
spin_unlock_irqrestore(&mux_spin_lock, flags);
}
if (warn) {
#ifdef CONFIG_DAVINCI_MUX_WARNINGS
printk(KERN_WARNING "MUX: initialized %s\n", cfg->name);
#endif
}
#ifdef CONFIG_DAVINCI_MUX_DEBUG
if (cfg->debug || warn) {
printk(KERN_WARNING "MUX: Setting register %s\n", cfg->name);
printk(KERN_WARNING " %s (0x%08x) = 0x%08x -> 0x%08x\n",
cfg->mux_reg_name, cfg->mux_reg, reg_orig, reg);
}
#endif
return 0;
}
static void __init timer_init(void)
{
u32 bases[] = {DAVINCI_TIMER0_BASE, DAVINCI_TIMER1_BASE};
int i;
/* Global init of each 64-bit timer as a whole */
for(i=0; i<2; i++) {
u32 tgcr, base = bases[i];
/* Disabled, Internal clock source */
davinci_writel(0, base + TCR);
/* reset both timers, no pre-scaler for timer34 */
tgcr = 0;
davinci_writel(tgcr, base + TGCR);
/* Set both timers to unchained 32-bit */
tgcr = TGCR_TIMMODE_32BIT_UNCHAINED << TGCR_TIMMODE_SHIFT;
davinci_writel(tgcr, base + TGCR);
/* Unreset timers */
tgcr |= (TGCR_UNRESET << TGCR_TIM12RS_SHIFT) |
(TGCR_UNRESET << TGCR_TIM34RS_SHIFT);
davinci_writel(tgcr, base + TGCR);
/* Init both counters to zero */
davinci_writel(0, base + TIM12);
davinci_writel(0, base + TIM34);
}
/* Init of each timer as a 32-bit timer */
for (i=0; i< ARRAY_SIZE(timers); i++) {
struct timer_s *t = &timers[i];
if (t->name) {
t->id = i;
t->reg_base = (IS_TIMER1(t->id) ?
DAVINCI_TIMER1_BASE : DAVINCI_TIMER0_BASE);
if (IS_TIMER_BOT(t->id)) {
t->enamode_shift = 6;
t->tim_reg = t->reg_base + TIM12;
t->prd_reg = t->reg_base + PRD12;
} else {
t->enamode_shift = 22;
t->tim_reg = t->reg_base + TIM34;
t->prd_reg = t->reg_base + PRD34;
}
/* Register interrupt */
t->irqaction.name = t->name;
t->irqaction.dev_id = (void *)t;
if (t->irqaction.handler != NULL) {
setup_irq(timer_irqs[t->id], &t->irqaction);
}
timer32_config(&timers[i]);
}
}
}
static int timer32_config(struct timer_s *t)
{
u32 tcr = davinci_readl(t->reg_base + TCR);
/* disable timer */
tcr &= ~(TCR_ENAMODE_MASK << t->enamode_shift);
davinci_writel(tcr, t->reg_base + TCR);
/* reset counter to zero, set new period */
davinci_writel(0, t->tim_reg);
davinci_writel(t->period, t->prd_reg);
/* Set enable mode */
if (t->opts & TIMER_OPTS_ONESHOT) {
tcr |= TCR_ENAMODE_ONESHOT << t->enamode_shift;
} else if (t->opts & TIMER_OPTS_PERIODIC) {
tcr |= TCR_ENAMODE_PERIODIC << t->enamode_shift;
}
davinci_writel(tcr, t->reg_base + TCR);
return 0;
}
static irqreturn_t imp_common_isr(int irq, void *device_id,
struct pt_regs *regs)
{
u32 val;
if (cpu_is_davinci_dm365()) {
val = davinci_readl(0x1c7000c);
if (val & 0x8000) {
davinci_writel(0x8000, 0x1c7000c);
complete(&(imp_serializer_info.sem_isr));
}
} else
complete(&(imp_serializer_info.sem_isr));
return IRQ_HANDLED;
}
int tsif_set_pcr_config(struct inode *inode, unsigned long arg)
{
struct tsif_pcr_config pcr_cfg;
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
/* copy the parameters to the configuration */
if (copy_from_user(&pcr_cfg,
(struct tsif_pcr_config *)arg,
sizeof(struct tsif_pcr_config)))
return -EFAULT;
davinci_writel(TSIF_PCR_SENSE_CFG_RESETVAL,
tsif_dev->base + PCR_SENSE_CFG);
davinci_writel((TSIF_PCR_SENSE_CFG_PCR_SENSE_EN | (u32) pcr_cfg.
pcr_pid), tsif_dev->base + PCR_SENSE_CFG);
return 0;
}
int tsif_stop_rx(struct inode *inode)
{
unsigned int index, minor = iminor(inode);
struct tsif_control_dev *tsif_dev;
unsigned int ctrl0;
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
ctrl0 &= ~(TSIF_CTRL0_RCV_DMA_CTL | TSIF_CTRL0_RCV_CTL);
davinci_writel(ctrl0, tsif_dev->base + CTRL0);
tsif_rx_enable = 0;
return 0;
}
int tsif_set_pmt_config(struct inode *inode, unsigned long arg)
{
struct tsif_pmt_config pmt_cfg;
char *pmt_cfg_buff_ptr;
u32 inten;
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
/* copy the parameters to the configuration */
if (copy_from_user(&pmt_cfg,
(struct tsif_pmt_config *)arg,
sizeof(struct tsif_pmt_config)))
return -EFAULT;
davinci_writel(TSIF_PMT_SENSE_CFG_RESETVAL,
tsif_dev->base + PMT_SENSE_CFG);
inten = davinci_readl(tsif_dev->base + INTEN);
inten &= ~TSIF_INTEN_PMT_DETECT_INTEN;
davinci_writel(inten, tsif_dev->base + INTEN);
pmt_cfg_buff_ptr = (char *)virt_to_phys(kmalloc(4096, GFP_KERNEL));
if (pmt_cfg_buff_ptr == NULL)
return -1;
davinci_writel((u32) pmt_cfg_buff_ptr, tsif_dev->base + PMT_STORE_ADD);
davinci_writel((TSIF_PMT_SENSE_CFG_PMT_SENSE_EN | (u32) pmt_cfg.
pmt_pid), tsif_dev->base + PMT_SENSE_CFG);
/* Clear PMT_detect */
davinci_writel(TSIF_INTEN_CLR_PMT_DETECT_INTEN_CLR,
tsif_dev->base + INT_STATUS_CLR);
/* PMT_detect_inten<-1 */
inten = davinci_readl(tsif_dev->base + INTEN);
inten |= TSIF_INTEN_SET_PMT_DETECT_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN);
/* PAT_detect_inten_set<-1 */
inten = davinci_readl(tsif_dev->base + INTEN_SET);
inten |= TSIF_INTEN_SET_PMT_DETECT_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN_SET);
init_completion(&tsif_isr_data.pmt_complete);
tsif_isr_data.pmt_complete.done = 0;
return 0;
}
void davinci_mux_peripheral(unsigned int mux, unsigned int enable)
{
u32 pinmux, muxreg = PINMUX0_M;
if (mux >= DAVINCI_MUX_LEVEL2) {
muxreg = PINMUX1_M;
mux -= DAVINCI_MUX_LEVEL2;
}
pinmux = davinci_readl(DAVINCI_SYSTEM_MODULE_BASE + muxreg);
if (enable)
pinmux |= (1 << mux);
else
pinmux &= ~(1 << mux);
davinci_writel(pinmux, DAVINCI_SYSTEM_MODULE_BASE + muxreg);
}
int tsif_set_pat_config(struct inode *inode, unsigned long arg)
{
char *pat_cfg_buff_ptr;
u32 inten;
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
davinci_writel(TSIF_PAT_SENSE_CFG_RESETVAL,
tsif_dev->base + PAT_SENSE_CFG);
inten = davinci_readl(tsif_dev->base + INTEN);
inten &= ~TSIF_INTEN_PAT_DETECT_INTEN;
davinci_writel(inten, tsif_dev->base + INTEN);
pat_cfg_buff_ptr = (char *)virt_to_phys(kmalloc(192, GFP_KERNEL));
if (pat_cfg_buff_ptr == NULL)
return -1;
davinci_writel((u32) pat_cfg_buff_ptr, tsif_dev->base + PAT_STORE_ADD);
/* Clear PAT_detect */
davinci_writel(TSIF_INTEN_CLR_PAT_DETECT_INTEN_CLR,
tsif_dev->base + INT_STATUS_CLR);
davinci_writel(TSIF_PAT_SENSE_CFG_PAT_SENSE_EN,
tsif_dev->base + PAT_SENSE_CFG);
/* PAT_detect_inten<-1 */
inten = davinci_readl(tsif_dev->base + INTEN);
inten |= TSIF_INTEN_SET_PAT_DETECT_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN);
/* PAT_detect_inten_set<-1 */
inten = davinci_readl(tsif_dev->base + INTEN_SET);
inten |= TSIF_INTEN_SET_PAT_DETECT_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN_SET);
init_completion(&tsif_isr_data.pat_complete);
tsif_isr_data.pat_complete.done = 0;
return 0;
}
static void dm644x_setup_pinmux(unsigned int id)
{
switch (id) {
case DAVINCI_LPSC_ATA:
davinci_cfg_reg(DM644X_HDIREN);
davinci_cfg_reg(DM644X_ATAEN);
break;
case DAVINCI_LPSC_MMC_SD:
/* VDD power manupulations are done in U-Boot for CPMAC
* so applies to MMC as well
*/
/*Set up the pull regiter for MMC */
davinci_writel(0, DAVINCI_VDD3P3V_PWDN);
davinci_cfg_reg(DM644X_MSTK);
break;
case DAVINCI_LPSC_I2C:
davinci_cfg_reg(DM644X_I2C);
break;
case DAVINCI_LPSC_McBSP:
davinci_cfg_reg(DM644X_MCBSP);
break;
case DAVINCI_LPSC_PWM0:
davinci_cfg_reg(DM644X_PWM0);
break;
case DAVINCI_LPSC_PWM1:
davinci_cfg_reg(DM644X_PWM1);
break;
case DAVINCI_LPSC_PWM2:
davinci_cfg_reg(DM644X_PWM2);
break;
case DAVINCI_LPSC_VLYNQ:
davinci_cfg_reg(DM644X_VLINQEN);
davinci_cfg_reg(DM644X_VLINQWD);
break;
default:
break;
}
}
int tsif_control_release(struct inode *inode, struct file *file)
{
unsigned int index;
struct tsif_control_dev *tsif_dev;
index = iminor(inode) / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
davinci_writel(0x0, tsif_dev->base + CTRL0);
davinci_writel(0x0, tsif_dev->base + CTRL1);
davinci_writel(0x0, tsif_dev->base + INTEN);
davinci_writel(0xFFFFFFFF, tsif_dev->base + INTEN_CLR);
davinci_writel(0xFFFFFFFF, tsif_dev->base + INT_STATUS_CLR);
davinci_writel(0x00000001, tsif_dev->base + EMULATION_CTRL);
clk_disable(tsif_dev->tsif_clk);
return 0;
}
/* reset board using watchdog timer */
void davinci_watchdog_reset(void) {
u32 tgcr, wdtcr, base = DAVINCI_WDOG_BASE;
/* disable, internal clock source */
davinci_writel(0, base + TCR);
/* reset timer, set mode to 64-bit watchdog, and unreset */
tgcr = 0;
davinci_writel(tgcr, base + TCR);
tgcr = TGCR_TIMMODE_64BIT_WDOG << TGCR_TIMMODE_SHIFT;
tgcr |= (TGCR_UNRESET << TGCR_TIM12RS_SHIFT) |
(TGCR_UNRESET << TGCR_TIM34RS_SHIFT);
davinci_writel(tgcr, base + TCR);
/* clear counter and period regs */
davinci_writel(0, base + TIM12);
davinci_writel(0, base + TIM34);
davinci_writel(0, base + PRD12);
davinci_writel(0, base + PRD34);
/* enable */
wdtcr = davinci_readl(base + WDTCR);
wdtcr |= WDTCR_WDEN_ENABLE << WDTCR_WDEN_SHIFT;
davinci_writel(wdtcr, base + WDTCR);
/* put watchdog in pre-active state */
wdtcr = (WDTCR_WDKEY_SEQ0 << WDTCR_WDKEY_SHIFT) |
(WDTCR_WDEN_ENABLE << WDTCR_WDEN_SHIFT);
davinci_writel(wdtcr, base + WDTCR);
/* put watchdog in active state */
wdtcr = (WDTCR_WDKEY_SEQ1 << WDTCR_WDKEY_SHIFT) |
(WDTCR_WDEN_ENABLE << WDTCR_WDEN_SHIFT);
davinci_writel(wdtcr, base + WDTCR);
/* write an invalid value to the WDKEY field to trigger
* a watchdog reset */
wdtcr = 0x00004000;
davinci_writel(wdtcr, base + WDTCR);
}
static inline u32 regw(u32 val, u32 offset)
{
davinci_writel(val, ccdc_base_addr + offset);
return val;
}
static inline u32 regw_bl(u32 val, u32 offset)
{
davinci_writel(val, vpss_base_addr + offset);
return val;
}
static inline void davinci_irq_writel(unsigned long value, int offset)
{
davinci_writel(value, DAVINCI_ARM_INTC_BASE + offset);
}
int tsif_control_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
int ret = 0;
unsigned int index;
struct tsif_control_dev *tsif_dev;
index = iminor(inode) / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
switch (cmd) {
case TSIF_SET_RX_CONFIG:{
tsif_set_rx_config(inode, arg);
break;
}
case TSIF_GET_RX_CONFIG:{
u32 tsif_ctrl0, tsif_ctrl1;
struct tsif_rx_config rx_cfg;
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
if ((tsif_ctrl0 & TSIF_CTRL0_RCV_IF_MODE_DMA) == 0) {
switch (tsif_ctrl0 &
TSIF_CTRL0_RCV_IF_MODE_MASK) {
case TSIF_CTRL0_RCV_IF_MODE_SER_SYN:
rx_cfg.if_mode = TSIF_IF_SERIAL_SYNC;
break;
case TSIF_CTRL0_RCV_IF_MODE_SER_ASYN:
rx_cfg.if_mode = TSIF_IF_SERIAL_ASYNC;
break;
case TSIF_CTRL0_RCV_IF_MODE_PAR_SYN:
rx_cfg.if_mode = TSIF_IF_PARALLEL_SYNC;
break;
case TSIF_CTRL0_RCV_IF_MODE_PAR_ASYN:
rx_cfg.if_mode = TSIF_IF_PARALLEL_ASYNC;
break;
}
} else
rx_cfg.if_mode = TSIF_IF_DMA;
if ((tsif_ctrl0 & TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE)
== 0)
rx_cfg.stream_mode = TSIF_STREAM_NON_TS;
else
rx_cfg.stream_mode = TSIF_STREAM_TS;
switch (tsif_ctrl0 & TSIF_CTRL0_RCV_ATS_MODE_MASK) {
case TSIF_CTRL0_RCV_ATS_MODE_IN_192:
rx_cfg.ats_mode = TSIF_RX_ATS_THROUGH;
break;
case TSIF_CTRL0_RCV_ATS_MODE_IN_188:
rx_cfg.ats_mode = TSIF_RX_ATS_NOADD;
break;
case TSIF_CTRL0_RCV_ATS_MODE_CHANGE_192:
rx_cfg.ats_mode = TSIF_RX_ATS_CHANGE;
break;
case TSIF_CTRL0_RCV_ATS_MODE_ADD_188:
rx_cfg.ats_mode = TSIF_RX_ATS_ADD;
break;
}
if ((tsif_ctrl1 & TSIF_CTRL1_PID_FILTER_EN_ACTIVATE) ==
0)
rx_cfg.filter_mode = TSIF_PID_FILTER_BYPASS;
else {
switch (tsif_ctrl1 &
TSIF_CTRL1_PID_FILTER_CTL_MASK) {
case TSIF_CTRL1_PID_FILTER_CTL_FULL_MAN:
rx_cfg.filter_mode =
TSIF_PID_FILTER_FULL_MANUAL;
break;
case TSIF_CTRL1_PID_FILTER_CTL_SEMI_A:
rx_cfg.filter_mode =
TSIF_PID_FILTER_SEMI_AUTO_A;
break;
case TSIF_CTRL1_PID_FILTER_CTL_SEMI_B:
rx_cfg.filter_mode =
TSIF_PID_FILTER_SEMI_AUTO_B;
break;
case TSIF_CTRL1_PID_FILTER_CTL_FULL_AUT:
rx_cfg.filter_mode =
TSIF_PID_FILTER_FULL_AUTO;
break;
default:
return -EINVAL;
}
}
if ((tsif_ctrl0 & TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE)
== 0) {
switch (tsif_ctrl0 &
TSIF_CTRL0_RCV_PKT_SIZE_MASK) {
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_200:
rx_cfg.pkt_size =
TSIF_200_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_208:
rx_cfg.pkt_size =
TSIF_208_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_216:
rx_cfg.pkt_size =
TSIF_216_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_224:
rx_cfg.pkt_size =
TSIF_224_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_232:
rx_cfg.pkt_size =
TSIF_232_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_240:
rx_cfg.pkt_size =
TSIF_240_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_248:
rx_cfg.pkt_size =
TSIF_248_BYTES_PER_PKT;
break;
case TSIF_CTRL0_RCV_PKT_SIZE_BYTE_256:
rx_cfg.pkt_size =
TSIF_256_BYTES_PER_PKT;
break;
default:
return -EINVAL;
}
} else
rx_cfg.pkt_size = 192;
/* copy the configuration to the user space */
if (copy_to_user((struct tsif_rx_config *)arg,
&rx_cfg,
sizeof(struct tsif_rx_config)))
return -EFAULT;
break;
}
case TSIF_SET_TX_CONFIG:{
tsif_set_tx_config(inode, arg);
break;
}
case TSIF_GET_TX_CONFIG:{
u32 tsif_ctrl;
struct tsif_tx_config tx_cfg;
tsif_ctrl = davinci_readl(tsif_dev->base + CTRL0);
switch (tsif_ctrl & TSIF_CTRL0_TX_IF_MODE) {
case TSIF_CTRL0_TX_IF_MODE_SER_SYN:
tx_cfg.if_mode = TSIF_IF_SERIAL_SYNC;
break;
case TSIF_CTRL0_TX_IF_MODE_SER_ASYN:
tx_cfg.if_mode = TSIF_IF_SERIAL_ASYNC;
break;
case TSIF_CTRL0_TX_IF_MODE_PAR_SYN:
tx_cfg.if_mode = TSIF_IF_PARALLEL_SYNC;
break;
case TSIF_CTRL0_TX_IF_MODE_PAR_ASYN:
tx_cfg.if_mode = TSIF_IF_PARALLEL_ASYNC;
break;
}
if ((tsif_ctrl & TSIF_CTRL0_TX_STREAM_MODE) == 0)
tx_cfg.stream_mode = TSIF_STREAM_NON_TS;
else
tx_cfg.stream_mode = TSIF_STREAM_TS;
switch (tsif_ctrl & TSIF_CTRL0_TX_ATS_MODE) {
case TSIF_CTRL0_TX_ATS_MODE_OUT_188:
tx_cfg.ats_mode = TSIF_TX_ATS_REMOVE;
break;
case TSIF_CTRL0_TX_ATS_MODE_OUT_192:
tx_cfg.ats_mode = TSIF_TX_ATS_THROUGH;
break;
}
tx_cfg.interval_wait =
davinci_readb(tsif_dev->base + ASYNC_TX_WAIT);
if ((tsif_ctrl & TSIF_CTRL0_TX_STREAM_MODE) == 0) {
switch (tsif_ctrl & TSIF_CTRL0_TX_PKT_SIZE) {
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_200:
tx_cfg.pkt_size =
TSIF_200_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_208:
tx_cfg.pkt_size =
TSIF_208_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_216:
tx_cfg.pkt_size =
TSIF_216_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_224:
tx_cfg.pkt_size =
TSIF_224_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_232:
tx_cfg.pkt_size =
TSIF_232_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_240:
tx_cfg.pkt_size =
TSIF_240_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_248:
tx_cfg.pkt_size =
TSIF_248_BYTES_PER_PKT;
break;
case TSIF_CTRL0_TX_PKT_SIZE_BYTE_256:
tx_cfg.pkt_size =
TSIF_256_BYTES_PER_PKT;
break;
default:
return -EINVAL;
}
} else
tx_cfg.pkt_size = 192;
/* copy the configuration to the user space */
if (copy_to_user((struct tsif_tx_config *)arg,
&tx_cfg,
sizeof(struct tsif_tx_config)))
return -EFAULT;
break;
}
case TSIF_START_RX:{
u32 tsif_ctrl0;
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 |=
(TSIF_CTRL0_RCV_DMA_CTL | TSIF_CTRL0_RCV_CTL);
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_rx_enable = 1;
break;
}
case TSIF_STOP_RX:{
u32 tsif_ctrl0;
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &=
~(TSIF_CTRL0_RCV_DMA_CTL | TSIF_CTRL0_RCV_CTL);
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_rx_enable = 0;
break;
}
case TSIF_START_TX:{
u32 tsif_ctrl0;
void *addr;
addr =
(void *)davinci_readl(tsif_dev->base +
RRB0_STRT_ADD);
if (davinci_readl(tsif_dev->base + RRB0_STRT_ADD) ==
0x00000000)
return -EPERM;
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 |=
(TSIF_CTRL0_TX_DMA_CTL | TSIF_CTRL0_TX_CTL);
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_tx_enable = 1;
break;
}
case TSIF_STOP_TX:{
u32 tsif_ctrl0;
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &=
~(TSIF_CTRL0_TX_DMA_CTL | TSIF_CTRL0_TX_CTL);
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_tx_enable = 0;
tsif_tx_ats_init = 0;
break;
}
case TSIF_CONFIG_PAT:{
unsigned char flag;
unsigned int pat_store_add;
get_user(flag, (unsigned char *)arg);
if (flag)
tsif_set_pat_config(inode, arg);
else {
davinci_writel(0x0, tsif_dev->base +
PAT_SENSE_CFG);
pat_store_add = (unsigned int)
phys_to_virt(davinci_readl
(tsif_dev->base +
PAT_STORE_ADD));
kfree((void *)pat_store_add);
}
break;
}
case TSIF_GET_PAT_PKT:{
unsigned int pat_store_add;
wait_for_completion_interruptible(&tsif_isr_data.
pat_complete);
pat_store_add =
davinci_readl(tsif_dev->base + PAT_STORE_ADD);
pat_store_add =
(unsigned int)phys_to_virt(pat_store_add);
/* copy to user the PAT packet */
if (copy_to_user
((void *)arg, (void *)pat_store_add, 192))
return -EFAULT;
else
return 0;
break;
} /* case */
case TSIF_GET_PAT_CONFIG:{
struct tsif_pat_config pat_cfg;
pat_cfg.flag = davinci_readl(tsif_dev->base +
PAT_SENSE_CFG) >> 16;
/* copy the configuration to the user space */
if (copy_to_user((struct tsif_pat_config *)arg,
&pat_cfg,
sizeof(struct tsif_pat_config)))
return -EFAULT;
break;
}
case TSIF_GET_PMT_CONFIG:{
struct tsif_pmt_config pmt_cfg;
pmt_cfg.pmt_pid = davinci_readl(tsif_dev->base +
PMT_SENSE_CFG) & 0x1fff;
pmt_cfg.flag = davinci_readl(tsif_dev->base +
PMT_SENSE_CFG) >> 16;
/* copy the configuration to the user space */
if (copy_to_user((struct tsif_pmt_config *)arg,
&pmt_cfg,
sizeof(struct tsif_pmt_config)))
return -EFAULT;
break;
}
case TSIF_CONFIG_PMT:{
struct tsif_pmt_config pmt_cfg;
unsigned int pmt_store_add;
if (copy_from_user(&pmt_cfg,
(struct tsif_pmt_config *)arg,
sizeof(struct tsif_pmt_config)))
return -EFAULT;
if (pmt_cfg.flag)
tsif_set_pmt_config(inode, arg);
else {
davinci_writel(0x0,
tsif_dev->base + PMT_SENSE_CFG);
pmt_store_add = (unsigned int)
phys_to_virt(davinci_readl
(tsif_dev->base +
PMT_STORE_ADD));
kfree((void *)pmt_store_add);
}
break;
}
case TSIF_GET_PMT_PKT:{
unsigned int pmt_store_add;
wait_for_completion_interruptible(&tsif_isr_data.
pmt_complete);
pmt_store_add =
davinci_readl(tsif_dev->base + PMT_STORE_ADD);
pmt_store_add =
(unsigned int)phys_to_virt(pmt_store_add);
/* copy to user the PMT packet */
if (copy_to_user
((void *)arg, (void *)pmt_store_add, 4096))
return -EFAULT;
else
return 0;
break;
}
case TSIF_ENABLE_PCR:{
tsif_set_pcr_config(inode, arg);
break;
}
case TSIF_DISABLE_PCR:{
davinci_writel(0x0, tsif_dev->base + PCR_SENSE_CFG);
break;
}
case TSIF_SET_SPCPKT_CONFIG:{
tsif_set_spec_pkt_config(inode, arg);
break;
}
case TSIF_GET_SPCPKT_CONFIG:{
struct tsif_spcpkt_config spcpkt_cfg;
char *spcpkt_cfg_buff_ptr;
if ((davinci_readl(tsif_dev->base + CTRL1) &
TSIF_CTRL1_STREAM_BNDRY_CTL) == 0)
spcpkt_cfg.pid = 0x2000; /* set illegal PID */
else
spcpkt_cfg.pid =
(u16) (davinci_readl
(tsif_dev->base + BSP_PID) & 0x1fff);
spcpkt_cfg_buff_ptr =
(u8 *) davinci_readl(tsif_dev->base +
BSP_STORE_ADD);
/* copy the configuration to the user space */
if (copy_to_user((struct tsif_spcpkt_config *)arg,
&spcpkt_cfg,
sizeof(struct tsif_spcpkt_config)))
return -EFAULT;
break;
}
case TSIF_SET_ATS:{
unsigned long ats_val;
get_user(ats_val, (int *)arg);
ats_val |= (1 << 30);
davinci_writel(ats_val, tsif_dev->base + TX_ATS_INIT);
break;
}
case TSIF_GET_ATS:{
unsigned int ats_val;
ats_val = davinci_readl(tsif_dev->base +
TX_ATS_MONITOR);
put_user(ats_val, (int *)arg);
break;
}
case TSIF_BYPASS_ENABLE:{
davinci_writel(0x01000000,
tsif_dev->base + BP_MODE_CFG);
break;
}
case TSIF_SET_CONSEQUENTIAL_MODE:{
unsigned int ctrl0;
ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_DMA;
davinci_writel(ctrl0, tsif_dev->base + CTRL0);
break;
}
case TSIF_ENABLE_GOP_DETECT:{
unsigned char gop_flag;
get_user(gop_flag, (int *)arg);
if (gop_flag) {
davinci_writel(
(davinci_readl(
tsif_dev->base + INTEN) |
TSIF_INTEN_GOP_START_INTEN),
tsif_dev->base + INTEN);
davinci_writel(
(davinci_readl(
tsif_dev->base + INTEN_SET) |
TSIF_INTEN_SET_GOP_START_INTEN_SET),
tsif_dev->base + INTEN_SET);
davinci_writel(
(davinci_readl(
tsif_dev->base + CTRL1) | 0x20),
tsif_dev->base + CTRL1);
} else {
davinci_writel(
(davinci_readl(
tsif_dev->base + CTRL1) & 0xFFFFFFDF),
tsif_dev->base + CTRL1);
}
break;
}
case TSIF_GET_SPCPKT:{
unsigned int bsp_store_add;
wait_for_completion_interruptible(&tsif_isr_data.
spcpkt_complete);
bsp_store_add =
davinci_readl(tsif_dev->base + BSP_STORE_ADD);
bsp_store_add =
(unsigned int)phys_to_virt(bsp_store_add);
/* copy to user the specific packet */
if (copy_to_user
((void *)arg, (void *)bsp_store_add, 4096))
return -EFAULT;
else
return 0;
break;
}
case TSIF_SET_ENDIAN_CTL:{
unsigned long endian_ctl;
unsigned long cur_reg_val;
get_user(endian_ctl, (int *)arg);
cur_reg_val = davinci_readl(tsif_dev->base + CTRL1);
if (endian_ctl)
cur_reg_val |= 1 << 14;
else
cur_reg_val &= ~(1 << 14);
davinci_writel(cur_reg_val, tsif_dev->base + CTRL1);
break;
}
}
return ret;
}
int tsif_set_rx_config(struct inode *inode, unsigned long arg)
{
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
u32 tsif_ctrl0, tsif_ctrl1, inten;
u32 rx_ctrl0, rx_ctrl1;
struct tsif_rx_config rx_cfg;
int pkt_size = 0;
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
/* copy the parameters to the configuration */
if (copy_from_user(&rx_cfg,
(struct tsif_rx_config *)arg,
sizeof(struct tsif_rx_config)))
return -EFAULT;
if (tsif_stop_rx(inode) != 0)
return -EPERM;
davinci_writel(TSIF_RING_BUFFER_WRITE_CHANNEL_CONTROL_RESETVAL,
tsif_dev->base + WRB_CH_CTRL);
/* Disbale all receiver relarted interrupts */
inten = davinci_readl(tsif_dev->base + INTEN);
inten &= ~(TSIF_INTEN_RBW7_FULL_INTEN |
TSIF_INTEN_RBW6_FULL_INTEN |
TSIF_INTEN_RBW5_FULL_INTEN |
TSIF_INTEN_RBW4_FULL_INTEN |
TSIF_INTEN_RBW3_FULL_INTEN |
TSIF_INTEN_RBW2_FULL_INTEN |
TSIF_INTEN_RBW1_FULL_INTEN |
TSIF_INTEN_RBW0_FULL_INTEN | TSIF_INTEN_GOP_START_INTEN);
davinci_writel(inten, tsif_dev->base + INTEN);
if (&rx_cfg != NULL) {
rx_ctrl0 = rx_ctrl1 = 0x00000000;
switch (rx_cfg.if_mode) {
case TSIF_IF_SERIAL_SYNC:
rx_ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_SER_SYN;
break;
case TSIF_IF_SERIAL_ASYNC:
rx_ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_SER_ASYN;
break;
case TSIF_IF_PARALLEL_SYNC:
rx_ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_PAR_SYN;
break;
case TSIF_IF_PARALLEL_ASYNC:
rx_ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_PAR_ASYN;
break;
case TSIF_IF_DMA:
rx_ctrl0 |= TSIF_CTRL0_RCV_IF_MODE_DMA;
break;
default:
return -EINVAL;
}
switch (rx_cfg.filter_mode) {
case TSIF_PID_FILTER_BYPASS:{
switch (rx_cfg.stream_mode) {
case TSIF_STREAM_TS:
rx_ctrl0 |=
TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
case TSIF_STREAM_NON_TS:
rx_ctrl0 |=
TSIF_CTRL0_RCV_STREAM_MODE_TS_INACTIVE;
switch (rx_cfg.pkt_size) {
case TSIF_200_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_200;
pkt_size = 200;
break;
case TSIF_208_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_208;
pkt_size = 208;
break;
case TSIF_216_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_216;
pkt_size = 216;
break;
case TSIF_224_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_224;
pkt_size = 224;
break;
case TSIF_232_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_232;
pkt_size = 232;
break;
case TSIF_240_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_240;
pkt_size = 240;
break;
case TSIF_248_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_248;
pkt_size = 248;
break;
case TSIF_256_BYTES_PER_PKT:
rx_ctrl0 |=
TSIF_CTRL0_RCV_PKT_SIZE_BYTE_256;
pkt_size = 256;
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
break;
}
case TSIF_PID_FILTER_FULL_MANUAL:
rx_ctrl1 |=
TSIF_CTRL1_STREAM_BNDRY_CTL |
TSIF_CTRL1_PID_FILTER_EN_ACTIVATE |
TSIF_CTRL1_PID_FILTER_CTL_FULL_MAN;
rx_ctrl0 |= TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
case TSIF_PID_FILTER_SEMI_AUTO_A:
rx_ctrl1 |=
TSIF_CTRL1_STREAM_BNDRY_CTL |
TSIF_CTRL1_PID_FILTER_EN_ACTIVATE |
TSIF_CTRL1_PID_FILTER_CTL_SEMI_A;
rx_ctrl0 |= TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
case TSIF_PID_FILTER_SEMI_AUTO_B:
rx_ctrl1 |=
TSIF_CTRL1_STREAM_BNDRY_CTL |
TSIF_CTRL1_PID_FILTER_EN_ACTIVATE |
TSIF_CTRL1_PID_FILTER_CTL_SEMI_B;
rx_ctrl0 |= TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
case TSIF_PID_FILTER_FULL_AUTO:
rx_ctrl1 |=
TSIF_CTRL1_STREAM_BNDRY_CTL |
TSIF_CTRL1_PID_FILTER_EN_ACTIVATE |
TSIF_CTRL1_PID_FILTER_CTL_FULL_AUT;
rx_ctrl0 |= TSIF_CTRL0_RCV_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
default:
return -EINVAL;
}
switch (rx_cfg.ats_mode) {
case TSIF_RX_ATS_THROUGH:
rx_ctrl0 |= TSIF_CTRL0_RCV_ATS_MODE_IN_192;
break;
case TSIF_RX_ATS_NOADD:
rx_ctrl0 |= TSIF_CTRL0_RCV_ATS_MODE_IN_188;
break;
case TSIF_RX_ATS_CHANGE:
rx_ctrl0 |= TSIF_CTRL0_RCV_ATS_MODE_CHANGE_192;
break;
case TSIF_RX_ATS_ADD:
rx_ctrl0 |= TSIF_CTRL0_RCV_ATS_MODE_ADD_188;
break;
default:
return -EINVAL;
}
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &= ~(RX_CONFIG);
tsif_ctrl0 |= rx_ctrl0;
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
tsif_ctrl1 |= rx_ctrl1;
davinci_writel(tsif_ctrl1, tsif_dev->base + CTRL1);
} else {
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &= ~(RX_CONFIG) | 0x00000000;
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
tsif_ctrl1 &= ~(TSIF_CTRL1_PID_FILTER_CTL) | 0x00000000;
davinci_writel(tsif_ctrl1, tsif_dev->base + CTRL1);
}
return 0;
}
int tsif_set_tx_config(struct inode *inode, unsigned long arg)
{
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
u32 tx_ctrl, tsif_ctrl0, inten;
struct tsif_tx_config tx_cfg;
int pkt_size = 0;
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
/* copy the parameters to the configuration */
if (copy_from_user(&tx_cfg,
(struct tsif_tx_config *)arg,
sizeof(struct tsif_tx_config)))
return -EFAULT;
davinci_writel(TSIF_RING_BUF_RD_CH_CTL_RESETVAL,
tsif_dev->base + RRB_CH_CTRL);
inten = davinci_readl(tsif_dev->base + INTEN);
inten &= ~TSIF_INTEN_RBR0_FULL_INTEN;
davinci_writel(inten, tsif_dev->base + INTEN);
if (&tx_cfg != NULL) {
tx_ctrl = 0x00000000;
switch (tx_cfg.if_mode) {
case TSIF_IF_SERIAL_SYNC:
if (tx_cfg.clk_speed == TSIF_13_5_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_13_5_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed ==
TSIF_16_875_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_16_875_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed == TSIF_27_0_MHZ_SERIAL)
set_tsif_clk(TSIF_27_0_MHZ_SERIAL);
else if (tx_cfg.clk_speed == TSIF_54_0_MHZ_SERIAL)
set_tsif_clk(TSIF_54_0_MHZ_SERIAL);
else if (tx_cfg.clk_speed == TSIF_81_0_MHZ_SERIAL)
set_tsif_clk(TSIF_81_0_MHZ_SERIAL);
else
return -EINVAL;
davinci_cfg_reg(DM646X_PTSOMUX_SERIAL);
davinci_cfg_reg(DM646X_PTSIMUX_SERIAL);
tx_ctrl |= TSIF_CTRL0_TX_IF_MODE_SER_SYN;
break;
case TSIF_IF_SERIAL_ASYNC:
if (tx_cfg.clk_speed == TSIF_13_5_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_13_5_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed ==
TSIF_16_875_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_16_875_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed == TSIF_27_0_MHZ_SERIAL)
set_tsif_clk(TSIF_27_0_MHZ_SERIAL);
else if (tx_cfg.clk_speed == TSIF_54_0_MHZ_SERIAL)
set_tsif_clk(TSIF_54_0_MHZ_SERIAL);
else if (tx_cfg.clk_speed == TSIF_81_0_MHZ_SERIAL)
set_tsif_clk(TSIF_81_0_MHZ_SERIAL);
else
return -EINVAL;
davinci_cfg_reg(DM646X_PTSOMUX_SERIAL);
davinci_cfg_reg(DM646X_PTSIMUX_SERIAL);
tx_ctrl |= TSIF_CTRL0_TX_IF_MODE_SER_ASYN;
break;
case TSIF_IF_PARALLEL_SYNC:
if (tx_cfg.clk_speed == TSIF_13_5_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_13_5_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed ==
TSIF_16_875_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_16_875_MHZ_SERIAL_PARALLEL);
else
return -EINVAL;
davinci_cfg_reg(DM646X_PTSOMUX_PARALLEL);
davinci_cfg_reg(DM646X_PTSIMUX_PARALLEL);
tx_ctrl |= TSIF_CTRL0_TX_IF_MODE_PAR_SYN;
break;
case TSIF_IF_PARALLEL_ASYNC:
if (tx_cfg.clk_speed == TSIF_13_5_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_13_5_MHZ_SERIAL_PARALLEL);
else if (tx_cfg.clk_speed ==
TSIF_16_875_MHZ_SERIAL_PARALLEL)
set_tsif_clk(TSIF_16_875_MHZ_SERIAL_PARALLEL);
else
return -EINVAL;
davinci_cfg_reg(DM646X_PTSOMUX_PARALLEL);
davinci_cfg_reg(DM646X_PTSIMUX_PARALLEL);
tx_ctrl |= TSIF_CTRL0_TX_IF_MODE_PAR_ASYN;
break;
case TSIF_IF_DMA:
default:
return -EINVAL;
}
switch (tx_cfg.stream_mode) {
case TSIF_STREAM_TS:
tx_ctrl |= TSIF_CTRL0_TX_STREAM_MODE_TS_ACTIVE;
pkt_size = 192;
break;
case TSIF_STREAM_NON_TS:
tx_ctrl |= TSIF_CTRL0_TX_STREAM_MODE_TS_INACTIVE;
switch (tx_cfg.pkt_size) {
case TSIF_200_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_200;
pkt_size = 200;
break;
case TSIF_208_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_208;
pkt_size = 208;
break;
case TSIF_216_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_216;
pkt_size = 216;
break;
case TSIF_224_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_224;
pkt_size = 224;
break;
case TSIF_232_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_232;
pkt_size = 232;
break;
case TSIF_240_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_240;
pkt_size = 240;
break;
case TSIF_248_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_248;
pkt_size = 248;
break;
case TSIF_256_BYTES_PER_PKT:
tx_ctrl |= TSIF_CTRL0_TX_PKT_SIZE_BYTE_256;
pkt_size = 256;
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
switch (tx_cfg.ats_mode) {
case TSIF_TX_ATS_REMOVE:
tx_ctrl |= TSIF_CTRL0_TX_ATS_MODE_OUT_188;
break;
case TSIF_TX_ATS_THROUGH:
tx_ctrl |= TSIF_CTRL0_TX_ATS_MODE_OUT_192;
break;
default:
return -EINVAL;
}
davinci_writel((u32) tx_cfg.interval_wait,
tsif_dev->base + ASYNC_TX_WAIT);
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &= ~(TX_CONFIG);
tsif_ctrl0 |= tx_ctrl;
tsif_ctrl0 |= TSIF_CTRL0_TX_CLK_INV_MASK;
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
} else {
davinci_writel(TSIF_ASYNC_TX_WAIT_RESETVAL,
tsif_dev->base + ASYNC_TX_WAIT);
tsif_ctrl0 = davinci_readl(tsif_dev->base + CTRL0);
tsif_ctrl0 &= ~(TX_CONFIG) | 0x00000000;
davinci_writel(tsif_ctrl0, tsif_dev->base + CTRL0);
}
/* Clear RBR0_full */
davinci_writel(TSIF_INTEN_CLR_RBR0_FULL_INTEN_CLR,
tsif_dev->base + INT_STATUS_CLR);
/* RBR0_full_inten<-1 */
inten = davinci_readl(tsif_dev->base + INTEN);
inten |= TSIF_INTEN_RBR0_FULL_INTEN;
davinci_writel(inten, tsif_dev->base + INTEN);
/* RBR0_full_inten_set<-1 */
inten = davinci_readl(tsif_dev->base + INTEN_SET);
inten |= TSIF_INTEN_SET_RBR0_FULL_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN_SET);
return 0;
}
int tsif_set_spec_pkt_config(struct inode *inode, unsigned long arg)
{
struct tsif_spcpkt_config spcpkt_cfg;
char *spcpkt_cfg_buff_ptr = NULL;
u32 inten, tsif_ctrl1;
struct tsif_control_dev *tsif_dev;
unsigned int index, minor = iminor(inode);
index = minor / tsif_control_minor_count;
tsif_dev = tsif_control_dev_get_by_major(index);
/* copy the parameters to the configuration */
if (copy_from_user(&spcpkt_cfg,
(struct tsif_spcpkt_config *)arg,
sizeof(struct tsif_spcpkt_config)))
return -EFAULT;
inten = davinci_readl(tsif_dev->base + INTEN);
inten &= ~TSIF_INTEN_SET_BOUNDARY_SPECIFIC_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN);
spcpkt_cfg_buff_ptr = (char *)virt_to_phys(kmalloc(4096, GFP_KERNEL));
if (spcpkt_cfg_buff_ptr == NULL)
return -1;
if (&spcpkt_cfg != NULL) {
if (spcpkt_cfg.pid < 0x2000) {
davinci_writel((u32) spcpkt_cfg.pid,
tsif_dev->base + BSP_PID);
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
tsif_ctrl1 |= TSIF_CTRL1_STREAM_BNDRY_CTL;
davinci_writel(tsif_ctrl1, tsif_dev->base + CTRL1);
} else {
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
tsif_ctrl1 &= ~TSIF_CTRL1_STREAM_BNDRY_CTL;
}
davinci_writel((u32) spcpkt_cfg_buff_ptr,
tsif_dev->base + BSP_STORE_ADD);
} else {
tsif_ctrl1 = davinci_readl(tsif_dev->base + CTRL1);
tsif_ctrl1 &= ~TSIF_CTRL1_STREAM_BNDRY_CTL;
davinci_writel(tsif_ctrl1, tsif_dev->base + CTRL1);
davinci_writel(TSIF_BSP_STORE_ADDR_RESETVAL,
tsif_dev->base + BSP_STORE_ADD);
}
/* Clear boundary_specific */
davinci_writel(TSIF_INTEN_CLR_BOUNDARY_SPECIFIC_INTEN_CLR,
tsif_dev->base + INT_STATUS_CLR);
/* boundary_specific_inten<-1 */
inten = davinci_readl(tsif_dev->base + INTEN);
inten |= TSIF_INTEN_SET_BOUNDARY_SPECIFIC_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN);
/* boundary_specific_inten_set<-1 */
inten = davinci_readl(tsif_dev->base + INTEN_SET);
inten |= TSIF_INTEN_SET_BOUNDARY_SPECIFIC_INTEN_SET;
davinci_writel(inten, tsif_dev->base + INTEN_SET);
init_completion(&tsif_isr_data.spcpkt_complete);
tsif_isr_data.spcpkt_complete.done = 0;
return 0;
}
