* Frank Pavlic (pavlic@de.ibm.com) and
* Martin Schwidefsky <schwidefsky@de.ibm.com>
*
- * $Revision: 1.68 $ $Date: 2004/03/02 15:34:01 $
+ * $Revision: 1.72 $ $Date: 2004/03/22 09:34:27 $
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
/**
* initialization string for output
*/
-#define VERSION_LCS_C "$Revision: 1.68 $"
+#define VERSION_LCS_C "$Revision: 1.72 $"
static char version[] __initdata = "LCS driver ("VERSION_LCS_C "/" VERSION_LCS_H ")";
+static char debug_buffer[255];
/**
* Some prototypes.
{
int cnt;
- LCS_DBF_TEXT(3, setup, "ichalloc");
+ LCS_DBF_TEXT(2, setup, "ichalloc");
for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
/* alloc memory fo iobuffer */
channel->iob[cnt].data = (void *)
}
if (cnt < LCS_NUM_BUFFS) {
/* Not all io buffers could be allocated. */
- LCS_DBF_TEXT(3, setup, "echalloc");
+ LCS_DBF_TEXT(2, setup, "echalloc");
while (cnt-- > 0)
kfree(channel->iob[cnt].data);
return -ENOMEM;
{
int cnt;
- LCS_DBF_TEXT(3, setup, "ichfree");
+ LCS_DBF_TEXT(2, setup, "ichfree");
for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
if (channel->iob[cnt].data != NULL)
kfree(channel->iob[cnt].data);
}
}
+/*
+ * Cleanup channel.
+ */
+static void
+lcs_cleanup_channel(struct lcs_channel *channel)
+{
+ LCS_DBF_TEXT(3, setup, "cleanch");
+ /* Kill write channel tasklets. */
+ tasklet_kill(&channel->irq_tasklet);
+ /* Free channel buffers. */
+ lcs_free_channel(channel);
+}
+
+/**
+ * LCS free memory for card and channels.
+ */
+static void
+lcs_free_card(struct lcs_card *card)
+{
+ LCS_DBF_TEXT(2, setup, "remcard");
+ LCS_DBF_HEX(2, setup, &card, sizeof(void*));
+ kfree(card);
+}
+
/**
* LCS alloc memory for card and channels
*/
lcs_alloc_card(void)
{
struct lcs_card *card;
+ int rc;
+
+ LCS_DBF_TEXT(2, setup, "alloclcs");
- LCS_DBF_TEXT(3, setup, "alloclcs");
card = kmalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
if (card == NULL)
return NULL;
memset(card, 0, sizeof(struct lcs_card));
card->lan_type = LCS_FRAME_TYPE_AUTO;
card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
- return card;
-}
+ /* Allocate io buffers for the read channel. */
+ rc = lcs_alloc_channel(&card->read);
+ if (rc){
+ LCS_DBF_TEXT(2, setup, "iccwerr");
+ lcs_free_card(card);
+ return NULL;
+ }
+ /* Allocate io buffers for the write channel. */
+ rc = lcs_alloc_channel(&card->write);
+ if (rc) {
+ LCS_DBF_TEXT(2, setup, "iccwerr");
+ lcs_cleanup_channel(&card->read);
+ lcs_free_card(card);
+ return NULL;
+ }
-/**
- * LCS free memory for card and channels.
- */
-static void
-lcs_free_card(struct lcs_card *card)
-{
- LCS_DBF_TEXT(2, setup, "remcard");
- kfree(card);
+ LCS_DBF_HEX(2, setup, &card, sizeof(void*));
+ return card;
}
/*
card->read.buf_idx = 0;
}
-static int
+static void
lcs_setup_read(struct lcs_card *card)
{
- int rc;
+ LCS_DBF_TEXT(3, setup, "initread");
- LCS_DBF_TEXT(3, setup, "readirq");
- /* Allocate io buffers for the read channel. */
- rc = lcs_alloc_channel(&card->read);
- if (rc){
- LCS_DBF_TEXT(3, setup, "iccwerr");
- return rc;
- }
lcs_setup_read_ccws(card);
/* Initialize read channel tasklet. */
card->read.irq_tasklet.data = (unsigned long) &card->read;
card->read.irq_tasklet.func = lcs_tasklet;
/* Initialize waitqueue. */
init_waitqueue_head(&card->read.wait_q);
- return 0;
}
/*
{
int cnt;
- LCS_DBF_TEXT(2, setup, "iwritccw");
+ LCS_DBF_TEXT(3, setup, "iwritccw");
/* Setup write ccws. */
memset(card->write.ccws, 0, sizeof(struct ccw1) * LCS_NUM_BUFFS + 1);
for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
card->write.buf_idx = 0;
}
-static int
+static void
lcs_setup_write(struct lcs_card *card)
{
- int rc;
+ LCS_DBF_TEXT(3, setup, "initwrit");
- LCS_DBF_TEXT(3, setup, "writeirq");
- /* Allocate io buffers for the write channel. */
- rc = lcs_alloc_channel(&card->write);
- if (rc) {
- LCS_DBF_TEXT(3, setup, "iccwerr");
- return rc;
- }
lcs_setup_write_ccws(card);
/* Initialize write channel tasklet. */
card->write.irq_tasklet.data = (unsigned long) &card->write;
card->write.irq_tasklet.func = lcs_tasklet;
/* Initialize waitqueue. */
init_waitqueue_head(&card->write.wait_q);
- return 0;
}
-/*
- * Cleanup channel.
- */
-static void
-lcs_cleanup_channel(struct lcs_channel *channel)
-{
- LCS_DBF_TEXT(3, setup, "cleanch");
- /* Kill write channel tasklets. */
- tasklet_kill(&channel->irq_tasklet);
- /* Free channel buffers. */
- lcs_free_channel(channel);
-}
+
/**
* Initialize channels,card and state machines.
*/
-static int
+static void
lcs_setup_card(struct lcs_card *card)
{
- int rc;
-
- LCS_DBF_TEXT(3, setup, "initcard");
+ LCS_DBF_TEXT(2, setup, "initcard");
+ LCS_DBF_HEX(2, setup, &card, sizeof(void*));
- rc = lcs_setup_read(card);
- if (rc) {
- PRINT_ERR("Could not initialize read channel\n");
- return rc;
- }
- rc = lcs_setup_write(card);
- if (rc) {
- PRINT_ERR("Could not initialize write channel\n");
- lcs_cleanup_channel(&card->read);
- return rc;
- }
+ lcs_setup_read(card);
+ lcs_setup_write(card);
/* Set cards initial state. */
card->state = DEV_STATE_DOWN;
card->tx_buffer = NULL;
INIT_LIST_HEAD(&card->ipm_list);
#endif
INIT_LIST_HEAD(&card->lancmd_waiters);
- return 0;
}
/**
struct lcs_ipm_list *ipm_list;
LCS_DBF_TEXT(3, setup, "cleancrd");
+ LCS_DBF_HEX(2,setup,&card,sizeof(void*));
#ifdef CONFIG_IP_MULTICAST
/* Free multicast list. */
list_for_each_safe(l, n, &card->ipm_list) {
static int
lcs_start_channel(struct lcs_channel *channel)
{
- char dbf_text[15];
unsigned long flags;
int rc;
- sprintf(dbf_text,"ssch%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT_(4,trace,"ssch%s", channel->ccwdev->dev.bus_id);
spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
rc = ccw_device_start(channel->ccwdev,
channel->ccws + channel->io_idx, 0, 0,
channel->state = CH_STATE_RUNNING;
spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
if (rc) {
- sprintf(dbf_text,"essc%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT_(4,trace,"essh%s", channel->ccwdev->dev.bus_id);
PRINT_ERR("Error in starting channel, rc=%d!\n", rc);
}
return rc;
}
+static int
+lcs_clear_channel(struct lcs_channel *channel)
+{
+ unsigned long flags;
+ int rc;
+
+ LCS_DBF_TEXT(4,trace,"clearch");
+ LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
+ spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
+ rc = ccw_device_clear(channel->ccwdev, (addr_t) channel);
+ spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
+ if (rc) {
+ LCS_DBF_TEXT_(4,trace,"ecsc%s", channel->ccwdev->dev.bus_id);
+ return rc;
+ }
+ wait_event(channel->wait_q, (channel->state == CH_STATE_CLEARED));
+ channel->state = CH_STATE_STOPPED;
+ return rc;
+}
+
+
/**
* Stop channel.
*/
static int
lcs_stop_channel(struct lcs_channel *channel)
{
- char dbf_text[15];
unsigned long flags;
int rc;
if (channel->state == CH_STATE_STOPPED)
return 0;
- sprintf(dbf_text,"hsch%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT(4,trace,"haltsch");
+ LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
rc = ccw_device_halt(channel->ccwdev, (addr_t) channel);
spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
if (rc) {
- sprintf(dbf_text,"ehsc%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT_(4,trace,"ehsc%s", channel->ccwdev->dev.bus_id);
return rc;
}
/* Asynchronous halt initialted. Wait for its completion. */
wait_event(channel->wait_q, (channel->state == CH_STATE_HALTED));
+ lcs_clear_channel(channel);
return 0;
}
{
int index;
+ LCS_DBF_TEXT(5, trace, "_getbuff");
index = channel->io_idx;
do {
if (channel->iob[index].state == BUF_STATE_EMPTY) {
struct lcs_buffer *buffer;
unsigned long flags;
+ LCS_DBF_TEXT(5, trace, "getbuff");
spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
buffer = __lcs_get_buffer(channel);
spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
static int
__lcs_resume_channel(struct lcs_channel *channel)
{
- char dbf_text[15];
int rc;
if (channel->state != CH_STATE_SUSPENDED)
return 0;
if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
return 0;
- sprintf(dbf_text,"rsch%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT_(5, trace, "rsch%s", channel->ccwdev->dev.bus_id);
rc = ccw_device_resume(channel->ccwdev);
if (rc) {
- sprintf(dbf_text,"ersc%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(4, trace, dbf_text);
+ LCS_DBF_TEXT_(4, trace, "ersc%s", channel->ccwdev->dev.bus_id);
PRINT_ERR("Error in lcs_resume_channel: rc=%d\n",rc);
} else
channel->state = CH_STATE_RUNNING;
{
int prev, next;
+ LCS_DBF_TEXT(5, trace, "rdybits");
prev = (index - 1) & (LCS_NUM_BUFFS - 1);
next = (index + 1) & (LCS_NUM_BUFFS - 1);
/* Check if we may clear the suspend bit of this buffer. */
unsigned long flags;
int index, rc;
+ LCS_DBF_TEXT(5, trace, "rdybuff");
if (buffer->state != BUF_STATE_LOCKED &&
buffer->state != BUF_STATE_PROCESSED)
BUG();
{
int index, prev, next;
+ LCS_DBF_TEXT(5, trace, "prcsbuff");
if (buffer->state != BUF_STATE_READY)
BUG();
buffer->state = BUF_STATE_PROCESSED;
{
unsigned long flags;
+ LCS_DBF_TEXT(5, trace, "relbuff");
if (buffer->state != BUF_STATE_LOCKED &&
buffer->state != BUF_STATE_PROCESSED)
BUG();
struct lcs_buffer *buffer;
struct lcs_cmd *cmd;
+ LCS_DBF_TEXT(4, trace, "getlncmd");
/* Get buffer and wait if none is available. */
wait_event(card->write.wait_q,
((buffer = lcs_get_buffer(&card->write)) != NULL));
struct list_head *l, *n;
struct lcs_reply *reply;
+ LCS_DBF_TEXT(4, trace, "notiwait");
spin_lock(&card->lock);
list_for_each_safe(l, n, &card->lancmd_waiters) {
reply = list_entry(l, struct lcs_reply, list);
{
struct lcs_reply *reply;
+ LCS_DBF_TEXT(4, trace, "timeout");
reply = (struct lcs_reply *) data;
list_del(&reply->list);
reply->received = 1;
struct lcs_cmd *cmd;
struct timer_list timer;
int rc;
- char buf[16];
+ LCS_DBF_TEXT(4, trace, "sendcmd");
cmd = (struct lcs_cmd *) buffer->data;
cmd->sequence_no = ++card->sequence_no;
cmd->return_code = 0;
add_timer(&timer);
wait_event(reply.wait_q, reply.received);
del_timer(&timer);
- LCS_DBF_TEXT(5, trace, "sendcmd");
- sprintf(buf, "rc:%d", reply.rc);
- LCS_DBF_TEXT(5, trace, buf);
+ LCS_DBF_TEXT_(4, trace, "rc:%d",reply.rc);
return reply.rc ? -EIO : 0;
}
static void
__lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
{
+ LCS_DBF_TEXT(2, trace, "statcb");
memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
}
struct lcs_buffer *buffer;
struct lcs_cmd *cmd;
- LCS_DBF_TEXT(2, trace, "cmdstat");
+ LCS_DBF_TEXT(2,trace, "cmdstat");
buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
cmd = (struct lcs_cmd *) buffer->data;
/* Setup lanstat command. */
static void
__lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
{
+ LCS_DBF_TEXT(2, trace, "srtlancb");
card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
card->portno = cmd->cmd.lcs_std_cmd.portno;
}
cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
&ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
+ LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
return lcs_send_lancmd(card, buffer, NULL);
}
cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
&ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
+ LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
return lcs_send_lancmd(card, buffer, NULL);
}
static void
__lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
{
+ LCS_DBF_TEXT(2, trace, "chkmccb");
card->ip_assists_supported =
cmd->cmd.lcs_qipassist.ip_assists_supported;
card->ip_assists_enabled =
card = (struct lcs_card *) data;
daemonize("fixipm");
- LCS_DBF_TEXT(5, trace, "fixipm");
+ LCS_DBF_TEXT(4,trace, "fixipm");
spin_lock(&card->lock);
list_for_each_safe(l, n, &card->ipm_list) {
ipm = list_entry(l, struct lcs_ipm_list, list);
static void
lcs_get_mac_for_ipm(__u32 ipm, char *mac, struct net_device *dev)
{
+ LCS_DBF_TEXT(4,trace, "getmac");
if (dev->type == ARPHRD_IEEE802_TR)
ip_tr_mc_map(ipm, mac);
else
struct lcs_ipm_list *ipm, *tmp;
struct lcs_card *card;
- LCS_DBF_TEXT(5, trace, "setmulti");
+ LCS_DBF_TEXT(4, trace, "setmulti");
in4_dev = in_dev_get(dev);
if (in4_dev == NULL)
return;
static void
lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
{
- char dbf_text[15];
struct lcs_card *card;
struct lcs_channel *channel;
int index;
- card = (struct lcs_card *)cdev->dev.driver_data;
+ card = CARD_FROM_DEV(cdev);
if (card->read.ccwdev == cdev)
channel = &card->read;
else
channel = &card->write;
- sprintf(dbf_text, "Rint%s", cdev->dev.bus_id);
- LCS_DBF_TEXT(5, trace, dbf_text);
- sprintf(dbf_text, "%4x%4x", irb->scsw.cstat, irb->scsw.dstat);
- LCS_DBF_TEXT(5, trace, dbf_text);
+ LCS_DBF_TEXT_(5, trace, "Rint%s",cdev->dev.bus_id);
+ LCS_DBF_TEXT_(5, trace, "%4x%4x",irb->scsw.cstat, irb->scsw.dstat);
/* How far in the ccw chain have we processed? */
if ((channel->state != CH_STATE_INIT) &&
channel->state = CH_STATE_HALTED;
}
+ if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) {
+ channel->state = CH_STATE_CLEARED;
+ }
/* Do the rest in the tasklet. */
tasklet_schedule(&channel->irq_tasklet);
}
static void
lcs_tasklet(unsigned long data)
{
- char dbf_text[15];
unsigned long flags;
struct lcs_channel *channel;
struct lcs_buffer *iob;
int rc;
channel = (struct lcs_channel *) data;
- sprintf(dbf_text, "tlet%s", channel->ccwdev->dev.bus_id);
- LCS_DBF_TEXT(5, trace, dbf_text);
+ LCS_DBF_TEXT_(5, trace, "tlet%s",channel->ccwdev->dev.bus_id);
/* Check for processed buffers. */
iob = channel->iob;
static void
__lcs_emit_txbuffer(struct lcs_card *card)
{
+ LCS_DBF_TEXT(5, trace, "emittx");
*(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
card->tx_buffer->count += 2;
lcs_ready_buffer(&card->write, card->tx_buffer);
{
struct lcs_card *card;
+ LCS_DBF_TEXT(5, trace, "txbuffcb");
/* Put buffer back to pool. */
lcs_release_buffer(channel, buffer);
card = (struct lcs_card *)
{
struct lcs_header *header;
+ LCS_DBF_TEXT(5, trace, "hardxmit");
if (skb == NULL) {
card->stats.tx_dropped++;
card->stats.tx_errors++;
/* Get new tx buffer */
card->tx_buffer = lcs_get_buffer(&card->write);
if (card->tx_buffer == NULL) {
- netif_stop_queue(dev);
card->stats.tx_dropped++;
return -EBUSY;
}
{
int rc;
+ LCS_DBF_TEXT(2, trace, "strtauto");
#ifdef CONFIG_NET_ETHERNET
card->lan_type = LCS_FRAME_TYPE_ENET;
rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
{
int rc = 0;
- LCS_DBF_TEXT(3, setup," lcsdetct");
+ LCS_DBF_TEXT(2, setup, "lcsdetct");
/* start/reset card */
if (card->dev)
netif_stop_queue(card->dev);
{
int retries;
- LCS_DBF_TEXT(4, trace, "rescard");
+ LCS_DBF_TEXT(2, trace, "rescard");
for (retries = 0; retries < 10; retries++) {
if (lcs_detect(card) == 0) {
netif_wake_queue(card->dev);
int rc;
LCS_DBF_TEXT(3, setup, "stopcard");
+
if (card->read.state != CH_STATE_STOPPED &&
card->write.state != CH_STATE_STOPPED &&
- card->state == DEV_STATE_UP)
+ card->state == DEV_STATE_UP) {
rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
- rc = lcs_send_shutdown(card);
+ rc = lcs_send_shutdown(card);
+ }
rc = lcs_stop_channels(card);
card->state = DEV_STATE_DOWN;
+
return rc;
}
static void
lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
{
+ LCS_DBF_TEXT(5, trace, "getctrl");
if (cmd->initiator == LCS_INITIATOR_LGW) {
switch(cmd->cmd_code) {
case LCS_CMD_STARTUP:
{
struct sk_buff *skb;
+ LCS_DBF_TEXT(5, trace, "getskb");
if (card->dev == NULL ||
card->state != DEV_STATE_UP)
/* The card isn't up. Ignore the packet. */
LCS_DBF_TEXT(2, trace, "stopdev");
card = (struct lcs_card *) dev->priv;
netif_stop_queue(dev);
+ dev->flags &= ~IFF_UP;
rc = lcs_stopcard(card);
if (rc)
PRINT_ERR("Try it again!\n ");
PRINT_ERR("LCS:Error in opening device!\n");
} else {
+ dev->flags |= IFF_UP;
netif_wake_queue(dev);
card->state = DEV_STATE_UP;
}
if (!get_device(&ccwgdev->dev))
return -ENODEV;
- LCS_DBF_TEXT(3, setup, "add_dev");
+ LCS_DBF_TEXT(2, setup, "add_dev");
card = lcs_alloc_card();
if (!card) {
PRINT_ERR("Allocation of lcs card failed\n");
return ret;
}
ccwgdev->dev.driver_data = card;
- ccwgdev->cdev[0]->dev.driver_data = card;
ccwgdev->cdev[0]->handler = lcs_irq;
- ccwgdev->cdev[1]->dev.driver_data = card;
ccwgdev->cdev[1]->handler = lcs_irq;
return 0;
}
+static int
+lcs_register_netdev(struct ccwgroup_device *ccwgdev)
+{
+ struct lcs_card *card;
+
+ LCS_DBF_TEXT(2, setup, "regnetdv");
+ card = (struct lcs_card *)ccwgdev->dev.driver_data;
+ if (card->dev->reg_state != NETREG_UNINITIALIZED)
+ return 0;
+ SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
+ return register_netdev(card->dev);
+}
+
/**
* lcs_new_device will be called by setting the group device online.
*/
+
static int
lcs_new_device(struct ccwgroup_device *ccwgdev)
{
struct lcs_card *card;
- struct net_device *dev;
+ struct net_device *dev=NULL;
+ enum lcs_dev_states recover_state;
int rc;
card = (struct lcs_card *)ccwgdev->dev.driver_data;
if (!card)
return -ENODEV;
+ LCS_DBF_TEXT(2, setup, "newdev");
+ LCS_DBF_HEX(3, setup, &card, sizeof(void*));
card->read.ccwdev = ccwgdev->cdev[0];
card->write.ccwdev = ccwgdev->cdev[1];
+ recover_state = card->state;
ccw_device_set_online(card->read.ccwdev);
ccw_device_set_online(card->write.ccwdev);
LCS_DBF_TEXT(3, setup, "lcsnewdv");
- rc = lcs_setup_card(card);
- if (rc) {
- LCS_DBF_TEXT(3, setup, "errinit");
- PRINT_ERR("LCS card Initialization failed\n");
- return rc;
- }
+ lcs_setup_card(card);
rc = lcs_detect(card);
if (rc) {
lcs_stopcard(card);
lcs_cleanup_card(card);
- return -ENODEV;
+ goto out;
+ }
+ if (card->dev) {
+ LCS_DBF_TEXT(2, setup, "samedev");
+ LCS_DBF_HEX(3, setup, &card, sizeof(void*));
+ goto netdev_out;
}
switch (card->lan_type) {
#ifdef CONFIG_NET_ETHERNET
}
if (!dev)
goto out;
- memcpy(dev->dev_addr, card->mac, LCS_MAC_LENGTH);
card->dev = dev;
- dev->priv = card;
- dev->open = lcs_open_device;
- dev->stop = lcs_stop_device;
- dev->hard_start_xmit = lcs_start_xmit;
+netdev_out:
+ card->dev->priv = card;
+ card->dev->open = lcs_open_device;
+ card->dev->stop = lcs_stop_device;
+ card->dev->hard_start_xmit = lcs_start_xmit;
+ card->dev->get_stats = lcs_getstats;
+ SET_MODULE_OWNER(dev);
+ if (lcs_register_netdev(ccwgdev) != 0)
+ goto out;
+ memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
#ifdef CONFIG_IP_MULTICAST
if (lcs_check_multicast_support(card))
- dev->set_multicast_list = lcs_set_multicast_list;
+ card->dev->set_multicast_list = lcs_set_multicast_list;
#endif
- dev->get_stats = lcs_getstats;
- SET_MODULE_OWNER(dev);
- if (register_netdev(dev) != 0)
- goto out;
- /* Create symlinks. */
- SET_NETDEV_DEV(dev, &ccwgdev->dev);
+ netif_stop_queue(card->dev);
+ if (recover_state == DEV_STATE_RECOVER) {
+ card->dev->flags |= IFF_UP;
+ netif_wake_queue(card->dev);
+ card->state = DEV_STATE_UP;
+ } else
+ lcs_stopcard(card);
- netif_stop_queue(dev);
- lcs_stopcard(card);
return 0;
out:
+
+ ccw_device_set_offline(card->read.ccwdev);
+ ccw_device_set_offline(card->write.ccwdev);
lcs_cleanup_card(card);
return -ENODEV;
}
lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
{
struct lcs_card *card;
+ enum lcs_dev_states recover_state;
int ret;
LCS_DBF_TEXT(3, setup, "shtdndev");
if (!card)
return -ENODEV;
+ LCS_DBF_HEX(3, setup, &card, sizeof(void*));
+ recover_state = card->state;
+
ret = lcs_stop_device(card->dev);
+ ret = ccw_device_set_offline(card->read.ccwdev);
+ ret = ccw_device_set_offline(card->write.ccwdev);
+ if (recover_state == DEV_STATE_UP) {
+ card->state = DEV_STATE_RECOVER;
+ }
if (ret)
return ret;
- unregister_netdev(card->dev);
return 0;
}
{
struct lcs_card *card;
- LCS_DBF_TEXT(3, setup, "remdev");
card = (struct lcs_card *)ccwgdev->dev.driver_data;
if (!card)
return;
+
+ PRINT_INFO("Removing lcs group device ....\n");
+ LCS_DBF_TEXT(3, setup, "remdev");
+ LCS_DBF_HEX(3, setup, &card, sizeof(void*));
if (ccwgdev->state == CCWGROUP_ONLINE) {
- lcs_stop_device(card->dev); /* Ignore rc. */
- unregister_netdev(card->dev);
+ lcs_shutdown_device(ccwgdev);
}
+ unregister_netdev(card->dev);
sysfs_remove_group(&ccwgdev->dev.kobj, &lcs_attr_group);
lcs_cleanup_card(card);
lcs_free_card(card);
projects / linux / commitdiff