parport.c

上传linux-jx2410的源代码

	struct etrax100par_struct *info =
		(struct etrax100par_struct *)p->private_data;
	*info->irq_mask_clr = info->irq_mask_tx;
	DPRINTK("* E100 PP %d: disable irq\n", p->portnum);
}


static void
parport_etrax_data_forward(struct parport *p)
{
	struct etrax100par_struct *info =
		(struct etrax100par_struct *)p->private_data;

	DPRINTK("* E100 PP %d: forward mode\n", p->portnum);
	SETS(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, oe, enable);
	*info->reg_ctrl_data = info->reg_ctrl_data_shadow;
}


static void
parport_etrax_data_reverse(struct parport *p)
{
	struct etrax100par_struct *info =
		(struct etrax100par_struct *)p->private_data;

	DPRINTK("* E100 PP %d: reverse mode\n", p->portnum);
	SETS(info->reg_ctrl_data_shadow, R_PAR0_CTRL_DATA, oe, disable);
	*info->reg_ctrl_data = info->reg_ctrl_data_shadow;
}


static void
parport_etrax_init_state(struct pardevice *dev, struct parport_state *s)
{
	DPRINTK("* E100 PP: parport_etrax_init_state\n");
}


static void
parport_etrax_save_state(struct parport *p, struct parport_state *s)
{
	DPRINTK("* E100 PP: parport_etrax_save_state\n");
}


static void
parport_etrax_restore_state(struct parport *p, struct parport_state *s)
{
	DPRINTK("* E100 PP: parport_etrax_restore_state\n");
}


static void
parport_etrax_inc_use_count(void)
{
	MOD_INC_USE_COUNT;
}


static void
parport_etrax_dec_use_count(void)
{
	MOD_DEC_USE_COUNT;
}


static struct
parport_operations pp_etrax_ops = {
	parport_etrax_write_data,
	parport_etrax_read_data,

	parport_etrax_write_control,
	parport_etrax_read_control,
	parport_etrax_frob_control,

	parport_etrax_read_status,

	parport_etrax_enable_irq,
	parport_etrax_disable_irq,

	parport_etrax_data_forward, 
	parport_etrax_data_reverse, 

	parport_etrax_init_state,
	parport_etrax_save_state,
	parport_etrax_restore_state,

	parport_etrax_inc_use_count,
	parport_etrax_dec_use_count,

	parport_ieee1284_epp_write_data,
	parport_ieee1284_epp_read_data,
	parport_ieee1284_epp_write_addr,
	parport_ieee1284_epp_read_addr,

	parport_ieee1284_ecp_write_data,
	parport_ieee1284_ecp_read_data,
	parport_ieee1284_ecp_write_addr,

	parport_ieee1284_write_compat,
	parport_ieee1284_read_nibble,
	parport_ieee1284_read_byte,
};

	
static void 
parport_etrax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	struct etrax100par_struct *info = (struct etrax100par_struct *)
		((struct parport *)dev_id)->private_data;
	DPRINTK("* E100 PP %d: Interrupt received\n",
		((struct parport *)dev_id)->portnum);
	*info->irq_mask_clr = info->irq_mask_tx;
	parport_generic_irq(irq, (struct parport *)dev_id, regs);
}

/* ----------- Initialisation code --------------------------------- */

static void __init
parport_etrax_show_parallel_version(void)
{
	printk("ETRAX 100LX parallel port driver v1.0, (c) 2001 Axis Communications AB\n");
}

#ifdef CONFIG_ETRAX_PAR0_DMA
#define PAR0_USE_DMA 1
#else
#define PAR0_USE_DMA 0
#endif

#ifdef CONFIG_ETRAX_PAR1_DMA
#define PAR1_USE_DMA 1
#else
#define PAR1_USE_DMA 0
#endif

static void __init
parport_etrax_init_registers(void)
{
	struct etrax100par_struct *info;
	int i;

	for (i = 0, info = port_table; i < 2; i++, info++) {
#ifndef CONFIG_ETRAX_PARALLEL_PORT0
		if (i == 0)
			continue;
#endif
#ifndef CONFIG_ETRAX_PARALLEL_PORT1
		if (i == 1)
			continue;
#endif
		info->reg_config_shadow = 
			IO_STATE(R_PAR0_CONFIG, iseli, inv)       |
			IO_STATE(R_PAR0_CONFIG, iautofd, inv)     |
			IO_STATE(R_PAR0_CONFIG, istrb, inv)       |
			IO_STATE(R_PAR0_CONFIG, iinit, inv)       |
			IO_STATE(R_PAR0_CONFIG, rle_in, disable)  |
			IO_STATE(R_PAR0_CONFIG, rle_out, disable) |
			IO_STATE(R_PAR0_CONFIG, enable, on)       |
			IO_STATE(R_PAR0_CONFIG, force, off)       |
			IO_STATE(R_PAR0_CONFIG, ign_ack, wait)    |
			IO_STATE(R_PAR0_CONFIG, oe_ack, wait_oe)  |
			IO_STATE(R_PAR0_CONFIG, mode, manual);

		if ((i == 0 && PAR0_USE_DMA) || (i == 1 && PAR1_USE_DMA))
			info->reg_config_shadow |=
				IO_STATE(R_PAR0_CONFIG, dma, enable);
		else
			info->reg_config_shadow |=
				IO_STATE(R_PAR0_CONFIG, dma, disable);

		*info->reg_config = info->reg_config_shadow;

		info->reg_ctrl_data_shadow = 
			IO_STATE(R_PAR0_CTRL_DATA, peri_int, nop)    |
			IO_STATE(R_PAR0_CTRL_DATA, oe, enable)       |
			IO_STATE(R_PAR0_CTRL_DATA, seli, inactive)   |
			IO_STATE(R_PAR0_CTRL_DATA, autofd, inactive) |
			IO_STATE(R_PAR0_CTRL_DATA, strb, inactive)   |
			IO_STATE(R_PAR0_CTRL_DATA, init, inactive)   |
			IO_STATE(R_PAR0_CTRL_DATA, ecp_cmd, data)    |
			IO_FIELD(R_PAR0_CTRL_DATA, data, 0);
		*info->reg_ctrl_data = info->reg_ctrl_data_shadow;

		/* Clear peri int without setting shadow */
		*info->reg_ctrl_data = info->reg_ctrl_data_shadow |
			IO_STATE(R_PAR0_CTRL_DATA, peri_int, ack);

		info->reg_delay_shadow = 
			IO_FIELD(R_PAR0_DELAY, setup, 5)  |
			IO_FIELD(R_PAR0_DELAY, strobe, 5) |
			IO_FIELD(R_PAR0_DELAY, hold, 5);
		*info->reg_delay = info->reg_delay_shadow;
	}

#ifdef CONFIG_ETRAX_PARALLEL_PORT0
#ifdef CONFIG_ETRAX_PAR0_DMA
	RESET_DMA(PAR0_TX_DMA_NBR);
	WAIT_DMA(PAR0_TX_DMA_NBR);
#ifdef CONFIG_ETRAX_SERIAL_PORT2
	printk(" Warning - DMA clash with ser2!\n");
#endif /* SERIAL_PORT2 */
#endif /* DMA */
#endif /* PORT0 */

#ifdef CONFIG_ETRAX_PARALLEL_PORT1
#ifdef CONFIG_ETRAX_PAR1_DMA
	RESET_DMA(PAR1_TX_DMA_NBR);
	WAIT_DMA(PAR1_TX_DMA_NBR);
#ifdef CONFIG_ETRAX_SERIAL_PORT3
	printk(" Warning - DMA clash with ser3!\n");
#endif /* SERIAL_PORT3 */
#endif /* DMA */
#endif /* PORT1 */
} 


int __init
parport_etrax_init(void)
{
	struct parport *p;
	int port_exists = 0;
	int i;
	struct etrax100par_struct *info;
        const char *names[] = { "parallel 0 tx+rx", "parallel 1 tx+rx" };

	parport_etrax_show_parallel_version();
	parport_etrax_init_registers();

        for (i = 0, info = port_table; i < NR_PORTS; i++, info++) {
#ifndef CONFIG_ETRAX_PARALLEL_PORT0
		if (i == 0)
			continue;
#endif
#ifndef CONFIG_ETRAX_PARALLEL_PORT1
		if (i == 1)
			continue;
#endif
                p = parport_register_port((unsigned long)0, info->int_irq,
                                          PARPORT_DMA_NONE, &pp_etrax_ops);
                if (!p)
			continue;

                info->port = p;
                p->private_data = info;
                /* Axis FIXME: Set mode flags. */
                /* p->modes = PARPORT_MODE_TRISTATE | PARPORT_MODE_SAFEININT; */

	        if(request_irq(info->int_irq, parport_etrax_interrupt,
                               SA_SHIRQ, names[i], p)) {
	        	parport_unregister_port (p);
                        continue;
                }

                printk(KERN_INFO "%s: ETRAX 100LX port %d using irq\n",
                       p->name, i);
                parport_proc_register(p);
                parport_announce_port(p);
                port_exists = 1;
        }

	return port_exists;
}

void __exit
parport_etrax_exit(void)
{
	int i;
	struct etrax100par_struct *info;

        for (i = 0, info = port_table; i < NR_PORTS; i++, info++) {
#ifndef CONFIG_ETRAX_PARALLEL_PORT0
		if (i == 0)
			continue;
#endif
#ifndef CONFIG_ETRAX_PARALLEL_PORT1
		if (i == 1)
			continue;
#endif
		if (info->int_irq != PARPORT_IRQ_NONE)
			free_irq(info->int_irq, info->port);
		parport_proc_unregister(info->port);
		parport_unregister_port(info->port);
        }
}