static int elp_open(struct net_device *dev)
{
elp_device *adapter;
int retval;
adapter = dev->priv;
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: request to open device\n", dev->name);
/*
* make sure we actually found the device
*/
if (adapter == NULL) {
printk(KERN_ERR "%s: Opening a non-existent physical device\n", dev->name);
return -EAGAIN;
}
/*
* disable interrupts on the board
*/
outb_control(0, dev);
/*
* clear any pending interrupts
*/
inb_command(dev->base_addr);
adapter_reset(dev);
/*
* no receive PCBs active
*/
adapter->rx_active = 0;
adapter->busy = 0;
adapter->send_pcb_semaphore = 0;
adapter->rx_backlog.in = 0;
adapter->rx_backlog.out = 0;
spin_lock_init(&adapter->lock);
/*
* install our interrupt service routine
*/
if ((retval = request_irq(dev->irq, &elp_interrupt, 0, dev->name, dev))) {
printk(KERN_ERR "%s: could not allocate IRQ%d\n", dev->name, dev->irq);
return retval;
}
if ((retval = request_dma(dev->dma, dev->name))) {
free_irq(dev->irq, dev);
printk(KERN_ERR "%s: could not allocate DMA%d channel\n", dev->name, dev->dma);
return retval;
}
adapter->dma_buffer = (void *) dma_mem_alloc(DMA_BUFFER_SIZE);
if (!adapter->dma_buffer) {
printk(KERN_ERR "%s: could not allocate DMA buffer\n", dev->name);
free_dma(dev->dma);
free_irq(dev->irq, dev);
return -ENOMEM;
}
adapter->dmaing = 0;
/*
* enable interrupts on the board
*/
outb_control(CMDE, dev);
/*
* configure adapter memory: we need 10 multicast addresses, default==0
*/
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: sending 3c505 memory configuration command\n", dev->name);
adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
adapter->tx_pcb.data.memconf.cmd_q = 10;
adapter->tx_pcb.data.memconf.rcv_q = 20;
adapter->tx_pcb.data.memconf.mcast = 10;
adapter->tx_pcb.data.memconf.frame = 20;
adapter->tx_pcb.data.memconf.rcv_b = 20;
adapter->tx_pcb.data.memconf.progs = 0;
adapter->tx_pcb.length = sizeof(struct Memconf);
adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 0;
if (!send_pcb(dev, &adapter->tx_pcb))
printk(KERN_ERR "%s: couldn't send memory configuration command\n", dev->name);
else {
unsigned long timeout = jiffies + TIMEOUT;
while (adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] == 0 && time_before(jiffies, timeout));
if (time_after_eq(jiffies, timeout))
TIMEOUT_MSG(__LINE__);
}
/*
* configure adapter to receive broadcast messages and wait for response
*/
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: sending 82586 configure command\n", dev->name);
adapter->tx_pcb.command = CMD_CONFIGURE_82586;
adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
adapter->tx_pcb.length = 2;
adapter->got[CMD_CONFIGURE_82586] = 0;
if (!send_pcb(dev, &adapter->tx_pcb))
printk(KERN_ERR "%s: couldn't send 82586 configure command\n", dev->name);
else {
unsigned long timeout = jiffies + TIMEOUT;
while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
if (time_after_eq(jiffies, timeout))
TIMEOUT_MSG(__LINE__);
}
/* enable burst-mode DMA */
/* outb(0x1, dev->base_addr + PORT_AUXDMA); */
/*
* queue receive commands to provide buffering
*/
prime_rx(dev);
if (elp_debug >= 3)
printk(KERN_DEBUG "%s: %d receive PCBs active\n", dev->name, adapter->rx_active);
/*
* device is now officially open!
*/
netif_start_queue(dev);
return 0;
}
struct net_device * __init ltpc_probe(void)
{
struct net_device *dev;
int err = -ENOMEM;
int x=0,y=0;
int autoirq;
unsigned long f;
unsigned long timeout;
dev = alloc_ltalkdev(sizeof(struct ltpc_private));
if (!dev)
goto out;
SET_MODULE_OWNER(dev);
/* probe for the I/O port address */
if (io != 0x240 && request_region(0x220,8,"ltpc")) {
x = inb_p(0x220+6);
if ( (x!=0xff) && (x>=0xf0) ) {
io = 0x220;
goto got_port;
}
release_region(0x220,8);
}
if (io != 0x220 && request_region(0x240,8,"ltpc")) {
y = inb_p(0x240+6);
if ( (y!=0xff) && (y>=0xf0) ){
io = 0x240;
goto got_port;
}
release_region(0x240,8);
}
/* give up in despair */
printk(KERN_ERR "LocalTalk card not found; 220 = %02x, 240 = %02x.\n", x,y);
err = -ENODEV;
goto out1;
got_port:
/* probe for the IRQ line */
if (irq < 2) {
unsigned long irq_mask;
irq_mask = probe_irq_on();
/* reset the interrupt line */
inb_p(io+7);
inb_p(io+7);
/* trigger an interrupt (I hope) */
inb_p(io+6);
mdelay(2);
autoirq = probe_irq_off(irq_mask);
if (autoirq == 0) {
printk(KERN_ERR "ltpc: probe at %#x failed to detect IRQ line.\n", io);
} else {
irq = autoirq;
}
}
/* allocate a DMA buffer */
ltdmabuf = (unsigned char *) dma_mem_alloc(1000);
if (!ltdmabuf) {
printk(KERN_ERR "ltpc: mem alloc failed\n");
err = -ENOMEM;
goto out2;
}
ltdmacbuf = <dmabuf[800];
if(debug & DEBUG_VERBOSE) {
printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf);
}
/* reset the card */
inb_p(io+1);
inb_p(io+3);
msleep(20);
inb_p(io+0);
inb_p(io+2);
inb_p(io+7); /* clear reset */
inb_p(io+4);
inb_p(io+5);
inb_p(io+5); /* enable dma */
inb_p(io+6); /* tri-state interrupt line */
ssleep(1);
/* now, figure out which dma channel we're using, unless it's
already been specified */
/* well, 0 is a legal DMA channel, but the LTPC card doesn't
use it... */
dma = ltpc_probe_dma(io, dma);
if (!dma) { /* no dma channel */
printk(KERN_ERR "No DMA channel found on ltpc card.\n");
err = -ENODEV;
goto out3;
}
/* print out friendly message */
if(irq)
printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, IR%d, DMA%d.\n",io,irq,dma);
else
printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, DMA%d. Using polled mode.\n",io,dma);
/* Fill in the fields of the device structure with ethernet-generic values. */
dev->hard_start_xmit = ltpc_xmit;
dev->hard_header = ltpc_hard_header;
dev->get_stats = ltpc_get_stats;
/* add the ltpc-specific things */
dev->do_ioctl = <pc_ioctl;
dev->set_multicast_list = &set_multicast_list;
dev->mc_list = NULL;
dev->base_addr = io;
dev->irq = irq;
dev->dma = dma;
/* the card will want to send a result at this point */
/* (I think... leaving out this part makes the kernel crash,
so I put it back in...) */
f=claim_dma_lock();
disable_dma(dma);
clear_dma_ff(dma);
set_dma_mode(dma,DMA_MODE_READ);
set_dma_addr(dma,virt_to_bus(ltdmabuf));
set_dma_count(dma,0x100);
enable_dma(dma);
release_dma_lock(f);
(void) inb_p(io+3);
(void) inb_p(io+2);
timeout = jiffies+100*HZ/100;
while(time_before(jiffies, timeout)) {
if( 0xf9 == inb_p(io+6))
break;
schedule();
}
if(debug & DEBUG_VERBOSE) {
printk("setting up timer and irq\n");
}
/* grab it and don't let go :-) */
if (irq && request_irq( irq, <pc_interrupt, 0, "ltpc", dev) >= 0)
{
(void) inb_p(io+7); /* enable interrupts from board */
(void) inb_p(io+7); /* and reset irq line */
} else {
if( irq )
printk(KERN_ERR "ltpc: IRQ already in use, using polled mode.\n");
dev->irq = 0;
/* polled mode -- 20 times per second */
/* this is really, really slow... should it poll more often? */
init_timer(<pc_timer);
ltpc_timer.function=ltpc_poll;
ltpc_timer.data = (unsigned long) dev;
ltpc_timer.expires = jiffies + HZ/20;
add_timer(<pc_timer);
}
err = register_netdev(dev);
if (err)
goto out4;
return NULL;
out4:
del_timer_sync(<pc_timer);
if (dev->irq)
free_irq(dev->irq, dev);
out3:
free_pages((unsigned long)ltdmabuf, get_order(1000));
out2:
release_region(io, 8);
out1:
free_netdev(dev);
out:
return ERR_PTR(err);
}
static int elp_open(struct net_device *dev)
{
elp_device *adapter = netdev_priv(dev);
int retval;
if (elp_debug >= 3)
pr_debug("%s: request to open device\n", dev->name);
if (adapter == NULL) {
pr_err("%s: Opening a non-existent physical device\n", dev->name);
return -EAGAIN;
}
outb_control(0, dev);
inb_command(dev->base_addr);
adapter_reset(dev);
adapter->rx_active = 0;
adapter->busy = 0;
adapter->send_pcb_semaphore = 0;
adapter->rx_backlog.in = 0;
adapter->rx_backlog.out = 0;
spin_lock_init(&adapter->lock);
if ((retval = request_irq(dev->irq, elp_interrupt, 0, dev->name, dev))) {
pr_err("%s: could not allocate IRQ%d\n", dev->name, dev->irq);
return retval;
}
if ((retval = request_dma(dev->dma, dev->name))) {
free_irq(dev->irq, dev);
pr_err("%s: could not allocate DMA%d channel\n", dev->name, dev->dma);
return retval;
}
adapter->dma_buffer = (void *) dma_mem_alloc(DMA_BUFFER_SIZE);
if (!adapter->dma_buffer) {
pr_err("%s: could not allocate DMA buffer\n", dev->name);
free_dma(dev->dma);
free_irq(dev->irq, dev);
return -ENOMEM;
}
adapter->dmaing = 0;
outb_control(CMDE, dev);
if (elp_debug >= 3)
pr_debug("%s: sending 3c505 memory configuration command\n", dev->name);
adapter->tx_pcb.command = CMD_CONFIGURE_ADAPTER_MEMORY;
adapter->tx_pcb.data.memconf.cmd_q = 10;
adapter->tx_pcb.data.memconf.rcv_q = 20;
adapter->tx_pcb.data.memconf.mcast = 10;
adapter->tx_pcb.data.memconf.frame = 20;
adapter->tx_pcb.data.memconf.rcv_b = 20;
adapter->tx_pcb.data.memconf.progs = 0;
adapter->tx_pcb.length = sizeof(struct Memconf);
adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] = 0;
if (!send_pcb(dev, &adapter->tx_pcb))
pr_err("%s: couldn't send memory configuration command\n", dev->name);
else {
unsigned long timeout = jiffies + TIMEOUT;
while (adapter->got[CMD_CONFIGURE_ADAPTER_MEMORY] == 0 && time_before(jiffies, timeout));
if (time_after_eq(jiffies, timeout))
TIMEOUT_MSG(__LINE__);
}
if (elp_debug >= 3)
pr_debug("%s: sending 82586 configure command\n", dev->name);
adapter->tx_pcb.command = CMD_CONFIGURE_82586;
adapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
adapter->tx_pcb.length = 2;
adapter->got[CMD_CONFIGURE_82586] = 0;
if (!send_pcb(dev, &adapter->tx_pcb))
pr_err("%s: couldn't send 82586 configure command\n", dev->name);
else {
unsigned long timeout = jiffies + TIMEOUT;
while (adapter->got[CMD_CONFIGURE_82586] == 0 && time_before(jiffies, timeout));
if (time_after_eq(jiffies, timeout))
TIMEOUT_MSG(__LINE__);
}
prime_rx(dev);
if (elp_debug >= 3)
pr_debug("%s: %d receive PCBs active\n", dev->name, adapter->rx_active);
netif_start_queue(dev);
return 0;
}
static errval_t device_init_ioat_v3(struct ioat_dma_device *dev)
{
errval_t err;
IOATDEV_DEBUG("initialize Crystal Beach 3 DMA device\n", dev->common.id);
ioat_dma_dmacapability_t cap = ioat_dma_dmacapability_rd(&dev->device);
if (ioat_dma_cbver_minor_extract(dev->version) == 2) {
IOATDEV_DEBUG("disabling XOR and PQ opcodes for Crystal Beach 3.2\n",
dev->common.id);
cap = ioat_dma_dmacapability_xor_insert(cap, 0x0);
cap = ioat_dma_dmacapability_pq_insert(cap, 0x0);
} else if (ioat_dma_cbver_minor_extract(dev->version) == 3) {
IOATDEV_DEBUG("devices of Crystal Beach Version 3.3 are not supported.\n",
dev->common.id);
return DMA_ERR_DEVICE_UNSUPPORTED;
}
/* if DCA is enabled, we cannot support the RAID functions */
if (ioat_dma_dca_is_enabled()) {
IOATDEV_DEBUG("Disabling XOR and PQ while DCA is enabled\n", dev->common.id);
cap = ioat_dma_dmacapability_xor_insert(cap, 0x0);
cap = ioat_dma_dmacapability_pq_insert(cap, 0x0);
}
if (ioat_dma_dmacapability_xor_extract(cap)) {
IOATDEV_DEBUG("device supports XOR RAID.\n", dev->common.id);
dev->flags |= IOAT_DMA_DEV_F_RAID;
/*
* this may need some additional functions to prepare
* the specific transfers...
*
* max_xor = 8;
* prepare_xor, prepare_xor_val
*/
}
if (ioat_dma_dmacapability_pq_extract(cap)) {
IOATDEV_DEBUG("device supports PQ RAID.\n", dev->common.id);
dev->flags |= IOAT_DMA_DEV_F_RAID;
/*
* this may need some additional functions to prepare the
* DMA descriptors
*
* max_xor = 8;
* max_pq = 8;
* prepare_pq, perpare_pq_val
*
* also set the prepare_xor pointers...
*
*/
}
/* set the interrupt type to disabled*/
dev->common.irq_type = DMA_IRQ_DISABLED;
dev->common.type = DMA_DEV_TYPE_IOAT;
/* allocate memory for completion status writeback */
err = dma_mem_alloc(IOAT_DMA_COMPLSTATUS_SIZE, IOAT_DMA_COMPLSTATUS_FLAGS,
&dev->complstatus);
if (err_is_fail(err)) {
return err;
}
dev->common.channels.count = ioat_dma_chancnt_num_rdf(&dev->device);
dev->common.channels.c = calloc(dev->common.channels.count,
sizeof(*dev->common.channels.c));
if (dev->common.channels.c == NULL) {
dma_mem_free(&dev->complstatus);
return LIB_ERR_MALLOC_FAIL;
}
/* channel enumeration */
IOATDEV_DEBUG("channel enumeration. discovered %u channels\n", dev->common.id,
dev->common.channels.count);
uint32_t max_xfer_size = (1 << ioat_dma_xfercap_max_rdf(&dev->device));
for (uint8_t i = 0; i < dev->common.channels.count; ++i) {
struct dma_channel **chan = &dev->common.channels.c[i];
err = ioat_dma_channel_init(dev, i, max_xfer_size,
(struct ioat_dma_channel **) chan);
}
if (dev->flags & IOAT_DMA_DEV_F_DCA) {
/*TODO: DCA initialization device->dca = ioat3_dca_init(pdev, device->reg_base);*/
}
return SYS_ERR_OK;
}
int __init ltpc_probe(struct net_device *dev)
{
int err;
int x=0,y=0;
int timeout;
int autoirq;
unsigned long flags;
unsigned long f;
SET_MODULE_OWNER(dev);
save_flags(flags);
/* probe for the I/O port address */
if (io != 0x240 && !check_region(0x220,8)) {
x = inb_p(0x220+6);
if ( (x!=0xff) && (x>=0xf0) ) io = 0x220;
}
if (io != 0x220 && !check_region(0x240,8)) {
y = inb_p(0x240+6);
if ( (y!=0xff) && (y>=0xf0) ) io = 0x240;
}
if(io) {
/* found it, now grab it */
request_region(io,8,"ltpc");
} else {
/* give up in despair */
printk ("LocalTalk card not found; 220 = %02x, 240 = %02x.\n",
x,y);
restore_flags(flags);
return -1;
}
/* probe for the IRQ line */
if (irq < 2) {
autoirq_setup(2);
/* reset the interrupt line */
inb_p(io+7);
inb_p(io+7);
/* trigger an interrupt (I hope) */
inb_p(io+6);
autoirq = autoirq_report(1);
if (autoirq == 0) {
printk("ltpc: probe at %#x failed to detect IRQ line.\n",
io);
}
else {
irq = autoirq;
}
}
/* allocate a DMA buffer */
ltdmabuf = (unsigned char *) dma_mem_alloc(1000);
if (ltdmabuf) ltdmacbuf = <dmabuf[800];
if (!ltdmabuf) {
printk("ltpc: mem alloc failed\n");
restore_flags(flags);
return(-1);
}
if(debug&DEBUG_VERBOSE) {
printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf);
}
/* reset the card */
inb_p(io+1);
inb_p(io+3);
timeout = jiffies+2*HZ/100;
while(time_before(jiffies, timeout)) ; /* hold it in reset for a coupla jiffies */
inb_p(io+0);
inb_p(io+2);
inb_p(io+7); /* clear reset */
inb_p(io+4);
inb_p(io+5);
inb_p(io+5); /* enable dma */
inb_p(io+6); /* tri-state interrupt line */
timeout = jiffies+100*HZ/100;
while(time_before(jiffies, timeout)) {
/* wait for the card to complete initialization */
}
/* now, figure out which dma channel we're using, unless it's
already been specified */
/* well, 0 is a legal DMA channel, but the LTPC card doesn't
use it... */
if (dma == 0) {
dma = ltpc_probe_dma(io);
if (!dma) { /* no dma channel */
printk("No DMA channel found on ltpc card.\n");
restore_flags(flags);
return -1;
}
}
/* print out friendly message */
if(irq)
printk("Apple/Farallon LocalTalk-PC card at %03x, IR%d, DMA%d.\n",io,irq,dma);
else
printk("Apple/Farallon LocalTalk-PC card at %03x, DMA%d. Using polled mode.\n",io,dma);
/* seems more logical to do this *after* probing the card... */
err = ltpc_init(dev);
if (err) return err;
dev->base_addr = io;
dev->irq = irq;
dev->dma = dma;
/* the card will want to send a result at this point */
/* (I think... leaving out this part makes the kernel crash,
so I put it back in...) */
f=claim_dma_lock();
disable_dma(dma);
clear_dma_ff(dma);
set_dma_mode(dma,DMA_MODE_READ);
set_dma_addr(dma,virt_to_bus(ltdmabuf));
set_dma_count(dma,0x100);
enable_dma(dma);
release_dma_lock(f);
(void) inb_p(io+3);
(void) inb_p(io+2);
timeout = jiffies+100*HZ/100;
while(time_before(jiffies, timeout)) {
if( 0xf9 == inb_p(io+6)) break;
}
if(debug&DEBUG_VERBOSE) {
printk("setting up timer and irq\n");
}
if (irq) {
/* grab it and don't let go :-) */
(void) request_irq( irq, <pc_interrupt, 0, "ltpc", dev);
(void) inb_p(io+7); /* enable interrupts from board */
(void) inb_p(io+7); /* and reset irq line */
} else {
/* polled mode -- 20 times per second */
/* this is really, really slow... should it poll more often? */
init_timer(<pc_timer);
ltpc_timer.function=ltpc_poll;
ltpc_timer.data = (unsigned long) dev;
ltpc_timer.expires = jiffies + 5;
add_timer(<pc_timer);
restore_flags(flags);
}
return 0;
}
