void cleanup_module(void)
{
if (!(this_port->flags & PARPORT_FLAG_COMA))
parport_quiesce(this_port);
parport_proc_unregister(this_port);
parport_unregister_port(this_port);
}
void __exit parport_amiga_exit(void)
{
if (this_port->irq != PARPORT_IRQ_NONE)
free_irq(IRQ_AMIGA_CIAA_FLG, this_port);
parport_proc_unregister(this_port);
parport_unregister_port(this_port);
release_mem_region(CIAA_PHYSADDR-1+0x100, 0x100);
}
void
cleanup_module(void)
{
struct parport *p = parport_enumerate(), *tmp;
while (p) {
tmp = p->next;
if (p->modes & PARPORT_MODE_PCSPP) {
if (!(p->flags & PARPORT_FLAG_COMA))
parport_quiesce(p);
parport_proc_unregister(p);
parport_unregister_port(p);
}
p = tmp;
}
}
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;
}
int __init parport_amiga_init(void)
{
struct parport *p;
int err;
if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_PARALLEL))
return -ENODEV;
err = -EBUSY;
if (!request_mem_region(CIAA_PHYSADDR-1+0x100, 0x100, "parallel"))
goto out_mem;
ciaa.ddrb = 0xff;
ciab.ddra &= 0xf8;
mb();
p = parport_register_port((unsigned long)&ciaa.prb, IRQ_AMIGA_CIAA_FLG,
PARPORT_DMA_NONE, &pp_amiga_ops);
if (!p)
goto out_port;
err = request_irq(IRQ_AMIGA_CIAA_FLG, amiga_interrupt, 0, p->name, p);
if (err)
goto out_irq;
this_port = p;
printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name);
/* XXX: set operating mode */
parport_proc_register(p);
parport_announce_port(p);
return 0;
out_irq:
parport_unregister_port(p);
out_port:
release_mem_region(CIAA_PHYSADDR-1+0x100, 0x100);
out_mem:
return err;
}
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);
}
}
void
cleanup_module(void)
{
struct parport *p = parport_enumerate();
while (p) {
struct parport *next = p->next;
if (1/*p->modes & PARPORT_MODE_PCSPP*/) {
struct parport_operations *ops = p->ops;
if (p->irq != PARPORT_IRQ_NONE) {
parport_sunbpp_disable_irq(p);
free_irq(p->irq, p);
}
sbus_iounmap(p->base, p->size);
parport_proc_unregister(p);
parport_unregister_port(p);
kfree (ops);
}
p = next;
}
}
void parport_cs_release(u_long arg)
{
dev_link_t *link = (dev_link_t *)arg;
parport_info_t *info = link->priv;
DEBUG(0, "parport_release(0x%p)\n", link);
if (info->ndev) {
struct parport *p = info->port;
parport_proc_unregister(p);
kfree(p->private_data);
parport_unregister_port(p);
}
info->ndev = 0;
link->dev = NULL;
CardServices(ReleaseConfiguration, link->handle);
CardServices(ReleaseIO, link->handle, &link->io);
CardServices(ReleaseIRQ, link->handle, &link->irq);
link->state &= ~DEV_CONFIG;
} /* parport_cs_release */
static int __init init_one_port(struct sbus_dev *sdev)
{
struct parport *p;
/* at least in theory there may be a "we don't dma" case */
struct parport_operations *ops;
unsigned long base;
int irq, dma, err, size;
struct bpp_regs *regs;
unsigned char value_tcr;
dprintk((KERN_DEBUG "init_one_port(%p): ranges, alloc_io, ", sdev));
irq = sdev->irqs[0];
base = sbus_ioremap(&sdev->resource[0], 0,
sdev->reg_addrs[0].reg_size,
"sunbpp");
size = sdev->reg_addrs[0].reg_size;
dma = PARPORT_DMA_NONE;
dprintk(("alloc(ppops), "));
ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
if (!ops) {
sbus_iounmap(base, size);
return 0;
}
memcpy (ops, &parport_sunbpp_ops, sizeof (struct parport_operations));
dprintk(("register_port\n"));
if (!(p = parport_register_port(base, irq, dma, ops))) {
kfree(ops);
sbus_iounmap(base, size);
return 0;
}
p->size = size;
dprintk((KERN_DEBUG "init_one_port: request_irq(%08x:%p:%x:%s:%p) ",
p->irq, parport_sunbpp_interrupt, SA_SHIRQ, p->name, p));
if ((err = request_irq(p->irq, parport_sunbpp_interrupt,
SA_SHIRQ, p->name, p)) != 0) {
dprintk(("ERROR %d\n", err));
parport_unregister_port(p);
kfree(ops);
sbus_iounmap(base, size);
return err;
} else {
dprintk(("OK\n"));
parport_sunbpp_enable_irq(p);
}
regs = (struct bpp_regs *)p->base;
dprintk((KERN_DEBUG "forward\n"));
value_tcr = sbus_readb(®s->p_tcr);
value_tcr &= ~P_TCR_DIR;
sbus_writeb(value_tcr, ®s->p_tcr);
printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
parport_proc_register(p);
parport_announce_port (p);
return 1;
}
