#define MAX_DEVICE_COUNT 4
+#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/signal.h>
struct _input_signal_events input_signal_events;
/* PCMCIA support */
- struct pcmcia_device *p_dev;
+ dev_link_t link;
dev_node_t node;
int stop;
/* PCMCIA prototypes */
-static int mgslpc_config(struct pcmcia_device *link);
+static void mgslpc_config(dev_link_t *link);
static void mgslpc_release(u_long arg);
static void mgslpc_detach(struct pcmcia_device *p_dev);
}
}
-static int mgslpc_probe(struct pcmcia_device *link)
+static int mgslpc_attach(struct pcmcia_device *p_dev)
{
MGSLPC_INFO *info;
- int ret;
-
+ dev_link_t *link;
+
if (debug_level >= DEBUG_LEVEL_INFO)
printk("mgslpc_attach\n");
-
+
info = (MGSLPC_INFO *)kmalloc(sizeof(MGSLPC_INFO), GFP_KERNEL);
if (!info) {
printk("Error can't allocate device instance data\n");
info->imrb_value = 0xffff;
info->pim_value = 0xff;
- info->p_dev = link;
+ link = &info->link;
link->priv = info;
-
- /* Initialize the struct pcmcia_device structure */
+
+ /* Initialize the dev_link_t structure */
/* Interrupt setup */
link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
link->irq.IRQInfo1 = IRQ_LEVEL_ID;
link->irq.Handler = NULL;
-
+
link->conf.Attributes = 0;
+ link->conf.Vcc = 50;
link->conf.IntType = INT_MEMORY_AND_IO;
- ret = mgslpc_config(link);
- if (ret)
- return ret;
+ link->handle = p_dev;
+ p_dev->instance = link;
+
+ link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
+ mgslpc_config(link);
mgslpc_add_device(info);
#define CS_CHECK(fn, ret) \
do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
-static int mgslpc_config(struct pcmcia_device *link)
+static void mgslpc_config(dev_link_t *link)
{
+ client_handle_t handle = link->handle;
MGSLPC_INFO *info = link->priv;
tuple_t tuple;
cisparse_t parse;
int last_fn, last_ret;
u_char buf[64];
+ config_info_t conf;
cistpl_cftable_entry_t dflt = { 0 };
cistpl_cftable_entry_t *cfg;
tuple.TupleData = buf;
tuple.TupleDataMax = sizeof(buf);
tuple.TupleOffset = 0;
- CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
- CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
- CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
+ CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
+ CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
+ CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
link->conf.ConfigBase = parse.config.base;
link->conf.Present = parse.config.rmask[0];
+
+ /* Configure card */
+ link->state |= DEV_CONFIG;
+
+ /* Look up the current Vcc */
+ CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
+ link->conf.Vcc = conf.Vcc;
/* get CIS configuration entry */
tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
- CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
+ CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
cfg = &(parse.cftable_entry);
- CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
- CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
+ CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
+ CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
if (cfg->index == 0)
link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
link->io.BasePort1 = io->win[0].base;
link->io.NumPorts1 = io->win[0].len;
- CS_CHECK(RequestIO, pcmcia_request_io(link, &link->io));
+ CS_CHECK(RequestIO, pcmcia_request_io(link->handle, &link->io));
}
link->conf.Attributes = CONF_ENABLE_IRQ;
+ link->conf.Vcc = 50;
link->conf.IntType = INT_MEMORY_AND_IO;
link->conf.ConfigIndex = 8;
link->conf.Present = PRESENT_OPTION;
link->irq.Attributes |= IRQ_HANDLE_PRESENT;
link->irq.Handler = mgslpc_isr;
link->irq.Instance = info;
- CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
+ CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
- CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+ CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
info->io_base = link->io.BasePort1;
info->irq_level = link->irq.AssignedIRQ;
/* add to linked list of devices */
sprintf(info->node.dev_name, "mgslpc0");
info->node.major = info->node.minor = 0;
- link->dev_node = &info->node;
+ link->dev = &info->node;
printk(KERN_INFO "%s: index 0x%02x:",
info->node.dev_name, link->conf.ConfigIndex);
printk(", io 0x%04x-0x%04x", link->io.BasePort1,
link->io.BasePort1+link->io.NumPorts1-1);
printk("\n");
- return 0;
+
+ link->state &= ~DEV_CONFIG_PENDING;
+ return;
cs_failed:
- cs_error(link, last_fn, last_ret);
+ cs_error(link->handle, last_fn, last_ret);
mgslpc_release((u_long)link);
- return -ENODEV;
}
/* Card has been removed.
*/
static void mgslpc_release(u_long arg)
{
- struct pcmcia_device *link = (struct pcmcia_device *)arg;
+ dev_link_t *link = (dev_link_t *)arg;
- if (debug_level >= DEBUG_LEVEL_INFO)
- printk("mgslpc_release(0x%p)\n", link);
+ if (debug_level >= DEBUG_LEVEL_INFO)
+ printk("mgslpc_release(0x%p)\n", link);
- pcmcia_disable_device(link);
+ /* Unlink the device chain */
+ link->dev = NULL;
+ link->state &= ~DEV_CONFIG;
+
+ pcmcia_release_configuration(link->handle);
+ if (link->io.NumPorts1)
+ pcmcia_release_io(link->handle, &link->io);
+ if (link->irq.AssignedIRQ)
+ pcmcia_release_irq(link->handle, &link->irq);
}
-static void mgslpc_detach(struct pcmcia_device *link)
+static void mgslpc_detach(struct pcmcia_device *p_dev)
{
- if (debug_level >= DEBUG_LEVEL_INFO)
- printk("mgslpc_detach(0x%p)\n", link);
+ dev_link_t *link = dev_to_instance(p_dev);
- ((MGSLPC_INFO *)link->priv)->stop = 1;
- mgslpc_release((u_long)link);
+ if (debug_level >= DEBUG_LEVEL_INFO)
+ printk("mgslpc_detach(0x%p)\n", link);
- mgslpc_remove_device((MGSLPC_INFO *)link->priv);
+ if (link->state & DEV_CONFIG) {
+ ((MGSLPC_INFO *)link->priv)->stop = 1;
+ mgslpc_release((u_long)link);
+ }
+
+ mgslpc_remove_device((MGSLPC_INFO *)link->priv);
}
-static int mgslpc_suspend(struct pcmcia_device *link)
+static int mgslpc_suspend(struct pcmcia_device *dev)
{
+ dev_link_t *link = dev_to_instance(dev);
MGSLPC_INFO *info = link->priv;
+ link->state |= DEV_SUSPEND;
info->stop = 1;
+ if (link->state & DEV_CONFIG)
+ pcmcia_release_configuration(link->handle);
return 0;
}
-static int mgslpc_resume(struct pcmcia_device *link)
+static int mgslpc_resume(struct pcmcia_device *dev)
{
+ dev_link_t *link = dev_to_instance(dev);
MGSLPC_INFO *info = link->priv;
+ link->state &= ~DEV_SUSPEND;
+ if (link->state & DEV_CONFIG)
+ pcmcia_request_configuration(link->handle, &link->conf);
info->stop = 0;
return 0;
return rc;
}
-static void bh_handler(void* Context)
+void bh_handler(void* Context)
{
MGSLPC_INFO *info = (MGSLPC_INFO*)Context;
int action;
__FILE__,__LINE__,info->device_name);
}
-static void bh_transmit(MGSLPC_INFO *info)
+void bh_transmit(MGSLPC_INFO *info)
{
struct tty_struct *tty = info->tty;
if (debug_level >= DEBUG_LEVEL_BH)
}
}
-static void bh_status(MGSLPC_INFO *info)
+void bh_status(MGSLPC_INFO *info)
{
info->ri_chkcount = 0;
info->dsr_chkcount = 0;
else
info->input_signal_events.dcd_down++;
#ifdef CONFIG_HDLC
- if (info->netcount) {
- if (info->serial_signals & SerialSignal_DCD)
- netif_carrier_on(info->netdev);
- else
- netif_carrier_off(info->netdev);
- }
+ if (info->netcount)
+ hdlc_set_carrier(info->serial_signals & SerialSignal_DCD, info->netdev);
#endif
wake_up_interruptible(&info->status_event_wait_q);
wake_up_interruptible(&info->event_wait_q);
if (!info)
return IRQ_NONE;
- if (!(info->p_dev->_locked))
+ if (!(info->link.state & DEV_CONFIG))
return IRQ_HANDLED;
spin_lock(&info->lock);
if (mgslpc_paranoia_check(info, tty->name, "mgslpc_put_char"))
return;
- if (!info->tx_buf)
+ if (!tty || !info->tx_buf)
return;
spin_lock_irqsave(&info->lock,flags);
__FILE__,__LINE__,info->device_name,count);
if (mgslpc_paranoia_check(info, tty->name, "mgslpc_write") ||
- !info->tx_buf)
+ !tty || !info->tx_buf)
goto cleanup;
if (info->params.mode == MGSL_MODE_HDLC) {
return ioctl_common(info, cmd, arg);
}
-static int ioctl_common(MGSLPC_INFO *info, unsigned int cmd, unsigned long arg)
+int ioctl_common(MGSLPC_INFO *info, unsigned int cmd, unsigned long arg)
{
int error;
struct mgsl_icount cnow; /* kernel counter temps */
return ((count < begin+len-off) ? count : begin+len-off);
}
-static int rx_alloc_buffers(MGSLPC_INFO *info)
+int rx_alloc_buffers(MGSLPC_INFO *info)
{
/* each buffer has header and data */
info->rx_buf_size = sizeof(RXBUF) + info->max_frame_size;
return 0;
}
-static void rx_free_buffers(MGSLPC_INFO *info)
+void rx_free_buffers(MGSLPC_INFO *info)
{
kfree(info->rx_buf);
info->rx_buf = NULL;
}
-static int claim_resources(MGSLPC_INFO *info)
+int claim_resources(MGSLPC_INFO *info)
{
if (rx_alloc_buffers(info) < 0 ) {
printk( "Cant allocate rx buffer %s\n", info->device_name);
return 0;
}
-static void release_resources(MGSLPC_INFO *info)
+void release_resources(MGSLPC_INFO *info)
{
if (debug_level >= DEBUG_LEVEL_INFO)
printk("release_resources(%s)\n", info->device_name);
*
* Arguments: info pointer to device instance data
*/
-static void mgslpc_add_device(MGSLPC_INFO *info)
+void mgslpc_add_device(MGSLPC_INFO *info)
{
info->next_device = NULL;
info->line = mgslpc_device_count;
#endif
}
-static void mgslpc_remove_device(MGSLPC_INFO *remove_info)
+void mgslpc_remove_device(MGSLPC_INFO *remove_info)
{
MGSLPC_INFO *info = mgslpc_device_list;
MGSLPC_INFO *last = NULL;
.drv = {
.name = "synclink_cs",
},
- .probe = mgslpc_probe,
+ .probe = mgslpc_attach,
.remove = mgslpc_detach,
.id_table = mgslpc_ids,
.suspend = mgslpc_suspend,
write_reg(info, CHA + MODE, val);
}
-static void hdlc_mode(MGSLPC_INFO *info)
+void hdlc_mode(MGSLPC_INFO *info)
{
unsigned char val;
unsigned char clkmode, clksubmode;
rx_stop(info);
}
-static void rx_stop(MGSLPC_INFO *info)
+void rx_stop(MGSLPC_INFO *info)
{
if (debug_level >= DEBUG_LEVEL_ISR)
printk("%s(%d):rx_stop(%s)\n",
info->rx_overflow = 0;
}
-static void rx_start(MGSLPC_INFO *info)
+void rx_start(MGSLPC_INFO *info)
{
if (debug_level >= DEBUG_LEVEL_ISR)
printk("%s(%d):rx_start(%s)\n",
info->rx_enabled = 1;
}
-static void tx_start(MGSLPC_INFO *info)
+void tx_start(MGSLPC_INFO *info)
{
if (debug_level >= DEBUG_LEVEL_ISR)
printk("%s(%d):tx_start(%s)\n",
info->tx_enabled = 1;
}
-static void tx_stop(MGSLPC_INFO *info)
+void tx_stop(MGSLPC_INFO *info)
{
if (debug_level >= DEBUG_LEVEL_ISR)
printk("%s(%d):tx_stop(%s)\n",
/* Reset the adapter to a known state and prepare it for further use.
*/
-static void reset_device(MGSLPC_INFO *info)
+void reset_device(MGSLPC_INFO *info)
{
/* power up both channels (set BIT7) */
write_reg(info, CHA + CCR0, 0x80);
write_reg(info, IPC, 0x05);
}
-static void async_mode(MGSLPC_INFO *info)
+void async_mode(MGSLPC_INFO *info)
{
unsigned char val;
/* Set the HDLC idle mode for the transmitter.
*/
-static void tx_set_idle(MGSLPC_INFO *info)
+void tx_set_idle(MGSLPC_INFO *info)
{
/* Note: ESCC2 only supports flags and one idle modes */
if (info->idle_mode == HDLC_TXIDLE_FLAGS)
/* get state of the V24 status (input) signals.
*/
-static void get_signals(MGSLPC_INFO *info)
+void get_signals(MGSLPC_INFO *info)
{
unsigned char status = 0;
/* Set the state of DTR and RTS based on contents of
* serial_signals member of device extension.
*/
-static void set_signals(MGSLPC_INFO *info)
+void set_signals(MGSLPC_INFO *info)
{
unsigned char val;
set_reg_bits(info, CHA + PVR, PVR_DTR);
}
-static void rx_reset_buffers(MGSLPC_INFO *info)
+void rx_reset_buffers(MGSLPC_INFO *info)
{
RXBUF *buf;
int i;
*
* Returns 1 if frame returned, otherwise 0
*/
-static int rx_get_frame(MGSLPC_INFO *info)
+int rx_get_frame(MGSLPC_INFO *info)
{
unsigned short status;
RXBUF *buf;
return 1;
}
-static BOOLEAN register_test(MGSLPC_INFO *info)
+BOOLEAN register_test(MGSLPC_INFO *info)
{
static unsigned char patterns[] =
{ 0x00, 0xff, 0xaa, 0x55, 0x69, 0x96, 0x0f };
return rc;
}
-static BOOLEAN irq_test(MGSLPC_INFO *info)
+BOOLEAN irq_test(MGSLPC_INFO *info)
{
unsigned long end_time;
unsigned long flags;
return info->irq_occurred ? TRUE : FALSE;
}
-static int adapter_test(MGSLPC_INFO *info)
+int adapter_test(MGSLPC_INFO *info)
{
if (!register_test(info)) {
info->init_error = DiagStatus_AddressFailure;
return 0;
}
-static void trace_block(MGSLPC_INFO *info,const char* data, int count, int xmit)
+void trace_block(MGSLPC_INFO *info,const char* data, int count, int xmit)
{
int i;
int linecount;
/* HDLC frame time out
* update stats and do tx completion processing
*/
-static void tx_timeout(unsigned long context)
+void tx_timeout(unsigned long context)
{
MGSLPC_INFO *info = (MGSLPC_INFO*)context;
unsigned long flags;
}
info->params.encoding = new_encoding;
- info->params.crc_type = new_crctype;
+ info->params.crc_type = new_crctype;;
/* if network interface up, reprogram hardware */
if (info->netcount)
spin_lock_irqsave(&info->lock, flags);
get_signals(info);
spin_unlock_irqrestore(&info->lock, flags);
- if (info->serial_signals & SerialSignal_DCD)
- netif_carrier_on(dev);
- else
- netif_carrier_off(dev);
+ hdlc_set_carrier(info->serial_signals & SerialSignal_DCD, dev);
+
return 0;
}
git://git.onelab.eu / linux-2.6.git / blobdiff