* IS-NIC driver.
*/
-#include <linux/version.h>
#define SLIC_DUMP_ENABLED 0
#define KLUDGE_FOR_4GB_BOUNDARY 1
#include <linux/moduleparam.h>
#include <linux/types.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/pci.h>
#include <linux/dma-mapping.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
#include <linux/mii.h>
#include <linux/if_vlan.h>
-#include <linux/skbuff.h>
-#include <linux/string.h>
#include <asm/unaligned.h>
#include <linux/ethtool.h>
card->reg_value[i], card->reg_valueh[i]);
}
}
-}
#endif
static void slic_init_adapter(struct net_device *netdev,
release_mem_region(mmio_start, mmio_len);
err_out_exit_slic_probe:
+ pci_release_regions(pcidev);
DBG_ERROR("%s EXIT jiffies[%lx] cpu %d\n", __func__, jiffies,
smp_processor_id());
uint mmio_len = 0;
struct adapter *adapter = (struct adapter *) netdev_priv(dev);
struct sliccard *card;
+ struct mcast_address *mcaddr, *mlist;
ASSERT(adapter);
DBG_MSG("slicoss: %s ENTER dev[%p] adapter[%p]\n", __func__, dev,
DBG_MSG("slicoss: %s iounmap dev->base_addr[%x]\n", __func__,
(uint) dev->base_addr);
iounmap((void __iomem *)dev->base_addr);
+ /* free multicast addresses */
+ mlist = adapter->mcastaddrs;
+ while (mlist) {
+ mcaddr = mlist;
+ mlist = mlist->next;
+ kfree(mcaddr);
+ }
ASSERT(adapter->card);
card = adapter->card;
ASSERT(card->adapters_allocated);
}
DBG_MSG("slicoss: %s deallocate device\n", __func__);
kfree(dev);
+ pci_release_regions(pcidev);
DBG_MSG("slicoss: %s EXIT\n", __func__);
}
#ifdef DEBUG_DUMP
if (adapter->kill_card) {
- p_slic_host64_cmd_t ihcmd;
+ struct slic_host64_cmd ihcmd;
ihcmd = &hcmd->cmd64;
unsigned char fruformat;
unsigned char oemfruformat;
struct atk_fru *patkfru;
- union oemfru_t *poemfru;
+ union oemfru *poemfru;
DBG_MSG
("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x] \
* Allocate COMMAND BUFFER
*/
if (!card->cmdbuffer) {
- card->cmdbuffer = kmalloc(sizeof(dump_cmd_t), GFP_ATOMIC);
+ card->cmdbuffer = kmalloc(sizeof(struct dump_cmd), GFP_ATOMIC);
ASSERT(card->cmdbuffer);
if (card->cmdbuffer == NULL)
* Smear the shared memory structure and then obtain
* the PHYSICAL address of this structure
*/
- memset(card->cmdbuffer, 0, sizeof(dump_cmd_t));
+ memset(card->cmdbuffer, 0, sizeof(struct dump_cmd));
card->cmdbuffer_phys = virt_to_bus(card->cmdbuffer);
card->cmdbuffer_physh = SLIC_GET_ADDR_HIGH(card->cmdbuffer_phys);
card->cmdbuffer_physl = SLIC_GET_ADDR_LOW(card->cmdbuffer_phys);
* 50 seconds or whatever STATS_TIMER_INTERVAL is set to.
*
*/
+#if SLIC_GET_STATS_TIMER_ENABLED
static void slic_timer_get_stats(ulong dev)
{
struct adapter *adapter;
SLIC_SECS_TO_JIFFS(STATS_TIMER_INTERVAL);
add_timer(&adapter->statstimer);
}
-
+#endif
static void slic_timer_load_check(ulong cardaddr)
{
struct sliccard *card = (struct sliccard *)cardaddr;
#ifdef MOOKTODO
int i;
struct sliccard *card = seq->private;
- pslic_config_t config = &card->config;
+ struct slic_config *config = &card->config;
unsigned char *fru = (unsigned char *)(&card->config.atk_fru);
unsigned char *oemfru = (unsigned char *)(&card->config.OemFru);
#endif
u32 queue;
u32 len, offset;
u32 sram_size, dram_size, regs;
- sliccore_hdr_t corehdr;
+ struct sliccore_hdr corehdr;
u32 file_offset;
char *namestr;
u32 i;
}
corehdr.driver_version[i] = 0;
- file_offset = sizeof(sliccore_hdr_t);
+ file_offset = sizeof(struct sliccore_hdr);
/*
* Issue the following debug commands to the SLIC:
*/
file_offset = 0;
DBG_MSG("[slicmon] Write CoreHeader len[%x] offset[%x]\n",
- (uint) sizeof(sliccore_hdr_t), file_offset);
+ (uint) sizeof(struct sliccore_hdr), file_offset);
result =
- slic_dump_write(card, &corehdr, sizeof(sliccore_hdr_t),
+ slic_dump_write(card, &corehdr, sizeof(struct sliccore_hdr),
file_offset);
DBG_MSG("[slicmon] corehdr xoff[%x] xsz[%x]\n"
" roff[%x] rsz[%x] fileoff[%x] filesz[%x]\n"
corehdr.XmtRegsize, corehdr.RcvRegOff, corehdr.RcvRegsize,
corehdr.FileRegOff, corehdr.FileRegsize, corehdr.SramOff,
corehdr.Sramsize, corehdr.DramOff, corehdr.Dramsize,
- (uint) sizeof(sliccore_hdr_t));
+ (uint) sizeof(struct sliccore_hdr));
for (i = 0; i < max_queues; i++) {
DBG_MSG("[slicmon] QUEUE 0x%x offset[%x] size[%x]\n",
(uint) i, corehdr.queues[i].queueOff,
static u32 slic_dump_reg(struct sliccard *card, unsigned char proc)
{
- pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
+ struct dump_cmd *dump = (struct dump_cmd *)card->cmdbuffer;
dump->cmd = COMMAND_BYTE(CMD_DUMP, 0, proc);
dump->desc = DESC_REG;
static u32 slic_dump_data(struct sliccard *card,
u32 addr, ushort count, unsigned char desc)
{
- pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
+ struct dump_cmd *dump = (struct dump_cmd *)card->cmdbuffer;
dump->cmd = COMMAND_BYTE(CMD_DUMP, 0, PROC_RECEIVE);
dump->desc = desc;
static u32 slic_dump_queue(struct sliccard *card,
u32 addr, u32 buf_physh, u32 queue)
{
- pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
+ struct dump_cmd *dump = (struct dump_cmd *)card->cmdbuffer;
dump->cmd = COMMAND_BYTE(CMD_DUMP, 0, PROC_RECEIVE);
dump->desc = DESC_QUEUE;
static u32 slic_dump_load_queue(struct sliccard *card, u32 data,
u32 queue)
{
- pdump_cmd_t load = (pdump_cmd_t) card->cmdbuffer;
+ struct dump_cmd *load = (struct dump_cmd *) card->cmdbuffer;
load->cmd = COMMAND_BYTE(CMD_LOAD, 0, PROC_RECEIVE);
load->desc = DESC_QUEUE;
static u32 slic_dump_cam(struct sliccard *card,
u32 addr, u32 count, unsigned char desc)
{
- pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
+ struct dump_cmd *dump = (struct dump_cmd *)card->cmdbuffer;
dump->cmd = COMMAND_BYTE(CMD_CAM_OPS, 0, PROC_NONE);
dump->desc = desc;