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; }