Attachment #109271 for bug #163366

Lines 23-29 Link Here

(-)usr.orig/src/kernel-modules/fritzcapi/fritz.pcmcia/src/driver.h (-1 lines)
23	#ifndef __have_driver_h__	23	#ifndef __have_driver_h__
24	#define __have_driver_h__	24	#define __have_driver_h__
25		25
26	#include <linux/config.h>
27	#include <linux/skbuff.h>	26	#include <linux/skbuff.h>
28	#include <linux/capi.h>	27	#include <linux/capi.h>
29	#include <linux/list.h>	28	#include <linux/list.h>




#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
#define PCMCIA_IRQ_INFO2
#endif
#define NEW_PCMCIA_DRV

/*====================================================================*/
MODULE_LICENSE("GPL");

   handler.
*/

static int cs_config(struct pcmcia_device *link);
static void cs_release(struct pcmcia_device *link);

static void cs_detach(struct pcmcia_device *p_dev);
static int cs_attach(struct pcmcia_device *p_dev);
#else
static int cs_event(event_t event, int priority, event_callback_args_t *);

/*
   The attach() and detach() entry points are used to create and destroy

   needed to manage one actual PCMCIA card.
*/

static void cs_detach(struct pcmcia_device *p_dev);
static void cs_detach(dev_link_t *);
/*
   The dev_info variable is the "key" that is used to match up this
   device driver with appropriate cards, through the card configuration
   database.
*/

static dev_info_t dev_info = "fcpcmcia_cs";

/*
   A linked list of "instances" of the skeleton device.  Each actual
   PCMCIA card corresponds to one device instance, and is described
   by one struct pcmcia_device structure (defined in ds.h).

   You may not want to use a linked list for this -- for example, the
   memory card driver uses an array of struct pcmcia_device pointers, where minor
   device numbers are used to derive the corresponding array index.
*/

static dev_link_t *dev_list = NULL;

#endif
/*
   A dev_link_t structure has fields for most things that are needed
   to keep track of a socket, but there will usually be some device
   specific information that also needs to be kept track of.  The
   'priv' pointer in a dev_link_t structure can be used to point to
   a device-specific private data structure, like this.

   A driver needs to provide a dev_node_t structure for each device
   on a card.  In some cases, there is only one device per card (for
   example, ethernet cards, modems).  In other cases, there may be
   many actual or logical devices (SCSI adapters, memory cards with
   multiple partitions).  The dev_node_t structures need to be kept
   in a linked list starting at the 'dev' field of a struct pcmcia_device
   structure.  We allocate them in the card's private data structure,
   because they generally can't be allocated dynamically.
*/
   
typedef struct local_info_t {
	dev_node_t node;
} local_info_t;

/*======================================================================

    
======================================================================*/

static int cs_probe(struct pcmcia_device *p_dev)
static int cs_attach(struct pcmcia_device *p_dev)
{
	local_info_t *local;
static dev_link_t *cs_attach(void)
{
    client_reg_t client_reg;
    int ret;
#endif
    dev_link_t *link;
    local_info_t *local;
#if defined (PCMCIA_IRQ_INFO2)
	int i;
#endif
    
	NOTE("Attaching device...\n");

	/* The io structure describes IO port mapping */
	p_dev->io.NumPorts1 = 16;
	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	p_dev->io.NumPorts2 = 0;
    memset(link, 0, sizeof(struct dev_link_t));

    /* The io structure describes IO port mapping */
    link->io.NumPorts1 = 16;
    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    link->io.NumPorts2 = 0;

	/* Interrupt setup */
	p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;

#if defined (PCMCIA_IRQ_INFO2)
	p_dev->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
	if (irq_list_count > 0) {
		for (i = 0; (i < irq_list_count) && (irq_list[i] > 0); i++)
			p_dev->irq.IRQInfo2 |= 1 << irq_list[i];
	} else {
		for (i = 0; (i < irq_list_count) && (default_irq_list[i] > 0); i++)
			p_dev->irq.IRQInfo2 |= 1 << default_irq_list[i];
	}
#else
	p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
#endif
    
	/* General socket configuration */
	p_dev->conf.Attributes = CONF_ENABLE_IRQ;
	p_dev->conf.IntType = INT_MEMORY_AND_IO;
	p_dev->conf.ConfigIndex = 1;
	p_dev->conf.Present = PRESENT_OPTION;

	/* Allocate space for private device-specific data */
	local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
	if (!local)
	 	goto err_kfree;
	memset(local, 0, sizeof(local_info_t));
	p_dev->priv = local;
	return cs_config(p_dev);

err_kfree:
	return -ENOMEM;
    p_dev->instance = link;
    link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
    cs_config(link);
    return 0;
#else
    /* Register with Card Services */
    link->next = dev_list;
    dev_list = link;
    client_reg.dev_info = &dev_info;
#if 0
    client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
    client_reg.EventMask =
	CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
	CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
	CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
    client_reg.event_handler = &cs_event;
#endif
    client_reg.Version = 0x0210;
    client_reg.event_callback_args.client_data = link;
    ret = pcmcia_register_client(&link->handle, &client_reg);
    if (ret != 0) {
	cs_error(link->handle, RegisterClient, ret);
	cs_detach(link);
	goto err;
    }
    return link;
#endif
 err_kfree:
    kfree(link);
 err:
#ifdef NEW_PCMCIA_DRV
    return -EINVAL;
#else
    return NULL;
#endif
} /* cs_attach */

/*======================================================================

    when the device is released.

======================================================================*/
#ifdef NEW_PCMCIA_DRV
static void cs_detach(struct pcmcia_device *p_dev)
{
    dev_link_t *link = dev_to_instance(p_dev);

static void cs_detach(struct pcmcia_device *link)
    	cs_release(link);
#else
static void cs_detach(dev_link_t *link)
{
	cs_release(link);
	kfree(link->priv);
}

    /* Locate device structure */
    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
	if (*linkp == link) break;
    if (*linkp == NULL)
	return;

    /*
       If the device is currently configured and active, we won't
       actually delete it yet.  Instead, it is marked so that when
       the release() function is called, that will trigger a proper
       detach().
    */
    if (link->state & DEV_CONFIG) {
	link->state |= DEV_STALE_LINK;
	return;
    }

    /* Break the link with Card Services */
    if (link->handle)
	pcmcia_deregister_client(link->handle);
    
    /* Unlink device structure, free pieces */
    *linkp = link->next;
#endif
    kfree(link->priv);
    kfree(link);
} /* cs_detach */

/*======================================================================


    
======================================================================*/

static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple,
                     cisparse_t *parse)
{
    int i = pcmcia_get_tuple_data(handle, tuple);
    if (i != CS_SUCCESS) return i;
    return pcmcia_parse_tuple(handle, tuple, parse);
}

static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple,
		     cisparse_t *parse)
{
    int i = pcmcia_get_first_tuple(handle, tuple);

    return get_tuple(handle, tuple, parse);
}

static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple,
		     cisparse_t *parse)
{
    int i = pcmcia_get_next_tuple(handle, tuple);

    return get_tuple(handle, tuple, parse);
}

static int cs_config(struct pcmcia_device *link)
{
    client_handle_t handle;
    tuple_t tuple;
    cisparse_t parse;
    cistpl_cftable_entry_t *cf = &parse.cftable_entry;

    int i;
    u_char buf[64];
    char devname[128];
    handle = link->handle;
    dev = link->priv;

    /*

    */
    do {
	tuple.DesiredTuple = CISTPL_CONFIG;
	i = pcmcia_get_first_tuple(link, &tuple);
	if (i != CS_SUCCESS) break;
	tuple.TupleData = buf;
	tuple.TupleDataMax = 64;
	tuple.TupleOffset = 0;
	i = pcmcia_get_tuple_data(link, &tuple);
	if (i != CS_SUCCESS) break;
	i = pcmcia_parse_tuple(link, &tuple, &parse);
	if (i != CS_SUCCESS) break;
	link->conf.ConfigBase = parse.config.base;
    } while (0);
    if (i != CS_SUCCESS) {
	cs_error(link, ParseTuple, i);
        return -ENODEV;
	return;
    }
    
    /* Configure card */
    link->state |= DEV_CONFIG;

    do {


	tuple.DesiredTuple = CISTPL_VERS_1;

	devname[0] = 0;
	if( !first_tuple(link, &tuple, &parse) && parse.version_1.ns > 1 ) {
	    strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1], 
			sizeof(devname));
	}

	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	tuple.Attributes = 0;
	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	i = first_tuple(link, &tuple, &parse);
	while (i == CS_SUCCESS) {
	    if (cf->io.nwin > 0) {
		link->conf.ConfigIndex = cf->index;

                NOTE("testing i/o %#x-%#x\n",
			link->io.BasePort1,
		        link->io.BasePort1+link->io.NumPorts1-1);
		i = pcmcia_request_io(link, &link->io);
		if (i == CS_SUCCESS) goto found_port;
	    }
	    i = next_tuple(link, &tuple, &parse);
	}

found_port:
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestIO, i);
	    break;
	}
	
	/*
	 * allocate an interrupt line
	 */
	i = pcmcia_request_irq(link, &link->irq);
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestIRQ, i);
            /* undo */
            pcmcia_disable_device(link);
	    break;
	}
	
	/*
         * configure the PCMCIA socket
	  */
	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestConfiguration, i);
            pcmcia_disable_device(link);
	    pcmcia_release_irq(link->handle, &link->irq);
	    break;
	}


    strcpy(dev->node.dev_name, "A1");
    dev->node.major = 64;
    dev->node.minor = 0;

    link->dev_node = &dev->node;
    link->state &= ~DEV_CONFIG_PENDING;
    /* If any step failed, release any partially configured state */
    if (i != 0) {
        ERROR("Failed to setup controller, releasing link...\n");
	cs_release(link);
	return -ENODEV;
    }
    NOTE("Ready to call card driver for '%s'...\n", devname);


		link->irq.AssignedIRQ
	);
	cs_release(link);
	return -ENODEV;
    }
    dev->node.minor = i;


	link->io.BasePort1, 
	link->irq.AssignedIRQ
    );
    return 0;
} /* cs_config */

/*======================================================================

    
======================================================================*/

static void cs_release(struct pcmcia_device *link)
{
    fcpcmcia_delcard(link->io.BasePort1, link->irq.AssignedIRQ);

    pcmcia_disable_device(link);
    link->dev = NULL;
    
    /* Don't bother checking to see if these succeed or not */
    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);
    link->state &= ~DEV_CONFIG;
    
#ifndef NEW_PCMCIA_DRV
    if (link->state & DEV_STALE_LINK)
	cs_detach(link);
#endif
} /* cs_release */

#ifdef NEW_PCMCIA_DRV
static int cs_suspend(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state |= DEV_SUSPEND;
	if (link->state & DEV_CONFIG)
		pcmcia_release_configuration(link->handle);

	return 0;
}

static int cs_resume(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state &= ~DEV_SUSPEND;
	if (link->state & DEV_CONFIG)
		pcmcia_request_configuration(link->handle, &link->conf);

	return 0;
}
#else
/*======================================================================

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.  A CARD_REMOVAL event
    also sets some flags to discourage the net drivers from trying
    to talk to the card any more.

    When a CARD_REMOVAL event is received, we immediately set a flag
    to block future accesses to this device.  All the functions that
    actually access the device should check this flag to make sure
    the card is still present.
    
======================================================================*/

static int cs_event(event_t event, int priority, event_callback_args_t *args)
{
    dev_link_t *link = args->client_data;

    LOG("Card service event: %x\n", event);
    switch (event) {
    case CS_EVENT_CARD_REMOVAL:
	link->state &= ~DEV_PRESENT;
	if (link->state & DEV_CONFIG)
		cs_release(link);
	break;
    case CS_EVENT_CARD_INSERTION:
	link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
	cs_config(link);
	break;
    case CS_EVENT_PM_SUSPEND:
	link->state |= DEV_SUSPEND;
	/* Fall through... */
    case CS_EVENT_RESET_PHYSICAL:
	if (link->state & DEV_CONFIG)
	    pcmcia_release_configuration(link->handle);
	break;
    case CS_EVENT_PM_RESUME:
	link->state &= ~DEV_SUSPEND;
	/* Fall through... */
    case CS_EVENT_CARD_RESET:
	if (link->state & DEV_CONFIG)
	    pcmcia_request_configuration(link->handle, &link->conf);
	break;
    }
    return 0;
} /* cs_event */
#endif

static struct pcmcia_device_id fcpcmcia_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN A", 0x95d42008, 0xadc9d4bb),
	PCMCIA_DEVICE_PROD_ID12("ISDN", "CARD", 0x8d9761c8, 0x01c5aa7b),

	.drv	= {
		.name	= "fcpcmcia_cs",
	},
	.probe	= cs_probe,
	.remove	= cs_detach,
	.id_table = fcpcmcia_ids,

	.resume = cs_resume,
#else
	.attach	= cs_attach,
	.detach	= cs_detach,
	.event	= cs_event,
#endif
	.id_table = fcpcmcia_ids, 
};

static int __init cs_init(void)

static void __exit cs_exit(void)
{
	pcmcia_unregister_driver(&cs_driver);

}

module_init(cs_init);

Lines 22-28 Link Here

(-)usr.orig/src/kernel-modules/fritzcapi/fritz.pcmcia/src/main.c (-1 lines)
22		22
23	#include <stdarg.h>	23	#include <stdarg.h>
24	#include <asm/uaccess.h>	24	#include <asm/uaccess.h>
25	#include <linux/config.h>
26	#include <linux/version.h>	25	#include <linux/version.h>
27	#include <linux/kernel.h>	26	#include <linux/kernel.h>
28	#include <linux/module.h>	27	#include <linux/module.h>




extern void lprintf  (const char *, const char *, ...);
extern void vlprintf (const char *, const char *, va_list);



#ifndef atomic_xchg
static inline unsigned long atomic_xchg (
	volatile atomic_t *	v, 
	unsigned		value
) {
	return __xchg (value, &v->counter, sizeof (unsigned));
} /* atomic_xchg */
#endif
/*---------------------------------------------------------------------------*\
\*---------------------------------------------------------------------------*/
#ifndef NDEBUG

Return to bug 163366

Lines 69-84 Link Here

(-)usr.orig/src/kernel-modules/fritzcapi/fritz.pcmcia/src/tools.h (-10 / +2 lines)
69	extern void lprintf (const char , const char , ...);	69	extern void lprintf (const char , const char , ...);
70	extern void vlprintf (const char , const char , va_list);	70	extern void vlprintf (const char , const char , va_list);
71		71
72	/---------------------------------------------------------------------------\	72
73	\---------------------------------------------------------------------------/	73
74	#ifndef atomic_xchg
75	static inline unsigned long atomic_xchg (
76	volatile atomic_t * v,
77	unsigned value
78	) {
79	return __xchg (value, &v->counter, sizeof (unsigned));
80	} /* atomic_xchg */
81	#endif
82	/---------------------------------------------------------------------------\	74	/---------------------------------------------------------------------------\
83	\---------------------------------------------------------------------------/	75	\---------------------------------------------------------------------------/
84	#ifndef NDEBUG	76	#ifndef NDEBUG