/* * 3c359.c (c) 2000 Mike Phillips (mikep@linuxtr.net) All Rights Reserved * * Linux driver for 3Com 3c359 Tokenlink Velocity XL PCI NIC * * Base Driver Olympic: * Written 1999 Peter De Schrijver & Mike Phillips * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * * 7/17/00 - Clean up, version number 0.9.0. Ready to release to the world. * * 2/16/01 - Port up to kernel 2.4.2 ready for submission into the kernel. * 3/05/01 - Last clean up stuff before submission. * 2/15/01 - Finally, update to new pci api. * * To Do: */ /* * Technical Card Details * * All access to data is done with 16/8 bit transfers. The transfer * method really sucks. You can only read or write one location at a time. * * Also, the microcode for the card must be uploaded if the card does not have * the flashrom on board. This is a 28K bloat in the driver when compiled * as a module. * * Rx is very simple, status into a ring of descriptors, dma data transfer, * interrupts to tell us when a packet is received. * * Tx is a little more interesting. Similar scenario, descriptor and dma data * transfers, but we don't have to interrupt the card to tell it another packet * is ready for transmission, we are just doing simple memory writes, not io or mmio * writes. The card can be set up to simply poll on the next * descriptor pointer and when this value is non-zero will automatically download * the next packet. The card then interrupts us when the packet is done. * */ #define XL_DEBUG 0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "3c359.h" static char version[] __devinitdata = "3c359.c v1.2.0 2/17/01 - Mike Phillips (mikep@linuxtr.net)" ; MODULE_AUTHOR("Mike Phillips ") ; MODULE_DESCRIPTION("3Com 3C359 Velocity XL Token Ring Adapter Driver \n") ; /* Module paramters */ /* Ring Speed 0,4,16 * 0 = Autosense * 4,16 = Selected speed only, no autosense * This allows the card to be the first on the ring * and become the active monitor. * * WARNING: Some hubs will allow you to insert * at the wrong speed. * * The adapter will _not_ fail to open if there are no * active monitors on the ring, it will simply open up in * its last known ringspeed if no ringspeed is specified. */ static int ringspeed[XL_MAX_ADAPTERS] = {0,} ; module_param_array(ringspeed, int, NULL, 0); MODULE_PARM_DESC(ringspeed,"3c359: Ringspeed selection - 4,16 or 0") ; /* Packet buffer size */ static int pkt_buf_sz[XL_MAX_ADAPTERS] = {0,} ; module_param_array(pkt_buf_sz, int, NULL, 0) ; MODULE_PARM_DESC(pkt_buf_sz,"3c359: Initial buffer size") ; /* Message Level */ static int message_level[XL_MAX_ADAPTERS] = {0,} ; module_param_array(message_level, int, NULL, 0) ; MODULE_PARM_DESC(message_level, "3c359: Level of reported messages") ; /* * This is a real nasty way of doing this, but otherwise you * will be stuck with 1555 lines of hex #'s in the code. */ #include "3c359_microcode.h" static struct pci_device_id xl_pci_tbl[] = { {PCI_VENDOR_ID_3COM,PCI_DEVICE_ID_3COM_3C359, PCI_ANY_ID, PCI_ANY_ID, }, { } /* terminate list */ }; MODULE_DEVICE_TABLE(pci,xl_pci_tbl) ; static int xl_init(struct net_device *dev); static int xl_open(struct net_device *dev); static int xl_open_hw(struct net_device *dev) ; static int xl_hw_reset(struct net_device *dev); static int xl_xmit(struct sk_buff *skb, struct net_device *dev); static void xl_dn_comp(struct net_device *dev); static int xl_close(struct net_device *dev); static void xl_set_rx_mode(struct net_device *dev); static irqreturn_t xl_interrupt(int irq, void *dev_id); static int xl_set_mac_address(struct net_device *dev, void *addr) ; static void xl_arb_cmd(struct net_device *dev); static void xl_asb_cmd(struct net_device *dev) ; static void xl_srb_cmd(struct net_device *dev, int srb_cmd) ; static void xl_wait_misr_flags(struct net_device *dev) ; static int xl_change_mtu(struct net_device *dev, int mtu); static void xl_srb_bh(struct net_device *dev) ; static void xl_asb_bh(struct net_device *dev) ; static void xl_reset(struct net_device *dev) ; static void xl_freemem(struct net_device *dev) ; /* EEProm Access Functions */ static u16 xl_ee_read(struct net_device *dev, int ee_addr) ; static void xl_ee_write(struct net_device *dev, int ee_addr, u16 ee_value) ; /* Debugging functions */ #if XL_DEBUG static void print_tx_state(struct net_device *dev) ; static void print_rx_state(struct net_device *dev) ; static void print_tx_state(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); struct xl_tx_desc *txd ; u8 __iomem *xl_mmio = xl_priv->xl_mmio ; int i ; printk("tx_ring_head: %d, tx_ring_tail: %d, free_ent: %d \n",xl_priv->tx_ring_head, xl_priv->tx_ring_tail, xl_priv->free_ring_entries) ; printk("Ring , Address , FSH , DnNextPtr, Buffer, Buffer_Len \n"); for (i = 0; i < 16; i++) { txd = &(xl_priv->xl_tx_ring[i]) ; printk("%d, %08lx, %08x, %08x, %08x, %08x \n", i, virt_to_bus(txd), txd->framestartheader, txd->dnnextptr, txd->buffer, txd->buffer_length ) ; } printk("DNLISTPTR = %04x \n", readl(xl_mmio + MMIO_DNLISTPTR) ); printk("DmaCtl = %04x \n", readl(xl_mmio + MMIO_DMA_CTRL) ); printk("Queue status = %0x \n",netif_running(dev) ) ; } static void print_rx_state(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); struct xl_rx_desc *rxd ; u8 __iomem *xl_mmio = xl_priv->xl_mmio ; int i ; printk("rx_ring_tail: %d \n", xl_priv->rx_ring_tail) ; printk("Ring , Address , FrameState , UPNextPtr, FragAddr, Frag_Len \n"); for (i = 0; i < 16; i++) { /* rxd = (struct xl_rx_desc *)xl_priv->rx_ring_dma_addr + (i * sizeof(struct xl_rx_desc)) ; */ rxd = &(xl_priv->xl_rx_ring[i]) ; printk("%d, %08lx, %08x, %08x, %08x, %08x \n", i, virt_to_bus(rxd), rxd->framestatus, rxd->upnextptr, rxd->upfragaddr, rxd->upfraglen ) ; } printk("UPLISTPTR = %04x \n", readl(xl_mmio + MMIO_UPLISTPTR) ); printk("DmaCtl = %04x \n", readl(xl_mmio + MMIO_DMA_CTRL) ); printk("Queue status = %0x \n",netif_running(dev) ) ; } #endif /* * Read values from the on-board EEProm. This looks very strange * but you have to wait for the EEProm to get/set the value before * passing/getting the next value from the nic. As with all requests * on this nic it has to be done in two stages, a) tell the nic which * memory address you want to access and b) pass/get the value from the nic. * With the EEProm, you have to wait before and inbetween access a) and b). * As this is only read at initialization time and the wait period is very * small we shouldn't have to worry about scheduling issues. */ static u16 xl_ee_read(struct net_device *dev, int ee_addr) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem *xl_mmio = xl_priv->xl_mmio ; /* Wait for EEProm to not be busy */ writel(IO_WORD_READ | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while ( readw(xl_mmio + MMIO_MACDATA) & EEBUSY ) ; /* Tell EEProm what we want to do and where */ writel(IO_WORD_WRITE | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(EEREAD + ee_addr, xl_mmio + MMIO_MACDATA) ; /* Wait for EEProm to not be busy */ writel(IO_WORD_READ | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while ( readw(xl_mmio + MMIO_MACDATA) & EEBUSY ) ; /* Tell EEProm what we want to do and where */ writel(IO_WORD_WRITE | EECONTROL , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(EEREAD + ee_addr, xl_mmio + MMIO_MACDATA) ; /* Finally read the value from the EEProm */ writel(IO_WORD_READ | EEDATA , xl_mmio + MMIO_MAC_ACCESS_CMD) ; return readw(xl_mmio + MMIO_MACDATA) ; } /* * Write values to the onboard eeprom. As with eeprom read you need to * set which location to write, wait, value to write, wait, with the * added twist of having to enable eeprom writes as well. */ static void xl_ee_write(struct net_device *dev, int ee_addr, u16 ee_value) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem *xl_mmio = xl_priv->xl_mmio ; /* Wait for EEProm to not be busy */ writel(IO_WORD_READ | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while ( readw(xl_mmio + MMIO_MACDATA) & EEBUSY ) ; /* Enable write/erase */ writel(IO_WORD_WRITE | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(EE_ENABLE_WRITE, xl_mmio + MMIO_MACDATA) ; /* Wait for EEProm to not be busy */ writel(IO_WORD_READ | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while ( readw(xl_mmio + MMIO_MACDATA) & EEBUSY ) ; /* Put the value we want to write into EEDATA */ writel(IO_WORD_WRITE | EEDATA, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(ee_value, xl_mmio + MMIO_MACDATA) ; /* Tell EEProm to write eevalue into ee_addr */ writel(IO_WORD_WRITE | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(EEWRITE + ee_addr, xl_mmio + MMIO_MACDATA) ; /* Wait for EEProm to not be busy, to ensure write gets done */ writel(IO_WORD_READ | EECONTROL, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while ( readw(xl_mmio + MMIO_MACDATA) & EEBUSY ) ; return ; } static int __devinit xl_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct net_device *dev ; struct xl_private *xl_priv ; static int card_no = -1 ; int i ; card_no++ ; if (pci_enable_device(pdev)) { return -ENODEV ; } pci_set_master(pdev); if ((i = pci_request_regions(pdev,"3c359"))) { return i ; } ; /* * Allowing init_trdev to allocate the private data will align * xl_private on a 32 bytes boundary which we need for the rx/tx * descriptors */ dev = alloc_trdev(sizeof(struct xl_private)) ; if (!dev) { pci_release_regions(pdev) ; return -ENOMEM ; } xl_priv = netdev_priv(dev); #if XL_DEBUG printk("pci_device: %p, dev:%p, dev->priv: %p, ba[0]: %10x, ba[1]:%10x\n", pdev, dev, netdev_priv(dev), (unsigned int)pdev->resource[0].start, (unsigned int)pdev->resource[1].start); #endif dev->irq=pdev->irq; dev->base_addr=pci_resource_start(pdev,0) ; xl_priv->xl_card_name = pci_name(pdev); xl_priv->xl_mmio=ioremap(pci_resource_start(pdev,1), XL_IO_SPACE); xl_priv->pdev = pdev ; if ((pkt_buf_sz[card_no] < 100) || (pkt_buf_sz[card_no] > 18000) ) xl_priv->pkt_buf_sz = PKT_BUF_SZ ; else xl_priv->pkt_buf_sz = pkt_buf_sz[card_no] ; dev->mtu = xl_priv->pkt_buf_sz - TR_HLEN ; xl_priv->xl_ring_speed = ringspeed[card_no] ; xl_priv->xl_message_level = message_level[card_no] ; xl_priv->xl_functional_addr[0] = xl_priv->xl_functional_addr[1] = xl_priv->xl_functional_addr[2] = xl_priv->xl_functional_addr[3] = 0 ; xl_priv->xl_copy_all_options = 0 ; if((i = xl_init(dev))) { iounmap(xl_priv->xl_mmio) ; free_netdev(dev) ; pci_release_regions(pdev) ; return i ; } dev->open=&xl_open; dev->hard_start_xmit=&xl_xmit; dev->change_mtu=&xl_change_mtu; dev->stop=&xl_close; dev->do_ioctl=NULL; dev->set_multicast_list=&xl_set_rx_mode; dev->set_mac_address=&xl_set_mac_address ; SET_NETDEV_DEV(dev, &pdev->dev); pci_set_drvdata(pdev,dev) ; if ((i = register_netdev(dev))) { printk(KERN_ERR "3C359, register netdev failed\n") ; pci_set_drvdata(pdev,NULL) ; iounmap(xl_priv->xl_mmio) ; free_netdev(dev) ; pci_release_regions(pdev) ; return i ; } printk(KERN_INFO "3C359: %s registered as: %s\n",xl_priv->xl_card_name,dev->name) ; return 0; } static int __devinit xl_init(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); printk(KERN_INFO "%s \n", version); printk(KERN_INFO "%s: I/O at %hx, MMIO at %p, using irq %d\n", xl_priv->xl_card_name, (unsigned int)dev->base_addr ,xl_priv->xl_mmio, dev->irq); spin_lock_init(&xl_priv->xl_lock) ; return xl_hw_reset(dev) ; } /* * Hardware reset. This needs to be a separate entity as we need to reset the card * when we change the EEProm settings. */ static int xl_hw_reset(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem *xl_mmio = xl_priv->xl_mmio ; unsigned long t ; u16 i ; u16 result_16 ; u8 result_8 ; u16 start ; int j ; /* * Reset the card. If the card has got the microcode on board, we have * missed the initialization interrupt, so we must always do this. */ writew( GLOBAL_RESET, xl_mmio + MMIO_COMMAND ) ; /* * Must wait for cmdInProgress bit (12) to clear before continuing with * card configuration. */ t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 40 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL card not responding to global reset.\n", dev->name); return -ENODEV; } } /* * Enable pmbar by setting bit in CPAttention */ writel( (IO_BYTE_READ | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; result_8 = readb(xl_mmio + MMIO_MACDATA) ; result_8 = result_8 | CPA_PMBARVIS ; writel( (IO_BYTE_WRITE | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(result_8, xl_mmio + MMIO_MACDATA) ; /* * Read cpHold bit in pmbar, if cleared we have got Flashrom on board. * If not, we need to upload the microcode to the card */ writel( (IO_WORD_READ | PMBAR),xl_mmio + MMIO_MAC_ACCESS_CMD); #if XL_DEBUG printk(KERN_INFO "Read from PMBAR = %04x \n", readw(xl_mmio + MMIO_MACDATA)) ; #endif if ( readw( (xl_mmio + MMIO_MACDATA)) & PMB_CPHOLD ) { /* Set PmBar, privateMemoryBase bits (8:2) to 0 */ writel( (IO_WORD_READ | PMBAR),xl_mmio + MMIO_MAC_ACCESS_CMD); result_16 = readw(xl_mmio + MMIO_MACDATA) ; result_16 = result_16 & ~((0x7F) << 2) ; writel( (IO_WORD_WRITE | PMBAR), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(result_16,xl_mmio + MMIO_MACDATA) ; /* Set CPAttention, memWrEn bit */ writel( (IO_BYTE_READ | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; result_8 = readb(xl_mmio + MMIO_MACDATA) ; result_8 = result_8 | CPA_MEMWREN ; writel( (IO_BYTE_WRITE | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(result_8, xl_mmio + MMIO_MACDATA) ; /* * Now to write the microcode into the shared ram * The microcode must finish at position 0xFFFF, so we must subtract * to get the start position for the code */ start = (0xFFFF - (mc_size) + 1 ) ; /* Looks strange but ensures compiler only uses 16 bit unsigned int for this */ printk(KERN_INFO "3C359: Uploading Microcode: "); for (i = start, j = 0; j < mc_size; i++, j++) { writel(MEM_BYTE_WRITE | 0XD0000 | i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(microcode[j],xl_mmio + MMIO_MACDATA) ; if (j % 1024 == 0) printk("."); } printk("\n") ; for (i=0;i < 16; i++) { writel( (MEM_BYTE_WRITE | 0xDFFF0) + i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(microcode[mc_size - 16 + i], xl_mmio + MMIO_MACDATA) ; } /* * Have to write the start address of the upload to FFF4, but * the address must be >> 4. You do not want to know how long * it took me to discover this. */ writel(MEM_WORD_WRITE | 0xDFFF4, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(start >> 4, xl_mmio + MMIO_MACDATA); /* Clear the CPAttention, memWrEn Bit */ writel( (IO_BYTE_READ | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; result_8 = readb(xl_mmio + MMIO_MACDATA) ; result_8 = result_8 & ~CPA_MEMWREN ; writel( (IO_BYTE_WRITE | CPATTENTION), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(result_8, xl_mmio + MMIO_MACDATA) ; /* Clear the cpHold bit in pmbar */ writel( (IO_WORD_READ | PMBAR),xl_mmio + MMIO_MAC_ACCESS_CMD); result_16 = readw(xl_mmio + MMIO_MACDATA) ; result_16 = result_16 & ~PMB_CPHOLD ; writel( (IO_WORD_WRITE | PMBAR), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(result_16,xl_mmio + MMIO_MACDATA) ; } /* If microcode upload required */ /* * The card should now go though a self test procedure and get itself ready * to be opened, we must wait for an srb response with the initialization * information. */ #if XL_DEBUG printk(KERN_INFO "%s: Microcode uploaded, must wait for the self test to complete\n", dev->name); #endif writew(SETINDENABLE | 0xFFF, xl_mmio + MMIO_COMMAND) ; t=jiffies; while ( !(readw(xl_mmio + MMIO_INTSTATUS_AUTO) & INTSTAT_SRB) ) { schedule(); if (time_after(jiffies, t + 15 * HZ)) { printk(KERN_ERR "3COM 3C359 Velocity XL card not responding.\n"); return -ENODEV; } } /* * Write the RxBufArea with D000, RxEarlyThresh, TxStartThresh, * DnPriReqThresh, read the tech docs if you want to know what * values they need to be. */ writel(MMIO_WORD_WRITE | RXBUFAREA, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(0xD000, xl_mmio + MMIO_MACDATA) ; writel(MMIO_WORD_WRITE | RXEARLYTHRESH, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(0X0020, xl_mmio + MMIO_MACDATA) ; writew( SETTXSTARTTHRESH | 0x40 , xl_mmio + MMIO_COMMAND) ; writeb(0x04, xl_mmio + MMIO_DNBURSTTHRESH) ; writeb(0x04, xl_mmio + DNPRIREQTHRESH) ; /* * Read WRBR to provide the location of the srb block, have to use byte reads not word reads. * Tech docs have this wrong !!!! */ writel(MMIO_BYTE_READ | WRBR, xl_mmio + MMIO_MAC_ACCESS_CMD) ; xl_priv->srb = readb(xl_mmio + MMIO_MACDATA) << 8 ; writel( (MMIO_BYTE_READ | WRBR) + 1, xl_mmio + MMIO_MAC_ACCESS_CMD) ; xl_priv->srb = xl_priv->srb | readb(xl_mmio + MMIO_MACDATA) ; #if XL_DEBUG writel(IO_WORD_READ | SWITCHSETTINGS, xl_mmio + MMIO_MAC_ACCESS_CMD) ; if ( readw(xl_mmio + MMIO_MACDATA) & 2) { printk(KERN_INFO "Default ring speed 4 mbps \n") ; } else { printk(KERN_INFO "Default ring speed 16 mbps \n") ; } printk(KERN_INFO "%s: xl_priv->srb = %04x\n",xl_priv->xl_card_name, xl_priv->srb); #endif return 0; } static int xl_open(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); u8 __iomem *xl_mmio = xl_priv->xl_mmio ; u8 i ; __le16 hwaddr[3] ; /* Should be u8[6] but we get word return values */ int open_err ; u16 switchsettings, switchsettings_eeprom ; if(request_irq(dev->irq, &xl_interrupt, IRQF_SHARED , "3c359", dev)) { return -EAGAIN; } /* * Read the information from the EEPROM that we need. */ hwaddr[0] = cpu_to_le16(xl_ee_read(dev,0x10)); hwaddr[1] = cpu_to_le16(xl_ee_read(dev,0x11)); hwaddr[2] = cpu_to_le16(xl_ee_read(dev,0x12)); /* Ring speed */ switchsettings_eeprom = xl_ee_read(dev,0x08) ; switchsettings = switchsettings_eeprom ; if (xl_priv->xl_ring_speed != 0) { if (xl_priv->xl_ring_speed == 4) switchsettings = switchsettings | 0x02 ; else switchsettings = switchsettings & ~0x02 ; } /* Only write EEProm if there has been a change */ if (switchsettings != switchsettings_eeprom) { xl_ee_write(dev,0x08,switchsettings) ; /* Hardware reset after changing EEProm */ xl_hw_reset(dev) ; } memcpy(dev->dev_addr,hwaddr,dev->addr_len) ; open_err = xl_open_hw(dev) ; /* * This really needs to be cleaned up with better error reporting. */ if (open_err != 0) { /* Something went wrong with the open command */ if (open_err & 0x07) { /* Wrong speed, retry at different speed */ printk(KERN_WARNING "%s: Open Error, retrying at different ringspeed \n", dev->name) ; switchsettings = switchsettings ^ 2 ; xl_ee_write(dev,0x08,switchsettings) ; xl_hw_reset(dev) ; open_err = xl_open_hw(dev) ; if (open_err != 0) { printk(KERN_WARNING "%s: Open error returned a second time, we're bombing out now\n", dev->name); free_irq(dev->irq,dev) ; return -ENODEV ; } } else { printk(KERN_WARNING "%s: Open Error = %04x\n", dev->name, open_err) ; free_irq(dev->irq,dev) ; return -ENODEV ; } } /* * Now to set up the Rx and Tx buffer structures */ /* These MUST be on 8 byte boundaries */ xl_priv->xl_tx_ring = kzalloc((sizeof(struct xl_tx_desc) * XL_TX_RING_SIZE) + 7, GFP_DMA | GFP_KERNEL); if (xl_priv->xl_tx_ring == NULL) { printk(KERN_WARNING "%s: Not enough memory to allocate tx buffers.\n", dev->name); free_irq(dev->irq,dev); return -ENOMEM; } xl_priv->xl_rx_ring = kzalloc((sizeof(struct xl_rx_desc) * XL_RX_RING_SIZE) +7, GFP_DMA | GFP_KERNEL); if (xl_priv->xl_rx_ring == NULL) { printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers.\n", dev->name); free_irq(dev->irq,dev); kfree(xl_priv->xl_tx_ring); return -ENOMEM; } /* Setup Rx Ring */ for (i=0 ; i < XL_RX_RING_SIZE ; i++) { struct sk_buff *skb ; skb = dev_alloc_skb(xl_priv->pkt_buf_sz) ; if (skb==NULL) break ; skb->dev = dev ; xl_priv->xl_rx_ring[i].upfragaddr = cpu_to_le32(pci_map_single(xl_priv->pdev, skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)); xl_priv->xl_rx_ring[i].upfraglen = cpu_to_le32(xl_priv->pkt_buf_sz) | RXUPLASTFRAG; xl_priv->rx_ring_skb[i] = skb ; } if (i==0) { printk(KERN_WARNING "%s: Not enough memory to allocate rx buffers. Adapter disabled \n",dev->name) ; free_irq(dev->irq,dev) ; kfree(xl_priv->xl_tx_ring); kfree(xl_priv->xl_rx_ring); return -EIO ; } xl_priv->rx_ring_no = i ; xl_priv->rx_ring_tail = 0 ; xl_priv->rx_ring_dma_addr = pci_map_single(xl_priv->pdev,xl_priv->xl_rx_ring, sizeof(struct xl_rx_desc) * XL_RX_RING_SIZE, PCI_DMA_TODEVICE) ; for (i=0;i<(xl_priv->rx_ring_no-1);i++) { xl_priv->xl_rx_ring[i].upnextptr = cpu_to_le32(xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * (i+1))); } xl_priv->xl_rx_ring[i].upnextptr = 0 ; writel(xl_priv->rx_ring_dma_addr, xl_mmio + MMIO_UPLISTPTR) ; /* Setup Tx Ring */ xl_priv->tx_ring_dma_addr = pci_map_single(xl_priv->pdev,xl_priv->xl_tx_ring, sizeof(struct xl_tx_desc) * XL_TX_RING_SIZE,PCI_DMA_TODEVICE) ; xl_priv->tx_ring_head = 1 ; xl_priv->tx_ring_tail = 255 ; /* Special marker for first packet */ xl_priv->free_ring_entries = XL_TX_RING_SIZE ; /* * Setup the first dummy DPD entry for polling to start working. */ xl_priv->xl_tx_ring[0].framestartheader = TXDPDEMPTY; xl_priv->xl_tx_ring[0].buffer = 0 ; xl_priv->xl_tx_ring[0].buffer_length = 0 ; xl_priv->xl_tx_ring[0].dnnextptr = 0 ; writel(xl_priv->tx_ring_dma_addr, xl_mmio + MMIO_DNLISTPTR) ; writel(DNUNSTALL, xl_mmio + MMIO_COMMAND) ; writel(UPUNSTALL, xl_mmio + MMIO_COMMAND) ; writel(DNENABLE, xl_mmio + MMIO_COMMAND) ; writeb(0x40, xl_mmio + MMIO_DNPOLL) ; /* * Enable interrupts on the card */ writel(SETINTENABLE | INT_MASK, xl_mmio + MMIO_COMMAND) ; writel(SETINDENABLE | INT_MASK, xl_mmio + MMIO_COMMAND) ; netif_start_queue(dev) ; return 0; } static int xl_open_hw(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); u8 __iomem *xl_mmio = xl_priv->xl_mmio ; u16 vsoff ; char ver_str[33]; int open_err ; int i ; unsigned long t ; /* * Okay, let's build up the Open.NIC srb command * */ writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb), xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(OPEN_NIC, xl_mmio + MMIO_MACDATA) ; /* * Use this as a test byte, if it comes back with the same value, the command didn't work */ writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb)+ 2, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0xff,xl_mmio + MMIO_MACDATA) ; /* Open options */ writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb) + 8, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0x00, xl_mmio + MMIO_MACDATA) ; writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb) + 9, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0x00, xl_mmio + MMIO_MACDATA) ; /* * Node address, be careful here, the docs say you can just put zeros here and it will use * the hardware address, it doesn't, you must include the node address in the open command. */ if (xl_priv->xl_laa[0]) { /* If using a LAA address */ for (i=10;i<16;i++) { writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb) + i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(xl_priv->xl_laa[i-10],xl_mmio + MMIO_MACDATA) ; } memcpy(dev->dev_addr,xl_priv->xl_laa,dev->addr_len) ; } else { /* Regular hardware address */ for (i=10;i<16;i++) { writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb) + i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(dev->dev_addr[i-10], xl_mmio + MMIO_MACDATA) ; } } /* Default everything else to 0 */ for (i = 16; i < 34; i++) { writel( (MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb) + i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0x00,xl_mmio + MMIO_MACDATA) ; } /* * Set the csrb bit in the MISR register */ xl_wait_misr_flags(dev) ; writel(MEM_BYTE_WRITE | MF_CSRB, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0xFF, xl_mmio + MMIO_MACDATA) ; writel(MMIO_BYTE_WRITE | MISR_SET, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(MISR_CSRB , xl_mmio + MMIO_MACDATA) ; /* * Now wait for the command to run */ t=jiffies; while (! (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_SRB)) { schedule(); if (time_after(jiffies, t + 40 * HZ)) { printk(KERN_ERR "3COM 3C359 Velocity XL card not responding.\n"); break ; } } /* * Let's interpret the open response */ writel( (MEM_BYTE_READ | 0xD0000 | xl_priv->srb)+2, xl_mmio + MMIO_MAC_ACCESS_CMD) ; if (readb(xl_mmio + MMIO_MACDATA)!=0) { open_err = readb(xl_mmio + MMIO_MACDATA) << 8 ; writel( (MEM_BYTE_READ | 0xD0000 | xl_priv->srb) + 7, xl_mmio + MMIO_MAC_ACCESS_CMD) ; open_err |= readb(xl_mmio + MMIO_MACDATA) ; return open_err ; } else { writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 8, xl_mmio + MMIO_MAC_ACCESS_CMD) ; xl_priv->asb = swab16(readw(xl_mmio + MMIO_MACDATA)) ; printk(KERN_INFO "%s: Adapter Opened Details: ",dev->name) ; printk("ASB: %04x",xl_priv->asb ) ; writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 10, xl_mmio + MMIO_MAC_ACCESS_CMD) ; printk(", SRB: %04x",swab16(readw(xl_mmio + MMIO_MACDATA)) ) ; writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 12, xl_mmio + MMIO_MAC_ACCESS_CMD) ; xl_priv->arb = swab16(readw(xl_mmio + MMIO_MACDATA)) ; printk(", ARB: %04x \n",xl_priv->arb ) ; writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 14, xl_mmio + MMIO_MAC_ACCESS_CMD) ; vsoff = swab16(readw(xl_mmio + MMIO_MACDATA)) ; /* * Interesting, sending the individual characters directly to printk was causing klogd to use * use 100% of processor time, so we build up the string and print that instead. */ for (i=0;i<0x20;i++) { writel( (MEM_BYTE_READ | 0xD0000 | vsoff) + i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; ver_str[i] = readb(xl_mmio + MMIO_MACDATA) ; } ver_str[i] = '\0' ; printk(KERN_INFO "%s: Microcode version String: %s \n",dev->name,ver_str); } /* * Issue the AckInterrupt */ writew(ACK_INTERRUPT | SRBRACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; return 0 ; } /* * There are two ways of implementing rx on the 359 NIC, either * interrupt driven or polling. We are going to uses interrupts, * it is the easier way of doing things. * * The Rx works with a ring of Rx descriptors. At initialise time the ring * entries point to the next entry except for the last entry in the ring * which points to 0. The card is programmed with the location of the first * available descriptor and keeps reading the next_ptr until next_ptr is set * to 0. Hopefully with a ring size of 16 the card will never get to read a next_ptr * of 0. As the Rx interrupt is received we copy the frame up to the protocol layers * and then point the end of the ring to our current position and point our current * position to 0, therefore making the current position the last position on the ring. * The last position on the ring therefore loops continually loops around the rx ring. * * rx_ring_tail is the position on the ring to process next. (Think of a snake, the head * expands as the card adds new packets and we go around eating the tail processing the * packets.) * * Undoubtably it could be streamlined and improved upon, but at the moment it works * and the fast path through the routine is fine. * * adv_rx_ring could be inlined to increase performance, but its called a *lot* of times * in xl_rx so would increase the size of the function significantly. */ static void adv_rx_ring(struct net_device *dev) /* Advance rx_ring, cut down on bloat in xl_rx */ { struct xl_private *xl_priv=netdev_priv(dev); int n = xl_priv->rx_ring_tail; int prev_ring_loc; prev_ring_loc = (n + XL_RX_RING_SIZE - 1) & (XL_RX_RING_SIZE - 1); xl_priv->xl_rx_ring[prev_ring_loc].upnextptr = cpu_to_le32(xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * n)); xl_priv->xl_rx_ring[n].framestatus = 0; xl_priv->xl_rx_ring[n].upnextptr = 0; xl_priv->rx_ring_tail++; xl_priv->rx_ring_tail &= (XL_RX_RING_SIZE-1); } static void xl_rx(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; struct sk_buff *skb, *skb2 ; int frame_length = 0, copy_len = 0 ; int temp_ring_loc ; /* * Receive the next frame, loop around the ring until all frames * have been received. */ while (xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus & (RXUPDCOMPLETE | RXUPDFULL) ) { /* Descriptor to process */ if (xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus & RXUPDFULL ) { /* UpdFull, Multiple Descriptors used for the frame */ /* * This is a pain, you need to go through all the descriptors until the last one * for this frame to find the framelength */ temp_ring_loc = xl_priv->rx_ring_tail ; while (xl_priv->xl_rx_ring[temp_ring_loc].framestatus & RXUPDFULL ) { temp_ring_loc++ ; temp_ring_loc &= (XL_RX_RING_SIZE-1) ; } frame_length = le32_to_cpu(xl_priv->xl_rx_ring[temp_ring_loc].framestatus) & 0x7FFF; skb = dev_alloc_skb(frame_length) ; if (skb==NULL) { /* No memory for frame, still need to roll forward the rx ring */ printk(KERN_WARNING "%s: dev_alloc_skb failed - multi buffer !\n", dev->name) ; while (xl_priv->rx_ring_tail != temp_ring_loc) adv_rx_ring(dev) ; adv_rx_ring(dev) ; /* One more time just for luck :) */ dev->stats.rx_dropped++ ; writel(ACK_INTERRUPT | UPCOMPACK | LATCH_ACK , xl_mmio + MMIO_COMMAND) ; return ; } while (xl_priv->rx_ring_tail != temp_ring_loc) { copy_len = le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen) & 0x7FFF; frame_length -= copy_len ; pci_dma_sync_single_for_cpu(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE); skb_copy_from_linear_data(xl_priv->rx_ring_skb[xl_priv->rx_ring_tail], skb_put(skb, copy_len), copy_len); pci_dma_sync_single_for_device(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE); adv_rx_ring(dev) ; } /* Now we have found the last fragment */ pci_dma_sync_single_for_cpu(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE); skb_copy_from_linear_data(xl_priv->rx_ring_skb[xl_priv->rx_ring_tail], skb_put(skb,copy_len), frame_length); /* memcpy(skb_put(skb,frame_length), bus_to_virt(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr), frame_length) ; */ pci_dma_sync_single_for_device(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE); adv_rx_ring(dev) ; skb->protocol = tr_type_trans(skb,dev) ; netif_rx(skb) ; } else { /* Single Descriptor Used, simply swap buffers over, fast path */ frame_length = le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus) & 0x7FFF; skb = dev_alloc_skb(xl_priv->pkt_buf_sz) ; if (skb==NULL) { /* Still need to fix the rx ring */ printk(KERN_WARNING "%s: dev_alloc_skb failed in rx, single buffer \n",dev->name) ; adv_rx_ring(dev) ; dev->stats.rx_dropped++ ; writel(ACK_INTERRUPT | UPCOMPACK | LATCH_ACK , xl_mmio + MMIO_COMMAND) ; return ; } skb2 = xl_priv->rx_ring_skb[xl_priv->rx_ring_tail] ; pci_unmap_single(xl_priv->pdev, le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr), xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ; skb_put(skb2, frame_length) ; skb2->protocol = tr_type_trans(skb2,dev) ; xl_priv->rx_ring_skb[xl_priv->rx_ring_tail] = skb ; xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr = cpu_to_le32(pci_map_single(xl_priv->pdev,skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE)); xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen = cpu_to_le32(xl_priv->pkt_buf_sz) | RXUPLASTFRAG; adv_rx_ring(dev) ; dev->stats.rx_packets++ ; dev->stats.rx_bytes += frame_length ; netif_rx(skb2) ; } /* if multiple buffers */ } /* while packet to do */ /* Clear the updComplete interrupt */ writel(ACK_INTERRUPT | UPCOMPACK | LATCH_ACK , xl_mmio + MMIO_COMMAND) ; return ; } /* * This is ruthless, it doesn't care what state the card is in it will * completely reset the adapter. */ static void xl_reset(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; unsigned long t; writew( GLOBAL_RESET, xl_mmio + MMIO_COMMAND ) ; /* * Must wait for cmdInProgress bit (12) to clear before continuing with * card configuration. */ t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { if (time_after(jiffies, t + 40 * HZ)) { printk(KERN_ERR "3COM 3C359 Velocity XL card not responding.\n"); break ; } } } static void xl_freemem(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); int i ; for (i=0;irx_ring_skb[xl_priv->rx_ring_tail]) ; pci_unmap_single(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE); xl_priv->rx_ring_tail++ ; xl_priv->rx_ring_tail &= XL_RX_RING_SIZE-1; } /* unmap ring */ pci_unmap_single(xl_priv->pdev,xl_priv->rx_ring_dma_addr, sizeof(struct xl_rx_desc) * XL_RX_RING_SIZE, PCI_DMA_FROMDEVICE) ; pci_unmap_single(xl_priv->pdev,xl_priv->tx_ring_dma_addr, sizeof(struct xl_tx_desc) * XL_TX_RING_SIZE, PCI_DMA_TODEVICE) ; kfree(xl_priv->xl_rx_ring) ; kfree(xl_priv->xl_tx_ring) ; return ; } static irqreturn_t xl_interrupt(int irq, void *dev_id) { struct net_device *dev = (struct net_device *)dev_id; struct xl_private *xl_priv =netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; u16 intstatus, macstatus ; intstatus = readw(xl_mmio + MMIO_INTSTATUS) ; if (!(intstatus & 1)) /* We didn't generate the interrupt */ return IRQ_NONE; spin_lock(&xl_priv->xl_lock) ; /* * Process the interrupt */ /* * Something fishy going on here, we shouldn't get 0001 ints, not fatal though. */ if (intstatus == 0x0001) { writel(ACK_INTERRUPT | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; printk(KERN_INFO "%s: 00001 int received \n",dev->name) ; } else { if (intstatus & (HOSTERRINT | SRBRINT | ARBCINT | UPCOMPINT | DNCOMPINT | HARDERRINT | (1<<8) | TXUNDERRUN | ASBFINT)) { /* * Host Error. * It may be possible to recover from this, but usually it means something * is seriously fubar, so we just close the adapter. */ if (intstatus & HOSTERRINT) { printk(KERN_WARNING "%s: Host Error, performing global reset, intstatus = %04x \n",dev->name,intstatus) ; writew( GLOBAL_RESET, xl_mmio + MMIO_COMMAND ) ; printk(KERN_WARNING "%s: Resetting hardware: \n", dev->name); netif_stop_queue(dev) ; xl_freemem(dev) ; free_irq(dev->irq,dev); xl_reset(dev) ; writel(ACK_INTERRUPT | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; spin_unlock(&xl_priv->xl_lock) ; return IRQ_HANDLED; } /* Host Error */ if (intstatus & SRBRINT ) { /* Srbc interrupt */ writel(ACK_INTERRUPT | SRBRACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; if (xl_priv->srb_queued) xl_srb_bh(dev) ; } /* SRBR Interrupt */ if (intstatus & TXUNDERRUN) { /* Issue DnReset command */ writel(DNRESET, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { /* Wait for command to run */ /* !!! FIX-ME !!!! Must put a timeout check here ! */ /* Empty Loop */ } printk(KERN_WARNING "%s: TX Underrun received \n",dev->name) ; writel(ACK_INTERRUPT | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; } /* TxUnderRun */ if (intstatus & ARBCINT ) { /* Arbc interrupt */ xl_arb_cmd(dev) ; } /* Arbc */ if (intstatus & ASBFINT) { if (xl_priv->asb_queued == 1) { xl_asb_cmd(dev) ; } else if (xl_priv->asb_queued == 2) { xl_asb_bh(dev) ; } else { writel(ACK_INTERRUPT | LATCH_ACK | ASBFACK, xl_mmio + MMIO_COMMAND) ; } } /* Asbf */ if (intstatus & UPCOMPINT ) /* UpComplete */ xl_rx(dev) ; if (intstatus & DNCOMPINT ) /* DnComplete */ xl_dn_comp(dev) ; if (intstatus & HARDERRINT ) { /* Hardware error */ writel(MMIO_WORD_READ | MACSTATUS, xl_mmio + MMIO_MAC_ACCESS_CMD) ; macstatus = readw(xl_mmio + MMIO_MACDATA) ; printk(KERN_WARNING "%s: MacStatusError, details: ", dev->name); if (macstatus & (1<<14)) printk(KERN_WARNING "tchk error: Unrecoverable error \n") ; if (macstatus & (1<<3)) printk(KERN_WARNING "eint error: Internal watchdog timer expired \n") ; if (macstatus & (1<<2)) printk(KERN_WARNING "aint error: Host tried to perform invalid operation \n") ; printk(KERN_WARNING "Instatus = %02x, macstatus = %02x\n",intstatus,macstatus) ; printk(KERN_WARNING "%s: Resetting hardware: \n", dev->name); netif_stop_queue(dev) ; xl_freemem(dev) ; free_irq(dev->irq,dev); unregister_netdev(dev) ; free_netdev(dev) ; xl_reset(dev) ; writel(ACK_INTERRUPT | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; spin_unlock(&xl_priv->xl_lock) ; return IRQ_HANDLED; } } else { printk(KERN_WARNING "%s: Received Unknown interrupt : %04x \n", dev->name, intstatus) ; writel(ACK_INTERRUPT | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; } } /* Turn interrupts back on */ writel( SETINDENABLE | INT_MASK, xl_mmio + MMIO_COMMAND) ; writel( SETINTENABLE | INT_MASK, xl_mmio + MMIO_COMMAND) ; spin_unlock(&xl_priv->xl_lock) ; return IRQ_HANDLED; } /* * Tx - Polling configuration */ static int xl_xmit(struct sk_buff *skb, struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); struct xl_tx_desc *txd ; int tx_head, tx_tail, tx_prev ; unsigned long flags ; spin_lock_irqsave(&xl_priv->xl_lock,flags) ; netif_stop_queue(dev) ; if (xl_priv->free_ring_entries > 1 ) { /* * Set up the descriptor for the packet */ tx_head = xl_priv->tx_ring_head ; tx_tail = xl_priv->tx_ring_tail ; txd = &(xl_priv->xl_tx_ring[tx_head]) ; txd->dnnextptr = 0 ; txd->framestartheader = cpu_to_le32(skb->len) | TXDNINDICATE; txd->buffer = cpu_to_le32(pci_map_single(xl_priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE)); txd->buffer_length = cpu_to_le32(skb->len) | TXDNFRAGLAST; xl_priv->tx_ring_skb[tx_head] = skb ; dev->stats.tx_packets++ ; dev->stats.tx_bytes += skb->len ; /* * Set the nextptr of the previous descriptor equal to this descriptor, add XL_TX_RING_SIZE -1 * to ensure no negative numbers in unsigned locations. */ tx_prev = (xl_priv->tx_ring_head + XL_TX_RING_SIZE - 1) & (XL_TX_RING_SIZE - 1) ; xl_priv->tx_ring_head++ ; xl_priv->tx_ring_head &= (XL_TX_RING_SIZE - 1) ; xl_priv->free_ring_entries-- ; xl_priv->xl_tx_ring[tx_prev].dnnextptr = cpu_to_le32(xl_priv->tx_ring_dma_addr + (sizeof (struct xl_tx_desc) * tx_head)); /* Sneaky, by doing a read on DnListPtr we can force the card to poll on the DnNextPtr */ /* readl(xl_mmio + MMIO_DNLISTPTR) ; */ netif_wake_queue(dev) ; spin_unlock_irqrestore(&xl_priv->xl_lock,flags) ; return 0; } else { spin_unlock_irqrestore(&xl_priv->xl_lock,flags) ; return 1; } } /* * The NIC has told us that a packet has been downloaded onto the card, we must * find out which packet it has done, clear the skb and information for the packet * then advance around the ring for all tranmitted packets */ static void xl_dn_comp(struct net_device *dev) { struct xl_private *xl_priv=netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; struct xl_tx_desc *txd ; if (xl_priv->tx_ring_tail == 255) {/* First time */ xl_priv->xl_tx_ring[0].framestartheader = 0 ; xl_priv->xl_tx_ring[0].dnnextptr = 0 ; xl_priv->tx_ring_tail = 1 ; } while (xl_priv->xl_tx_ring[xl_priv->tx_ring_tail].framestartheader & TXDNCOMPLETE ) { txd = &(xl_priv->xl_tx_ring[xl_priv->tx_ring_tail]) ; pci_unmap_single(xl_priv->pdev, le32_to_cpu(txd->buffer), xl_priv->tx_ring_skb[xl_priv->tx_ring_tail]->len, PCI_DMA_TODEVICE); txd->framestartheader = 0 ; txd->buffer = cpu_to_le32(0xdeadbeef); txd->buffer_length = 0 ; dev_kfree_skb_irq(xl_priv->tx_ring_skb[xl_priv->tx_ring_tail]) ; xl_priv->tx_ring_tail++ ; xl_priv->tx_ring_tail &= (XL_TX_RING_SIZE - 1) ; xl_priv->free_ring_entries++ ; } netif_wake_queue(dev) ; writel(ACK_INTERRUPT | DNCOMPACK | LATCH_ACK , xl_mmio + MMIO_COMMAND) ; } /* * Close the adapter properly. * This srb reply cannot be handled from interrupt context as we have * to free the interrupt from the driver. */ static int xl_close(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; unsigned long t ; netif_stop_queue(dev) ; /* * Close the adapter, need to stall the rx and tx queues. */ writew(DNSTALL, xl_mmio + MMIO_COMMAND) ; t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-DNSTALL not responding.\n", dev->name); break ; } } writew(DNDISABLE, xl_mmio + MMIO_COMMAND) ; t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-DNDISABLE not responding.\n", dev->name); break ; } } writew(UPSTALL, xl_mmio + MMIO_COMMAND) ; t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-UPSTALL not responding.\n", dev->name); break ; } } /* Turn off interrupts, we will still get the indication though * so we can trap it */ writel(SETINTENABLE, xl_mmio + MMIO_COMMAND) ; xl_srb_cmd(dev,CLOSE_NIC) ; t=jiffies; while (!(readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_SRB)) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-CLOSENIC not responding.\n", dev->name); break ; } } /* Read the srb response from the adapter */ writel(MEM_BYTE_READ | 0xd0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD); if (readb(xl_mmio + MMIO_MACDATA) != CLOSE_NIC) { printk(KERN_INFO "%s: CLOSE_NIC did not get a CLOSE_NIC response \n",dev->name) ; } else { writel((MEM_BYTE_READ | 0xd0000 | xl_priv->srb) +2, xl_mmio + MMIO_MAC_ACCESS_CMD) ; if (readb(xl_mmio + MMIO_MACDATA)==0) { printk(KERN_INFO "%s: Adapter has been closed \n",dev->name) ; writew(ACK_INTERRUPT | SRBRACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; xl_freemem(dev) ; free_irq(dev->irq,dev) ; } else { printk(KERN_INFO "%s: Close nic command returned error code %02x\n",dev->name, readb(xl_mmio + MMIO_MACDATA)) ; } } /* Reset the upload and download logic */ writew(UPRESET, xl_mmio + MMIO_COMMAND) ; t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-UPRESET not responding.\n", dev->name); break ; } } writew(DNRESET, xl_mmio + MMIO_COMMAND) ; t=jiffies; while (readw(xl_mmio + MMIO_INTSTATUS) & INTSTAT_CMD_IN_PROGRESS) { schedule(); if (time_after(jiffies, t + 10 * HZ)) { printk(KERN_ERR "%s: 3COM 3C359 Velocity XL-DNRESET not responding.\n", dev->name); break ; } } xl_hw_reset(dev) ; return 0 ; } static void xl_set_rx_mode(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); struct dev_mc_list *dmi ; unsigned char dev_mc_address[4] ; u16 options ; int i ; if (dev->flags & IFF_PROMISC) options = 0x0004 ; else options = 0x0000 ; if (options ^ xl_priv->xl_copy_all_options) { /* Changed, must send command */ xl_priv->xl_copy_all_options = options ; xl_srb_cmd(dev, SET_RECEIVE_MODE) ; return ; } dev_mc_address[0] = dev_mc_address[1] = dev_mc_address[2] = dev_mc_address[3] = 0 ; for (i=0,dmi=dev->mc_list;i < dev->mc_count; i++,dmi = dmi->next) { dev_mc_address[0] |= dmi->dmi_addr[2] ; dev_mc_address[1] |= dmi->dmi_addr[3] ; dev_mc_address[2] |= dmi->dmi_addr[4] ; dev_mc_address[3] |= dmi->dmi_addr[5] ; } if (memcmp(xl_priv->xl_functional_addr,dev_mc_address,4) != 0) { /* Options have changed, run the command */ memcpy(xl_priv->xl_functional_addr, dev_mc_address,4) ; xl_srb_cmd(dev, SET_FUNC_ADDRESS) ; } return ; } /* * We issued an srb command and now we must read * the response from the completed command. */ static void xl_srb_bh(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; u8 srb_cmd, ret_code ; int i ; writel(MEM_BYTE_READ | 0xd0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; srb_cmd = readb(xl_mmio + MMIO_MACDATA) ; writel((MEM_BYTE_READ | 0xd0000 | xl_priv->srb) +2, xl_mmio + MMIO_MAC_ACCESS_CMD) ; ret_code = readb(xl_mmio + MMIO_MACDATA) ; /* Ret_code is standard across all commands */ switch (ret_code) { case 1: printk(KERN_INFO "%s: Command: %d - Invalid Command code\n",dev->name,srb_cmd) ; break ; case 4: printk(KERN_INFO "%s: Command: %d - Adapter is closed, must be open for this command \n",dev->name,srb_cmd) ; break ; case 6: printk(KERN_INFO "%s: Command: %d - Options Invalid for command \n",dev->name,srb_cmd) ; break ; case 0: /* Successful command execution */ switch (srb_cmd) { case READ_LOG: /* Returns 14 bytes of data from the NIC */ if(xl_priv->xl_message_level) printk(KERN_INFO "%s: READ.LOG 14 bytes of data ",dev->name) ; /* * We still have to read the log even if message_level = 0 and we don't want * to see it */ for (i=0;i<14;i++) { writel(MEM_BYTE_READ | 0xd0000 | xl_priv->srb | i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; if(xl_priv->xl_message_level) printk("%02x:",readb(xl_mmio + MMIO_MACDATA)) ; } printk("\n") ; break ; case SET_FUNC_ADDRESS: if(xl_priv->xl_message_level) printk(KERN_INFO "%s: Functional Address Set \n",dev->name) ; break ; case CLOSE_NIC: if(xl_priv->xl_message_level) printk(KERN_INFO "%s: Received CLOSE_NIC interrupt in interrupt handler \n",dev->name) ; break ; case SET_MULTICAST_MODE: if(xl_priv->xl_message_level) printk(KERN_INFO "%s: Multicast options successfully changed\n",dev->name) ; break ; case SET_RECEIVE_MODE: if(xl_priv->xl_message_level) { if (xl_priv->xl_copy_all_options == 0x0004) printk(KERN_INFO "%s: Entering promiscuous mode \n", dev->name) ; else printk(KERN_INFO "%s: Entering normal receive mode \n",dev->name) ; } break ; } /* switch */ break ; } /* switch */ return ; } static int xl_set_mac_address (struct net_device *dev, void *addr) { struct sockaddr *saddr = addr ; struct xl_private *xl_priv = netdev_priv(dev); if (netif_running(dev)) { printk(KERN_WARNING "%s: Cannot set mac/laa address while card is open\n", dev->name) ; return -EIO ; } memcpy(xl_priv->xl_laa, saddr->sa_data,dev->addr_len) ; if (xl_priv->xl_message_level) { printk(KERN_INFO "%s: MAC/LAA Set to = %x.%x.%x.%x.%x.%x\n",dev->name, xl_priv->xl_laa[0], xl_priv->xl_laa[1], xl_priv->xl_laa[2], xl_priv->xl_laa[3], xl_priv->xl_laa[4], xl_priv->xl_laa[5]); } return 0 ; } static void xl_arb_cmd(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; u8 arb_cmd ; u16 lan_status, lan_status_diff ; writel( ( MEM_BYTE_READ | 0xD0000 | xl_priv->arb), xl_mmio + MMIO_MAC_ACCESS_CMD) ; arb_cmd = readb(xl_mmio + MMIO_MACDATA) ; if (arb_cmd == RING_STATUS_CHANGE) { /* Ring.Status.Change */ writel( ( (MEM_WORD_READ | 0xD0000 | xl_priv->arb) + 6), xl_mmio + MMIO_MAC_ACCESS_CMD) ; printk(KERN_INFO "%s: Ring Status Change: New Status = %04x\n", dev->name, swab16(readw(xl_mmio + MMIO_MACDATA) )) ; lan_status = swab16(readw(xl_mmio + MMIO_MACDATA)); /* Acknowledge interrupt, this tells nic we are done with the arb */ writel(ACK_INTERRUPT | ARBCACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; lan_status_diff = xl_priv->xl_lan_status ^ lan_status ; if (lan_status_diff & (LSC_LWF | LSC_ARW | LSC_FPE | LSC_RR) ) { if (lan_status_diff & LSC_LWF) printk(KERN_WARNING "%s: Short circuit detected on the lobe\n",dev->name); if (lan_status_diff & LSC_ARW) printk(KERN_WARNING "%s: Auto removal error\n",dev->name); if (lan_status_diff & LSC_FPE) printk(KERN_WARNING "%s: FDX Protocol Error\n",dev->name); if (lan_status_diff & LSC_RR) printk(KERN_WARNING "%s: Force remove MAC frame received\n",dev->name); /* Adapter has been closed by the hardware */ netif_stop_queue(dev); xl_freemem(dev) ; free_irq(dev->irq,dev); printk(KERN_WARNING "%s: Adapter has been closed \n", dev->name) ; } /* If serious error */ if (xl_priv->xl_message_level) { if (lan_status_diff & LSC_SIG_LOSS) printk(KERN_WARNING "%s: No receive signal detected \n", dev->name) ; if (lan_status_diff & LSC_HARD_ERR) printk(KERN_INFO "%s: Beaconing \n",dev->name); if (lan_status_diff & LSC_SOFT_ERR) printk(KERN_WARNING "%s: Adapter transmitted Soft Error Report Mac Frame \n",dev->name); if (lan_status_diff & LSC_TRAN_BCN) printk(KERN_INFO "%s: We are tranmitting the beacon, aaah\n",dev->name); if (lan_status_diff & LSC_SS) printk(KERN_INFO "%s: Single Station on the ring \n", dev->name); if (lan_status_diff & LSC_RING_REC) printk(KERN_INFO "%s: Ring recovery ongoing\n",dev->name); if (lan_status_diff & LSC_FDX_MODE) printk(KERN_INFO "%s: Operating in FDX mode\n",dev->name); } if (lan_status_diff & LSC_CO) { if (xl_priv->xl_message_level) printk(KERN_INFO "%s: Counter Overflow \n", dev->name); /* Issue READ.LOG command */ xl_srb_cmd(dev, READ_LOG) ; } /* There is no command in the tech docs to issue the read_sr_counters */ if (lan_status_diff & LSC_SR_CO) { if (xl_priv->xl_message_level) printk(KERN_INFO "%s: Source routing counters overflow\n", dev->name); } xl_priv->xl_lan_status = lan_status ; } /* Lan.change.status */ else if ( arb_cmd == RECEIVE_DATA) { /* Received.Data */ #if XL_DEBUG printk(KERN_INFO "Received.Data \n") ; #endif writel( ((MEM_WORD_READ | 0xD0000 | xl_priv->arb) + 6), xl_mmio + MMIO_MAC_ACCESS_CMD) ; xl_priv->mac_buffer = swab16(readw(xl_mmio + MMIO_MACDATA)) ; /* Now we are going to be really basic here and not do anything * with the data at all. The tech docs do not give me enough * information to calculate the buffers properly so we're * just going to tell the nic that we've dealt with the frame * anyway. */ /* Acknowledge interrupt, this tells nic we are done with the arb */ writel(ACK_INTERRUPT | ARBCACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; /* Is the ASB free ? */ xl_priv->asb_queued = 0 ; writel( ((MEM_BYTE_READ | 0xD0000 | xl_priv->asb) + 2), xl_mmio + MMIO_MAC_ACCESS_CMD) ; if (readb(xl_mmio + MMIO_MACDATA) != 0xff) { xl_priv->asb_queued = 1 ; xl_wait_misr_flags(dev) ; writel(MEM_BYTE_WRITE | MF_ASBFR, xl_mmio + MMIO_MAC_ACCESS_CMD); writeb(0xff, xl_mmio + MMIO_MACDATA) ; writel(MMIO_BYTE_WRITE | MISR_SET, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(MISR_ASBFR, xl_mmio + MMIO_MACDATA) ; return ; /* Drop out and wait for the bottom half to be run */ } xl_asb_cmd(dev) ; } else { printk(KERN_WARNING "%s: Received unknown arb (xl_priv) command: %02x \n",dev->name,arb_cmd) ; } /* Acknowledge the arb interrupt */ writel(ACK_INTERRUPT | ARBCACK | LATCH_ACK , xl_mmio + MMIO_COMMAND) ; return ; } /* * There is only one asb command, but we can get called from different * places. */ static void xl_asb_cmd(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; if (xl_priv->asb_queued == 1) writel(ACK_INTERRUPT | LATCH_ACK | ASBFACK, xl_mmio + MMIO_COMMAND) ; writel(MEM_BYTE_WRITE | 0xd0000 | xl_priv->asb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0x81, xl_mmio + MMIO_MACDATA) ; writel(MEM_WORD_WRITE | 0xd0000 | xl_priv->asb | 6, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(swab16(xl_priv->mac_buffer), xl_mmio + MMIO_MACDATA) ; xl_wait_misr_flags(dev) ; writel(MEM_BYTE_WRITE | MF_RASB, xl_mmio + MMIO_MAC_ACCESS_CMD); writeb(0xff, xl_mmio + MMIO_MACDATA) ; writel(MMIO_BYTE_WRITE | MISR_SET, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(MISR_RASB, xl_mmio + MMIO_MACDATA) ; xl_priv->asb_queued = 2 ; return ; } /* * This will only get called if there was an error * from the asb cmd. */ static void xl_asb_bh(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; u8 ret_code ; writel(MMIO_BYTE_READ | 0xd0000 | xl_priv->asb | 2, xl_mmio + MMIO_MAC_ACCESS_CMD) ; ret_code = readb(xl_mmio + MMIO_MACDATA) ; switch (ret_code) { case 0x01: printk(KERN_INFO "%s: ASB Command, unrecognized command code \n",dev->name) ; break ; case 0x26: printk(KERN_INFO "%s: ASB Command, unexpected receive buffer \n", dev->name) ; break ; case 0x40: printk(KERN_INFO "%s: ASB Command, Invalid Station ID \n", dev->name) ; break ; } xl_priv->asb_queued = 0 ; writel(ACK_INTERRUPT | LATCH_ACK | ASBFACK, xl_mmio + MMIO_COMMAND) ; return ; } /* * Issue srb commands to the nic */ static void xl_srb_cmd(struct net_device *dev, int srb_cmd) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; switch (srb_cmd) { case READ_LOG: writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(READ_LOG, xl_mmio + MMIO_MACDATA) ; break; case CLOSE_NIC: writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(CLOSE_NIC, xl_mmio + MMIO_MACDATA) ; break ; case SET_RECEIVE_MODE: writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(SET_RECEIVE_MODE, xl_mmio + MMIO_MACDATA) ; writel(MEM_WORD_WRITE | 0xD0000 | xl_priv->srb | 4, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writew(xl_priv->xl_copy_all_options, xl_mmio + MMIO_MACDATA) ; break ; case SET_FUNC_ADDRESS: writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(SET_FUNC_ADDRESS, xl_mmio + MMIO_MACDATA) ; writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb | 6 , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(xl_priv->xl_functional_addr[0], xl_mmio + MMIO_MACDATA) ; writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb | 7 , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(xl_priv->xl_functional_addr[1], xl_mmio + MMIO_MACDATA) ; writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb | 8 , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(xl_priv->xl_functional_addr[2], xl_mmio + MMIO_MACDATA) ; writel(MEM_BYTE_WRITE | 0xD0000 | xl_priv->srb | 9 , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(xl_priv->xl_functional_addr[3], xl_mmio + MMIO_MACDATA) ; break ; } /* switch */ xl_wait_misr_flags(dev) ; /* Write 0xff to the CSRB flag */ writel(MEM_BYTE_WRITE | MF_CSRB , xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0xFF, xl_mmio + MMIO_MACDATA) ; /* Set csrb bit in MISR register to process command */ writel(MMIO_BYTE_WRITE | MISR_SET, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(MISR_CSRB, xl_mmio + MMIO_MACDATA) ; xl_priv->srb_queued = 1 ; return ; } /* * This is nasty, to use the MISR command you have to wait for 6 memory locations * to be zero. This is the way the driver does on other OS'es so we should be ok with * the empty loop. */ static void xl_wait_misr_flags(struct net_device *dev) { struct xl_private *xl_priv = netdev_priv(dev); u8 __iomem * xl_mmio = xl_priv->xl_mmio ; int i ; writel(MMIO_BYTE_READ | MISR_RW, xl_mmio + MMIO_MAC_ACCESS_CMD) ; if (readb(xl_mmio + MMIO_MACDATA) != 0) { /* Misr not clear */ for (i=0; i<6; i++) { writel(MEM_BYTE_READ | 0xDFFE0 | i, xl_mmio + MMIO_MAC_ACCESS_CMD) ; while (readb(xl_mmio + MMIO_MACDATA) != 0 ) {} ; /* Empty Loop */ } } writel(MMIO_BYTE_WRITE | MISR_AND, xl_mmio + MMIO_MAC_ACCESS_CMD) ; writeb(0x80, xl_mmio + MMIO_MACDATA) ; return ; } /* * Change mtu size, this should work the same as olympic */ static int xl_change_mtu(struct net_device *dev, int mtu) { struct xl_private *xl_priv = netdev_priv(dev); u16 max_mtu ; if (xl_priv->xl_ring_speed == 4) max_mtu = 4500 ; else max_mtu = 18000 ; if (mtu > max_mtu) return -EINVAL ; if (mtu < 100) return -EINVAL ; dev->mtu = mtu ; xl_priv->pkt_buf_sz = mtu + TR_HLEN ; return 0 ; } static void __devexit xl_remove_one (struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct xl_private *xl_priv=netdev_priv(dev); unregister_netdev(dev); iounmap(xl_priv->xl_mmio) ; pci_release_regions(pdev) ; pci_set_drvdata(pdev,NULL) ; free_netdev(dev); return ; } static struct pci_driver xl_3c359_driver = { .name = "3c359", .id_table = xl_pci_tbl, .probe = xl_probe, .remove = __devexit_p(xl_remove_one), }; static int __init xl_pci_init (void) { return pci_register_driver(&xl_3c359_driver); } static void __exit xl_pci_cleanup (void) { pci_unregister_driver (&xl_3c359_driver); } module_init(xl_pci_init); module_exit(xl_pci_cleanup); MODULE_LICENSE("GPL") ; MhKy.%yQ@t.Eb9EƅK4 N>^&+ 7y t.p60ݣ"rj07P؜b3k=P0)5qMws )5t(o/3:yZxvQ|t"ͪ$]%o(Q͎yE>wAlq.BL"Oo>W؃a(D?JEj5:P$p?XhFAڞA[ nrRDE,-;-9Df7YKijWXKeY!i%jɕI tB@gzRNcGfISa O )) nZ)Ohz2g]H>Ww B)/2  x %2(^)ʩN騤 U ~.:nmBܫ .,Ǡ硯C{3u"^Lp?TMN@&.J87JcK40k8 |8ɂFd} =) pDU/(7N澍qRkh0[lAR 1khTI7Qn[G+R /MNdr+R4:4Aeu+-ɭpiՃQ"NK ȇM?Zʴ? k]Uݑ5f<R.' 0xZ`ugz9>ڒZ W1Iwʼ#zW7ű{A!1mkդg̨5}h+/|or{@r еnI88EN h 88n1϶'M= CAДKDbҗ[$J27Y:B9cו )940ZyŎ!|߽vX r&?ܼFÍfŠZ͔03Z'a S@PGu{I)aAz wC;iL:]V?D_  Pn*cջ>Ţ$cxc_hgya>+e5oa69Gݶʬ^E^/{EN ]flm`iF "VAҞc'm! ʪ5kN!M|>;6;<8Eqn[a5WMr" G#j|6ag H rKW)3:nvئh|F?\0G RfM,hZ ^YИ7L ' (% 50Q{⎆p W;V!LRn gho(5Dp-]siHm{xEި8Jp Aj>,? $EѰ9B@>ӈT g(HKG G.kwh`;'`-ģ|C{'<#gNINuh㵒Fx`5Rǃ,U+1F4(:vo@w)4X_Z]HӞ m6펆Z$@9dl';%̑u/^"Ɗ 6)lHQݤ>tG O>L>"M/lH54qMBiduM]_YAMB<׆n 6Vm,rt';I,Vh<4ljd{B@yCT*O|ga^1ufPe0qfqsl!ߠkMnoh]`T4/Ԥ۶#EosD6ph(;ydNkp0sM-&ݫ`D܁t ,#Y$+ۄXieمv6V~ņIHbCCx^`Cv8Q*`1g=g!ssiv:1˩?ώ;nEE:)ȥX}Ğ=fM vՋvwYkRx/%f)U SN_rdh_T$bܥUƠ6 c4)U_[?S/ְPüfrU(O8qfl2Q/C (>}'-\Ls4܈Zɋxa[ U,bIlطȟݦaDl丯trAY\9'e]>_;C]JWMtڃ50ߘ梪F+rϑ>ѧs-:oL(+/y]l8pP%Y9}ܷϞt(ϑGBC-A6n!@jikEUo̊WVolXr@1I5B2y4[}ia(C\,4|Wv:2c A\( Έ2飉3"Z*1>bĞY=5 e)2B{*:F\iZHGNWv$|Yz&5mٰ^)C~#"[!vInC44]t~yf2iΌ= lX6FC26\PgBFJ8>J2|'n;)>~ |VjeaΘ2#3ALw Nnz@K ufF>`$ߪ(=E[8RNêCr,]d5ooظ0,\L[maUCFУOyJK ۾% y04/Ӷ4[_@%ͿkID _0YaI80RpZ7+N? h>j2| ܎Ⓚɯ  ȍZE"9K2MM> PQo[8$-ixAˤFōG⓮$@CPor7-%F5"6ߑ"Ǥ)NI5+/:&iuMI*ZLi' 5qV E@4]E`IX&\ έhGs0y'S"͜(9I5>Nqaz2}|u#V)6V"vJ,e6t]^f7C1[,JaPATi&RV9 *v,>xg+eƒO`Z|V/kQu%ꪦ-=3"2P,x  ? u rNznSpQ LqcƖIG0IlٟYsg0tSRNShhSغk-_ҕ2 lƮOV6/a[&ߵLV>J\,s,2na ńMivp?\y.BO]jA)ORG1_andEX*a=fى-MM#,M&`5] [H~K#'J7egMĈ >+[^*޸TXgG#XK ?nW>i8B OH,c? (أe 5Q9c}-P]4RDiKPPO1aZ J2wKiqTH+?OO ..Zis* N*e ?xzv3qVتz_A1BɳLqhw>Fs)adG=zC~Ho{eMhY ɱ_nB iO.FSwb2UY녤4U)#B-ҿ$-cOJ7VQ{TH婠MH,á*~Vvk+Edys¹Y*g"70aU'K>,X,&|! [7OWHf-z4w#c,_j5ʤ2iHȸ/R*t|ʀ[F|r=ܪn?%=.4NOKF9?ͪ:%<.E<4gΔ|˧_ e8]žN+a)b%U]ʖ̇K iw}bNsajqSap:MXV.>.[-\at4gC8(cl8ֺ<_ϸc˙9M~#&{IDGK>1HL"Dn=ԍ, m131;NJ8(6ԊbXL RIj GޗJk󓩩$ gq^5_\-q7@RP @^َs.LuDeVM/zZaNmbOydһK\zf ۿqN7>> ; T*NZ 3Ht=nA^xwQs2ύ3a*WOo+ur@TjqVP{T08dɠFe`)٤DwIvPfYm}Y6pB̜>x=c)?!C4S;E*[LbDOCNԴ,CtS3)gv\[>ډˋ`J{,qL|>wEn B_\1PƘAu2d'k~AŭD^4>RB 9$.Ël_˖ڭ-(VtYQ ~>ۜ>]eOO c=r$ mW` ,*6i&_1\y?X6ψTeLj&c2_, `jDIJ8EɪVQ%R!ZI8$ i>W( 2fܦP Yj_,ѮԅC}`G!Vl/u.5w- z]N,(% 0!N_@JtlWU4;l ?"D _w)58`g\W8:;B3ln-[LP61\{K \aK}䦅 _?򐰁k* /xK\ogBYc]|+!"Sj?oEw*ύc8{ ΆB/Zhiyvܴ9zA|O_$QfH[PkO3`άRuV{ :QIkSi;܃U 7CC<\=* 7%Y/zXq6kz' XW,gVpe42|ȇBe AxjEZ)KЍ2|I"u_XʼZƤJJ{\A\*մ938IJgFhr}/ӎ𷴅hSI.5¥C~k-rqŦ M.܃9O1@*;2}=^oҸcG1d;6ݐ==wVve6g㉬}ba! T"):ՠgXcQ>803y{#>Y_d(,,=; ݯWN74ٯD/XGRi7mƟYEA YY $"a uoay5ei[y堜^\Uڜ= ,8$pji#Jˣ=OŚei.>u?}P8dQAmg:ЃIt|]>uv$wQ- 5T;9Musdt* og?"6xckO#  7_ء;'ASG*hCbym3ᴂw+:LĥmvuIyw̑1p{Hvܔ2UkfoDcea@y;il;f`W\h!'VЮw5h̰Bhk_/ P6V7fy߇bfR%ȢF)F/-P{"F3v\ bD ǚh 6,=}'ց;=q~A6|f\cW0@PRBD٦JW^\SdT@}ǒys&:xXQ`.biݚiQ#ϝ@獄.ḬOxյ$g ÑfD>-Ph:fMx4h ЫmvKS1y~|GnX9\v?9Ws*0 dh" @\}PnnJ(ެ/V D  C gTC'vBo.")c(5=*1d??T -\4sb}RSbȎw`U2zQBC]Ep+e?~REzMQ|k7G G5m~7s^GRޟ¼SĽNLe B0@ek@JB. zw% 'cfs_h,zWq yY?~:=~б{Nų>Y>Ew56tӎmr&ujLcFM iU# u>/d DPvd%٩+䭫+^("?y0  cwǶRAW;r𲋔5qvClƯ(Ov*m-|{Fb~" u%zZRURLptnT-#ײzW@u< 0 0·` @>*z!DƮv(O MScSZuEyuPBY"Wv䣞Mω> ZOh,  2](IT).5GetLP-|RggzJT 2~ƍz!ifydbKYyCt@;;rȷYY1y;U6%lf/D~_𒛗nI 3ADUA$t"aѻ4QBi5b%U+aS,g"W7eoRRWT)nEmēis f/5^~C֫0̓ApW0˘]P3L`./)v( WUvC>cpP$H?J# X~ލ\&[ZD1i&DIl0ۚ⼴gөӸΗ"?!LsKrQ'5jlL2no[y=0_`5AߠW5LW%u3v| Č$0pS*6Hy]"_o1ɽ|K>tzxnCHKD%ow0 bD^k{ =Lwj0[Y%p }z@%>Ģڠ]E:Et?>hw Zf{u]fIbJ445oM[Z׏;8[a(9і_Y*RF1!Q(K wQ@!f'AlK[9hڸtb.u!}rS޶p#\XZkeeK3v}۹B\9S) ۠$E5\:)5A Τ\kt(=j%cq((Σ̐3<*) [ Odfނ5sYK/"ϿbfK°]+qކ>V#DV72`AE_׹8Q] &ganϙI5(f' `En+X,OW||]YGaiW~'ȍל)>Wy5qaڧmfi-r. =`ʲmB-]S;%9e0S:ʹt&v5峧)/Ds5?VD'd~Dl8UEM24nh6̭^:kp.@zԲ(K8xZ[~Z Znh&IG⇵t!^PT8 L3ҴkoCwLaf2x 撰Y@Bi.22~/)ud1q A`,YX5H\ȋ7yCuᷣ2$2N8I֖_Ov,Ӎ직FY-BmZD!RR/ٻsDs B9iͥVuUy. T1 ms'P0+U5g =/z_7uvOPvg:ߦOab ,p_tJ\LNc8l,YQRS[Mf~݇k6;lDLpCsEs!hO[lP:rċS4LsCl^3hKތfDDmQF@opNJ/nX6a24"o )_p>;;/_ R º3 n)"rd?.k'Do >VP>!Q28Yjmn2΂$\7&lJ} Ɬ NJ804Jg<ֆ+WVmH#h vfZ*cMV't38(ezɼxOw(+DuG9o&;DTrt{rS&GJ_ݞ.[Ő)L7ީefP`j({K?_~.lEDXi(V\rDyБT1Pd|l0 K Xs {\Wfɻhjڟb$AחMt;NAȶ\ 8kE9&)JRj ;Qnn2~R/[C2 ?,{QtQזE˦?( si)xoi7 89X\2bork;$F8Ā`e؉((ibĬ X^ɯ䘝BNb?7.o?"faIP]J*kc2_9pΐITnԏ×OهD|PcVc362x͛S_`?٫5TqwS7j6F=*j';/8g W%ǚd Rňc\#98 BKrqLU#@UlvJbaY{@6ȱ0P[3 ?)MI+"wTXE0}Z"Xli.%bp(`3uќ9Lr[^~2C蘑dKH ,eisŗT' *!MGWlQ3FjbQJ"ѵN)%YhO=#$kz}׻3\7ƝHDۊybnD*Wp_ܴw)ae YY7NDbS]f ^(`@3[:XA!uDq@4>w(jbH(".@1 NG\. [!prK#^5u# .S-kSMRGȌKb?NPނ7Ƴxv@WRhHy|LϢ1A=Kj}]Bd떲"2ǹ/|x$Aܚ$,U [t(8rS!2$^vbFt.ӿhS:h"gu&N4 ,n, bJɝ,Dﲐ*Ch*dP{G7 eY2E1gߨj}_IZJJYx'5pngaw{ <}iGi5avf[4EzTGA5L?Ɦ8F;oc}6] ڜʷ;gNFHǎ SP FIJbc #/^{g pXGcm59hA"nm$ CFeґ*QY$(VdO7PWnyWqJu@j`y2AS5WU`q5UxaHAĄx#%E!⟗xL@ |Db`H_#g"h6pzo cM4YpdmM7* Z ³| v ボ#qQ/33p).df_+c?'@ODR UH=OxpB{{r?FLE̓7MInsV^4JJ&T`! .I-yo~{GUTx'E }rOs6Њ (Jtv*(^Hwٚcg-@*ySg wNt,_byثoSSmH"cL YGO(bzOqHG\}wSD}!Cjʝs!!Xp5cˎ{ QYtB&'u{/.a'XZ,{+TI#i=36gwn#;Sڔy>CkˣZؕ(r&8nf@Qe.T.]ji’el7CXeB-pI:R w:.sּ|y?: :q'3]¶soI(p͎}ols"T;M l[D1KߞED{jmoKՒf|+%ȟ }6ʽY^0)IEf~&5:` W'g/P2l˜s9K9<~dr3j vƸA XR[6$$r5S%V%eo4"; :3X<6D60s0[>}j.^Zz[A( "pvY0q$$/1E+x.7A|Un,qb8b]v &sWgdI/6H.z[/HSB[EDS2?Ԯ, &W{=hڔYQy\[ұa<Lo\s^7S۠UiSNֺLkI_{O>*NY[HD-u`'z?u_^œ8=dzxD6BQ b x%2/V(J@/oG{-R* 8̨ M3 PiQΐ󇬣NeW4#l-ˊFR$?IBq $B AVK(76Bj jA5).|)ě4pV 7ĵչD+ryOqY[rل%}砛  } aεnApAFZbs0#aEE ;%(eƛzpXD1P:tMz6Sp$=AXolAV vOre1IЦW3^_|ĻC/ÓT16GEG]:+o A5 :*"}1k%Z`TeU {6I߁bӸv)Kv{|h7jI9;ͺMx7)uh~KVsfGsU"`g`mwEЧ,/pJЎ?43MLF&&t)6/uN}y.xߤڠR#Zkl9.b)dA6Jwh~>`=F:rſ3c'Z7~kԤſ*4=d +|>*E^FzH }HQQm)2WY "/KG\Em#oq|0?'9Nߴ4D5p|& zdyuێ rg)IeIԔc{}ƹ/S=݆f Tmgi"-r/#V*u_Z{a]& A)1 q ECs;D4agc2kJ㱪JegΨm1x.p|C;v25WBA__N/ͿlSN$5PNn:QߏV=3\véT=E."i5̚BbnA"±:H)8f)VAюHzH(D!()S2viؾ?G[UdTud`s,NϗQ=Û^,y3 ޿/r_+&^ܾ3WGşgt~`j#؟n}4>U^f *M0U:srCqBÓz&x#H+4횫n̙;!蜒fW/V ɜ1[vz`XHje2dntJ6ō$<BfDl*W7&&=.-tpLjZ\L()O0٘&O0N哔Hjſzzo;X%5*x* ȥS8b5^|_?{ёF V:Lp-n5%D¶4+6_qQ#~lV!CaQTxc ,dej{PS|Ȥfat?;5owۢ{!/"P8l!7 Ԓx"h{>"8(1Жz* sJz2'[mY @ǽ}KRc TMer,-$(9mY6E.*bX0?F b`cNi:%̫w{SPGΟP_ 0.dS5C /^^3iU[97n.:DzO8mD;~DŽa;$5\fA"yc_2'4Rȇ(nU{!cНhMM6 ;NϜ^b$B63mSv֖M, % A#{yD >:Ka/ڊ ޙP!wDa-G[9mPCLhw@ع.J{RM"B~iCp%? o⛲BvYJF&Ki }_濸I*gdӪԛkR@8>rZZ`KBYC8Ѥ'4of쪆пˑR>CKC!ZE-A]3z1ǡY󔑒`6U1'2Nw"ӜɈV.ɅFq \w^n˯<>`j+sȜ ,l8!V>?"9ZXPGo9&ġ34`T@e#sHEIl\|SPrת h/K]B#]` gIYYIiF7f@a; Tb) !DU,|sf0(au+Et5Q'#㗿d8V+aLWXb7! qU/4DT$'Z3j"!/WB+yN,~gV'&kEbZcN3K'yg|d>Uԃ>hst8#8 h"4 P1Ϩ!>D ٦|ͬT6Wԣtҫr%K+`EǙC[fDħ}6Rv|Ea ):cJp$*bt- 3q'iJ9 t°TJG=ܒ֔'Yi|SD4'{ }Slb>pZVdgF5E^07a-GՑAP(ϊp_ѡج:C@2sωrvzvMj&K.R.D{gHD=3@yK=>,ƩA rg  4r1: ˇ~dTw_\]*IԹu~kMѵԭEÛ!4h!fk#_غFo 5/Q/eJ2|t^#/@TwMJj}Iw]U?T9BM0gVcp Y+WیǙNC *@bczוi}sdC@۠L5O@.[ T 9^dLς*'掆F'$?|jRӾqwGUӛ55 /f?Z !TLKPq7{MHͺ#k zEk ˽-y3Wr'^ɲ>AMψն f|!$.ޜ~=8b-"4g-F3~tS[}5$gI-w8Z?NAF*IG,yo %&Z"rl+W(>Kj*`uL>Ut+`qsU|mh=Hk}>VDɝf_q{Ԋͷ'jɴ=u4 a AׅQeP2 [^?\|8j+c};NDe?J_)ylCGY$lV0݉If!@:WZ; sJfa4",av7\O&h; %Eдhpq$Ɯ)"JvZ;ԝ}bRV OtBl$F &,`X\a97ζp")jtL<$LiG$p%ͿzRqyGD[4d,;vQ47e"I~a0JC窺$dahڏtg|\ ~2RfuL(Գfc 1(16 g~DT^qN^] \^Uc0]e$>vBIe!(WVݒK0tV99U^K#3=ԼE^ZyGt*k(\t76錺6 jšaW?wE\w3"ZnִVfs|~<_Hغ\k4/5Z\rҷ J6Ԭ,@"ߜUj;glhIL ؼLGot :Z!q~LU6 O1l>*pdI>Zr#ښʘŭXM.o4ZvH尉P%k}g.Kilʍ+3/"iͰ]#%Yڸ{(ޥ&Y8!Kik^vކX 8mDweGQbXG3އO "hT8-6Jr͒-7<1$p?\zlĂ/ 1 9K}8]ÏT zK,͋b۔LD]w)J[ @W01J ~uUǜ^[ÍvT(FsoR,%*! ¥`B'oߍQY|~)]AD$R+Y_; 1,"? b$b~Vhm .x* ZtgGLl$9bhJ-/Vq(9+bITko6 {PuǎSLr=V~]mTx/^3cvΪ'Uc@(X?6 *YC~ng&ΰ{ɆP͋+a,R%bGMи7e<xơZ=.i(8i`z~p>@8yѮĀR>wl㰰nW 'x,쟊9k:k9kUர4 Sϗh +'iRj8 b|;kþ0;k]wNaj>$K(GgkgSjwĤh[yH/"@r1\4J%͐d#yR_ /D77M^& px6R3(2 1ʚh(H!hL֑2BwTGxOlhu`12c_PŦP5kC^Dd u_2ptoo!Zc@k+Ώݱ8x_rKh3!C\ ˎ,SeK *۽87MCԱeR"9LݎO0^G_KX>\qzSwުv5>{ҕ{Ư,grRP(sVSsdrdH<ǀZ[6^K"kLB8JAL/Zp/(7Hj>[.հQ1vHn߾[XW*WhZ94E|^{kqI9rj;mIᤅe򿖩x7s6e(q(Ȃk=}1x뼕7Ib9쪪2jS7]f/2ңHaBEޢNk./=҃_Bҿz?6_̝`z!A0`]lڲ73\k/Ss` $r6E.Ȟ?ֺcw/0k_ڜE?{dE^Gb͜S $X7r9i 1ib`,a@5bǢ|9pgǓxfTk7Jh,~QtI ȼ-~U\Xh'>8~--Sr}= +g&~P%ҝqi$e^=nr 3 I_!x?54,)^Qi~{z;vvw.NTK_|s_BӁy}Jt%JF7?u]yTJ#lejfehIq߆R|ґ'h-%t{"h =^tj|"|d-0)ӚnZQS\:߷m*`cӺ'g+u1$X@1~L];j&|6 2r+MBa;>jK 8K$*UҾv3(BLӫb]m$, -l߂džrYDeWԠΞ+l)}/_XB6q$ȕ\CXzqOh5v`ա8Qm?B>l"<˂]c08.ϲn^?RNPMN> [B.y+׍&%=d(iے%/%@VAV;eJF)$64/t-izrfMg"(euU[m HO'8GX@n>QN?$}9nC oԽgj膪~"ԨJ9]aQ2%D{,0!,oSsƟpʖШ #se^4m%膂m u`'/QE&Yp@itm&'3L k([aŞH\xN6 KE>x4"^*:o>xKzٛ!H_rsv.kwk%#&p1vMLĹQ9:\ lq؉~|.288a^ggu 5u{'ӂ1ץf -;@Q'i3P{`p<8hR;OрĀOG+ fXUtdOTީ& oFaN_bQi&X2/oE9 <JY_z:|6HNd9I:Xu қ6B=T(.nttbIgȽTj )JWpWy}մ9#+Ь5P,l0˹ lQA1$`-wp&jruE|bm (T47jDz1| 7ނm E< {Z3i)v>0KL6œ[b_)2%pf{JU y@c;&h;Mߖ=R,xzP7s0/>5 Nǣv Mz,az^W0->"6v1~2gΥte7+ 5ʏ֚ BEۜ|e(;jiNK4puNȍF뭜"xLGA y*gC9=<B\xp3IrI"B#:@|xN_`>)|Ul-9}F"'?aC75Y<-xGч+>ƌ/ և8#C;Lj+f]TM9~֮ 0fg[r/ǔKdŘ dԯ˻j 5H:Z"-1F};[~: RX']{zHMlq&Mo`À_V5GI+D叵6@0(@`)y-`P7_YEH_L5&@Ł㙢w󛑇 GKfq]1,zr23uO!(dKc\j62o#UwRA61 t)粝3gLQHQ򅳩UHPZ1Sxvw>3 pth!@˦14%Y/w C> e{BY }Ĝ92#Y*:O{^u؃[D_Xw.wwR}ǂQQ~^Ӓ-'|\d .g1#V _Z:y(j+ ĸ=+8xJi;E':?lS80P6w2~ˆk]B浴ܦ{m)h@Z{<_-rܸ)4N:e"J rG UyݿW  ]#?2ԆtD/Fu?|=5icUzzPh֦ "V{m/R #O[w' d ?-w#= +ũ[ם?, _޸9)p4RIj2҄izkX 3V$o|gha.n'~` l_wA>C߳~KW{11|xdHz&ջu5GZUGs0lىr ^?耴+%Q><= n6R \-(/g8ภ ݎ+R8b'^(>ӹY[k_W<tB-T=rRQ4{ddITz E#Ցn'ik{ZT֮.ӏ`.F?_z_E݄ɀtt@o_M9ii5<+wط}=-HmusAfA4;xoltϝIfCՉ=#  1J[uf&~ʠs[`KN'/6%@.na. ScmW.Y;0=0@2@EM%#ܑȾF"EaŢ2YP -K#r3l2Ni,: 6O V)jR:/eV]ȷ"cLW'J5Kf$QƨS}v5@2Yتj6=N. kC+iv =V{x08|kͨ+%VWħ ؈ eߛBq zBeATp%*ޜ`FMPz-O Z}ۣGѽ' &ۉI9]ކh*] SkbHm֬@<{D[CXxS^}m?-C8~D)opՉաd^kB (WH슿M>;jq=ȼ2Dp6\^`ny1)MB T ?6rU<0Pwwt6V]6Ҫ*$vMaYn9e?`?-'56flzalAcVװ  unX@bpZdV'/ۯ|ƓV= /t=bYd%c#X2nKs,RT%'BfHTe"6\hM::ċcǤ5\FګB}g`}D-\`oUJ$ͻ]WW`NeFHX (mL~&zt6Ac\łu]g81WZ#\b,+- fE3 m%F"Pa٢6Z2!IJO]@J=F0]LGXk[͞_ V=ٚ%ϣ^Pq_9Ïe^x.| E-뎾}$3m]ʦolV+왉A P`JQ_qǭaz۪oUσf Tc2&<3(fTZcD⢍y͌x}IrtU츍Ū[$ :>qib c $eYnΘꋉ^V f$Z :)[5LK'ƔOqx78S ~*KR2,VtcقXmZ;<>iHYϿ>UI~:Rֶ̀.Qrݘ1w>nϕ9p8n_ $)d{ڎwذ.ڕES+lp#3/\fЂ ttxcҐp?u},B)G`{~4?vjޓ 7IshbYs P4&JuP.&a<$'U=Go;9148:rys~*Vwl[FxVP 9f:ߛeqĔF5<P`W.:ߝ[| _+<6DS}٥3'C^sޔu@D Tͥ7xHLJXDz 7hEݕ16MQRDrAZԗ)("`)܁>bW˄;\3ZWYNeY(+$83!{ %9S^},:Mv6I=DS^f'tN&I4To7;%edU7SGϹ_#ɝIqӔ+E%5JѦRM$&u.[km.1CN^@/+`v(^9_).ºGkmd;3f<mށٲ^p?'MQX<"  hҟ;=I~w&y=8NRACfz&jJ=ؒ_}%)raz a P\CH MQm1}-ձ+%&n8vrL;P:D@ro"g\.Bd_q\T+w&tEbQ7tt D]wӟI~Ԗ ʊHu0/:ZZ^sp;,E-.$ǜ|;)j74 f: XbDˮ8NOIJ(p`$J#~)S}ݽ~op{8>6>MB2xZ.Pbg߾p|[r 2?eߜDqkaW9, \ПE,tG(ýI_lbh~g* tBPFNtd7d^)@)YW${AEmGL:N+dɀ1ޏ^> tГCGi ([gfL$9B`MuH3@B$557Fj51ȉw }LdTp B R&ri#PQB/nOy5g#Dk~N]fPC3X!sOy0GlEߐ6l *ICTd:'m%Ґ\,j:HUcKq޳$瓠 JuubYq-{$ڭ˽ /|ri%L9kXPerB*W $ƞ˂ɒ @e>Q D^yʿƒBfXطS/Avu%03v&RFh,1ɋR3o14KIwǓAfb 㝰۝XN..]5K2QoSuhzOBCB:FFQs|S39OoU`Pϣl:ܔjXPT-qcۣԻ-]ŮJDq9”/{b_=zU%+ރWh@/04*vL$J(c.{Cٰ+E杜H2 ~K5}dƔ/%B@qEc_5p+"O $d.ռ[jp@TPtK{_F?]|o|XNmIOb}HuH'>]^4nZ/bCOʪϵ2obfaD|J" ?pQ#:!8E"椩Fgۥo׸ŀΙ;,H8TӹxGE2sݬ`аM2agƧ a+`T \,ߵ>O08B-kPțՊ(_\7"i}"jSӄ*^VZCs4J4jO:ᵵ|$_ bC#}t(봧r׊'). E[;G5\T -u&;TSgfySt^ ltJ!$K3 sQ9Da;(QSc^n,PW0\@YƀErs$rh ԍp|א4h5/ ܧe u-^o>cw['w fj>4"z-lɫ/Z\kCV>؄Alv-9os]*QY+gCA}_V .ώapŪ9v{~0X,!uZU!ˎLlRK,Ut$q[ItGeSMQu;e __<#?TD(8a($.Xk,CXRoWCDI~IK/.ӽQfmmD29 le ⎼{HϻxQE_"}"4_qN⯵%OQJD|b0>1moѫm_MػV1[|&-9&Dh 6tD˛s.b,,b(Fb{ +> \?ut&ǽَv9™Aއz>d5+Kl|`(B߈1s/wTu\֝<8UEM[%]RPo* OWppZf`;_Nkqpބ&%< [,GJ ɤ«2й(TF3xoXk 0,SE?tVcC5jB .]f hv;D@侕ijA)$'dmVM!RL>GQۖG7Yub+ T*=Ȳ`'rbs0VpnXxARBC;ӥYm %=VAЯ+k#MTkj5$hh ܣhqMeITn1I+E}=B{ A oh*SL`hbʮ)ÝVRGB-XHa#,aR։AX!FGj޺Qק|e 1AW8d50Dzl( T>0eskra8gcp[Dp@oDe[:):*D5a.O&,$x鱰T;~.Cf},՚:5{\]$ciƄT8neF[ Ěqk mи4'0HyӱRgքӄxs3LD/j)⦃Y1(n?h2@V}̳L .@a+v R$VȎ݀E*' 3^2U%u2E{֊`shxtw]'m(jD.DC"y/, DM~ 2HsT.JY`ǣJ`.nIzbJaUy?+dlUWwsSN1s) =c`}Dkz8GWaUټO[aw}4`cc|7jT.{^@T'T0' BH2@`vvT׆ qG]Ip翨w$2ӚChAF<Ѥg9Ԩv$ZOygSH+ݑ4V ~+0, XxO/4^ζ~|j2ZbSac-hS4 {k>ęռňLi/aNN`S17S8|"W̺0M/%^4S=}SBiCgXX1_|uJDòEPWzУ'vX//V02mӮdREI%1[0J9hCh><5*w/T|TbםD  ?y@ʜү=.02C I#js2^P9V}'Op?~A^RuH[V#Q\W(u;zS03xԪ6GHV $OQ߁}{H> $i, )#~2|T Аth*-f>ck1Xz;~kc.)J2i3l"1`sS9) WRhe߮M~舥:^P(vi>80ުeeezͻ'Z*Nr)c 4S%e:%P/ qC5neg6@(t8j8)p%X&BNMV󽛡%iї["5`Z;U_B$EaS=́4k)h?J{kh6Ԗ_@rqd*N^T7@57䦉^33]̵ۧֆ|ԺkJ깛"_J^IY9p⫾Λ";v^Pˢ8fBw\CpdeU,!z"¢|mw]Bx0DnF~ıbPGy],gw!Ӽ(mH mf[$)+ 84}0w2ΰO[>cgP;u'AVܧi5yTw#X.%fQԦE!X\974> 2sUkG)q*Up9}m]>n5 g8W 7e N[ƾ27b<^:P3/mZ"?1* حFYM ~C&n*JBMZ.f8#zḱ ^yDj+t%Mod`|"{W)o:xmՇ/YwN@^ȢxΝ'ly8DQ$4qZ:B^ZDCJcz93:+E-N'O!6L( Xy .SbCA1ZI& pH4KCՅr19.ai /j,͎ߩ%qQ0thB0OЉ&oպvsOլfZì!@ğ:#| m/"ݶfuJAkǻ'汁AzHKʻfc>`%#|-3M:g_Ǖe+$6#uE#^ә4tBiv6tn3C !")bR ]w TVx*G"ץKcfZ?~$D80f#:PȊ}l?"3eUr?_Q'vz!å#MđRFVR>Øԕ?Q$肻L~7 e3jYvi;$W!AHN{%]lT.`%DUѣomTBw Wd y–SmP<7aB=/Zd^F#WGd~݋j:-mr3_$/6PԠ}I-ke:B)J֖GZv^zĨP\wpէ*_IT?!vEQoRza2WSZ8Uzy|PGlP%>lhϟy5CCr M7mfVQd/a뼲 PJ_6(>ozr13ƮqA||黂YQH8|b^uce:v-,5n߁]£R赏xr_}CoȻ67Ջ|)FfRh~\ 3ifP 5r;)s9DG%*٥Ƚ}:MQM [hdwqPi2]k*d~!ؐHޝx*YfH1*2EhɀDt(-tZ '~r"*ޚxG1Vmk!n 0Bg"]`qJ+ adZ؟hG"kda'~%>)bY C8tx"m%|4zn$ƳkmG| ֟ɻ@eH-iyZEK8]CBL9g%,uk7HWu$ 3_BUNg%!j)kBf})hHB> ׳(5fc$Dm(õc21"Cd_Qc^帨?K :]c#?zO$C=VbZU<7[ކ☨^떡[_fw/{-Z+u"9dv;{R$jWB/yWGlD<Kcb$<+e},T -a ʿ, #GL`B( D_뼎)K{ *EDŽ},m !%k;.k :9x= pt'jXʧv@9-1"ސS9 tB2zn RǠͳ9VankaeIRJxoqC Cm_e`9 !Ɵ!Y3m6B?Nipxr=-*뿢ť#Gr-I+Tm̙7$ +O(pl{]P7)H>+ C4W( O@ J{Ƹ\_}( :=O:5;EՖLZ=W ڑ*i? Hu\9L[dk$lj {APP>zs%n8zQ̧ac0i^EN;-g$ZEBbFe!a`WM_O\̂Bu/#6}\5`CzkZ aR\(d~Xɱ*֦D,hن䎦K_a[KL`1"qԘVW<8{-yP}Y`ڻ&j)Ws,B8fvXN Fm-oZ7Q G[ my+~D|w%aV8ӷFНRe\rț4ݻ;lMz!4 UwZ pV%/G%axHbIdI\" (QS^'T@J,,zv6}|5s`\2O'TwCZk"Ʀ"i)FRM:yU-弳euAN!?MnV ţß{~;^dF%*&ƙUB½09JXwQ(̞U- _`drޒeC_W5q^Ozc*v@[:^vF쒼I b;' ,̂0E[eTx@RC-/3[l+s|8ܯ*~m|sP 0F?zƟĖƌD<R"m]?\qk`6G)tl6{\E%o$n̥H;FEȔgEZFw@_M+$hB}7s>9UH3KEښʟ(B}$gs>mGu #݈!ѩ:^C% <3VzI{ZˍQ/\}_U[(˔<7J1(Y,7^qH"bi3s8䮭%~w*Ɏ}]]Rl,PT6zR Q$*ɾgZҐaZ fe-?!}K;Z6kfdֶǔ;&'vR}& UDn4@-OE!&%?I>- T90; mun`iE.ҧIŅG/S8|LRe+˭`jź좂4MYHt0/ G(W`e \]m$~R1pNDȲ_P2ٙ|bo.k 5nTjc?eanaѰ\6]C hC+uODVƟӤ'VP1f8cѤ1[(w^S{+_*wڥ| Q >#s> ƶs $LXnnZ-qe(e n)`ބla+897|NT{Gרd󿬄=ys}䮪Vӽ UG>h)R<-$E @9tѓ=R "=ԥ# sZ|2P)AE%6S=p{\LUE::<N=@h 4R:W,k:a @lGK@bX8.ΒkV55\n+iTLswNfts˖.&oZ[ JmYRq"@E Lp%$6V[O=AYީC U)ݔmhc!L lM٠4`)fj^rg =n߅pL)=^z$h:ΠFA*%ն]vwDq9Qts):iXrهUIԁ!m.۟{@H;Vp(у,u/ aqgQI礝uܑ T9MӔ׷ŢBϟ1!&zwk1Q9yHUSLq¤~Asf&~Wҷ|nݧA]j'U>ɝ{AA*f_ ?lɈs<IiNo7Q%geqb^lqCi 8$AAU0࡮W=$z^gVE`} q4|w{Vd;N÷ ӄ\k6TS"r`:c[U|<08M+W[]*XT7eQ` bjD3[h(0 K¿Bۯn+@OUWC_2\,0XӤ5v7M>EɊDA)CMrD3.⓿A :Lj<6LM"Ȟd"lJfjkE1]HaO - aG 'G z3})&ZfFC5xͼ([c24ؓ W`e?PEȡ\dc8 Ɂݣ' @7`PJgG\AZs"8( Ѱp4^`Ox7$0l j5Gw/6ЯZoA4/1N6B{.=}sZU-l8Gd /m?Myg4 h.F>pE21ʡAQHgYF/( /kpNEc2WWXn>2@Fv T[[4.$rWE;V(>;P.2>] ,Ѧms.2ӥ0N;@=I4 :s%z$paIY6H;WʱRczA X$,Nlm"0Ā,m񊅡uC%f[tüЋ]27z> c V_#d,3k'x`K{L}J$HȾtRhXI\N kWWk)&<c~*bIb'>b*mG!/)Ų .:QPESQuzӔ!D-sf RR*)s,!7|1+Yp:$*\"x|Ϭ+ >KUU\D n%R&Q@#0M_m[tNa&O3m67"dWZ2iX WT(pLXװa RQ2:N`3m}eNg`Yb:N{}BtPmW["z;Gc$8-ى( fF UX uϔrV0/q2 D)29kI*wCX4xn[3-Ҙ4#DUTsw~ >!aï&N(K˱ﷲV$^9C|HSjl|]L[UɥSalf\RDmY_o0A "q6lZ3 4fe5(hDZ6H*)G_{cbr:6Ad1qi 0h⬉eaG)E;ڢb " Ƨ%(N΢.~sЗGiqiu/y\;e3rI#/w zJ / hPwmv%&%fuQESJ7 NtJ;5$JE(IVRN@ڽ%pC<PCܳ?H5 zf(1Wz| &ώox2?k,ِ$ Wt-KP&ZXT6F,W҉7TTz4IH̡@د/&]}]Ѩ;˶1+Г\?s,%Z›>,&![=1'Ro?jGMyVGb@Vz#[v}ՠ *]g4GL;@}e<5>Ftg?eh4OAm 4siav 4wSy7M6rj#}Hsm+BQB{m.~ =gk$ʌcw]*"\8 HjXNڱ?9҉ӥf\);>/ ')/ƥ s?7&HW^*-f`$X|5M W"=Jk;#.#bH9?כ fu MB+xMmc.!ܪz|B -¶= ϕZ e)$(t"8 or( 7aM;X\zܢc6!..R0zIeW}oRprDbb-ZUsY+VHxpг-"#9ʅF]$Fx6'L+y|yȩ 6A2b]&l| ]y" ‰LXȴoɂ,=vB!ѡUiVWx$.ABB2WyU݌J 3γo;r3bW2¹`(toVpárƔӂzj* _t֍Nyj ͢K"b:U2'r'v2@ `nXry(28*ČS(Z4\qku@ Ot *z ]78e?up|5 \ ^ZfشUQDf|A=R V5BLz).pןiڮ[`W[t@A͌8m"d᧕MXI cTXCp~ 5xxb*Ar Hg}NZy_ig?yUPwF.d%ƒn*OhFՠb#F,jX!_GH `1M2[A6Jn3XR)P 'sqND}F8Mof06SPQv.=n_$Q7M!©⫔tn~8JڂhݲX;,'M)$3ICTm 缩A,$ Y3r.;^V 5l˪ot-N{hA2ph+ 4S3+jXkcB 0i(ftǧ[ x`.|w.xHurg E/$Y,̴i :+E9)*RDxހ-H8[g>g wɷbhua`R,I#L80W-ܳќ "+Elc/\ªC+iE@eJ^-zpF{e`<z ?]ezi(<.GӋ^IۜhN TvNVSO0z","ZpןwƧg͏G/s !d 3"0Ow$<<aT+e|1xx1]g<'D@&@^AɏXy*ɛ_nww_2ԑH+YW=9h+PO.ԽX{|jjMwpj*`9d2|ͪ+ʺ'zu@KHx4+U̦}jGy*x(a$vb7b-pЍo0s`'uk7 Uk,Έwn&k+𢳣My-m/r`~%ST88[O͹0t%Q20F;jNΟ?ψ\2aN'!⑕|4'^ X\yX]V<[fy*vm]e-*O<qpJsyt5?Gj[&ʋ[7{J dI3V´Yt1/K[ VaZYqٹf=3)ysY`_ۣp;iڝi'%˺887{1` ^ct񦺰3O_x(" z|9͎  cjԞ[wAS^p;]ٜj`)޳JxһIhqlOlکp ӮϠL/i3I"V/y֏+nK=T4o`NWtꛎC&n`=I8=q '\eW+ ' l:gn͔aHds3/@A%ueJoлy^64ҿD2T#C$#ʽ`Q$2Vm3\/$)Xq%L10'sTU=OC,V1ă{ |z%5|:I>;_#=1Fg=Fzo4dm "wom`70mh\W(ESsGpf_eN!k1Amc]F^;c2|`?.Aʏ>Vɀ*b~>ED/j]AՅ~oQVerOkAf'(s% oMLT=J7 2 3]NǪ 8;\DԐ'rQ믕4T'?hAE0404ccc(Xqn;&,C lO+29R=e@# 8ysN"r r`u6E>Ӣ,ʤ xGyg9EuvhSFݒMz.'q!yoϿl9uCuIޜ5Y;yJV7:--<ډ?H|9T \Pt\ȨbGՆh(2LKi8$zi% ck4tz7%W5)w!I%.Ze0ח.t^uLBl'wVшdyf ك!2ң)g%YE'Z9A&cBwkP^Ysգ3W}5]oNv0"[:%NU쌇12Q6+ca_uPHo~ @eXB\#b{vE)E|3۳3J6#l, '0j/@|ȍߙ|kǰr B=g6ɚLH3Z%w]&cu ?Fӧ}ˎ|hP푈k3_W6 %UH1Uu@|#͛y\InqW- F\~2% PY7N}TA3O/a|g@h1:‰h}]3]Q7A#Ȼ_1^'F%C nsshZ,n_R bՀ@j/^bZ,ȟܽH~uXXr:|\ Y0(̝m. f55|\ ܺW`{vac@{[qH挈I|l?>J6-EK@M~N[Agph<;%4Cuyr9[MrNBL2! L4>,uWY9lG3GI8IuMuY74zHD<]PE|ȑ-̴B7cp oxPd ٨XɺA O<ٌu1_po)?5Oi TUs@*ɳL>>H3?!TwD7~5MDV0?9T"fQydTdyЊLmASZ;+̀Ї&.ϛ;\ aEnk][3* ,9/ |;MIGBVG+ 9pRP9:5ҥ픏s%"Y=Sj+,kupOh]iuʭmO{ n} 6}E?|h7Đ-v1M*@o}fGvc;? uUbb+C 螷Prva">Oߪ܄~1> a,?ݏHAlkKws)~,yrKDk|34EOiysyzL)@'KgpɸHmgB>1A 7Z<*#t.Lkn&9D/v &}IJx7lkO7m^P]'ɩK͆ |ou4 H۷J*Ǟa]Kydi >邦︇IcIk. >4J9HGX$(W!X<[4z._`&VOȀQA7ʗ:m>󴑷B4S`au]G)Tǯ//4vE=8VLe|H=, UC{O3Q,K$Iׯ@f+oNBM4A[>Ԫp'NR6j 3FÆ3p>L~~)=ElU18uQżݑt5͡|gc5IR>ϚEe&jBl"X1Zh:S0 /qMG;Wc?$Kǥ!cnpnq5>nS7[eRμy`N B04k05pN1;.i6 CmtEXG;q1j t v}p#$/J#0(Ro~籶+}-~X<W.݇]jVŴ0* /8E,g#z*pu|Vt<ЧO iS#(v`s%&軿E} Wx9×ުROKR)e : CFGxvLҢӐk}G\Wcl ak!H<eqcGrYBjj!K1^ʌ#~NT̋dEyU9Y5ۄ4Prq/\[:C#F5ja!u/U^KьtrM5/cD-m۩ta*6l bw( SOȚ'-*X`dwz/u>!Jי3W"5L _-…Jgj{ G]O@\:Ĝ< Ⱥhʝ;h+2_='g_ ^](ӝ!L#"S_eMM%h-z3 Rv+_aqD'>ռCkwTj*wDۜ&e 60|/ȁm_)T+yυm0?  #A#5%sd l+iw:Y^u}Wq#.Yo*T%':h>Y68JJbF\d*(uEMsP Efb{bFT> pр{:ټ U&U}MW:cDuV wfI`A-O^͖E=6"n黕 trG~99{ 3|9xؐi8 ?`Y0í*@/{_f G(BR[8=/c;f>~8<C5z~%Lb&{1Մ'̛:HyP)\\ }i!@w?RwX:mD F%sT K5َIO,sWEs@?2C/\ڎT%b3Yޟ}̂o|'W{%ucs*|#>m ~m rmZQKҺ-,2eOßnMmm+뉘 M-N k:#1 }̙v9<"M@zΒnE~Xu)G0oi%P+gр^` !@f =ȣ/,TUr)F_1R&BҶ?Y"h%>}b"32;.3Z2ݴG`FANͤn/F 9 xIqls }?&(RЈO* =hfypQhQuD.N `}G)Ӆ&ܢWoX!n?E{d 5(vC3bpӑh#BX6ރ斪Yz~ZiPA\$P[J~#:\ƏbNddɮ:zafP8@N*_`2/U5|W 궜)Z]BL5g)F j-YtT@Q]i՛)>7 aKaZ>l+y?,];w)/ <)y1c7854*a*6 Y"Nʈ(2~^){#%Ia E t =T7d^@vDŽYݽ%X[gE m@ YPr="!)\PN#9nJ>Qug 䂃v7"sP#3KpR2i;Nߝ=Հ?C,_w d}Ps%(;ܰ!V<,!G|\ LJW$ IbF9>m"|qޠNX YV<ö3NkYr a]@mJYZnoO_SAGJܓ@ pRŮ]}T. 7~c̆eH-[ }Y=/ӆ࡚(  @6Qi PXv̗`/ri5 %/Q0򡙸I f(eL loqP)!aVc$ }UDfIq+E@z/nXoԵ TZ.)U|g&[f>"RE7tiӈi==P*|GH7G 3@JIjÁ*0Jn33s X0EUQY*om5[]~H9};CؗJr3N4ƼDPguȡoۘU'AyWp']ՋUǹTớ rMlTIk1eӳАˬL"Cr0q\޸…toཾ%f" <6L͸5|yMWI&Kз9h4\ʬ]H̆G9ןjIac4zSm;\mP8iqۺB >I5L5;ӕ}>~)2/|b&gCx0#UlG"҅F$! ]&uVxo3unJWؤfs] Ho@Ia|S׍׈'=f'_ x'Kݏ [Tӗk- i'up'ɫKt˩lhŸn44M>NNk.QCdwmEM`-Ȅ (i1Ipoᘳn1(;fmVeBA -q 6^?h- 7杔՝QZrr.}A]QEQbJ~*O.@OUO#jD@Bo3la9XK&)4JSh̐u^O^`[OP>,֑{\˰.(ĄᡴzsղQ#d̕S;=Ky/i/Nyœ搾LɕD]aDn[}1&HG͹0wqR]1=#7m-/XA.*ޫFD-Cg`/(O]%F_}Rn _X~7C60BM(T9Cz" P Uxȓ[fx^T@s0#lEm[Ki-JR9*btF_ #̈+9>uFr!fjc<6ְu lNWj,l}ƹpTLуH"Pl\0m=[a tdD9](r'0#g ۦ\Rca.|x4(@Vr5Ȕ%Q%ܑ]ZuY:ֺ90ڴMn _a)qD\YVMz 7;g~0XC̜HA|R[9SͲ!ùV|rXkW怃$|~F[;%ޖtl<`e`‚_J63‘dM}LrT?z/RBV 4&`0sڻ>J5 f@6&N7@|Wy0`; l?_)9mbfqᥢdoh3d#jg4PqH;,->[ӽCәB^?% ,4U$a2 _+rQ`V Ikc!r$bjэ5h>QU3ms }w;`ZyTC.x^/ñƪ" SzVxV9\uWPT./7gPآg4(n,ْ@ԳRM߁:нُ=r8jG. p Nb(X7Zwҗ]tX^jy<Vb y>$U q}P_\X1+U\v6m>4cZQg,#]Wfve7 cϼ'|trplV{-z.%mgk xpFN31./vWZ0xt+Pˇ3$K8A݃Y J1==Ia879,1*3 KȌ߷n}+pQ'g張L_VWW٨׉;x*Hsd"i!?jxm2l^N+֤Zgy?n}eGo<[4k '&qpu$ڨyNjT̥/Ϣ6k ”q|.`ϣ/ Tօu_]y<{n"BIe : ƕa}u]}2բɳ43qӾGmt MI*I DsHXIUM0̫ijҀER:fN>B1y?Syi$52Zu"޾%_\__)*<晏X&ұOY`kg1M~$hM<=eO'0[UɄnR*5 8)+XU;5W)׷{+q5ԱkxW؁Ŏ5Z*+}.ii0v9