[deliverable/linux.git] / drivers / net / jazzsonic.c

/*
 * jazzsonic.c
 *
 * (C) 2005 Finn Thain
 *
 * Converted to DMA API, and (from the mac68k project) introduced
 * dhd's support for 16-bit cards.
 *
 * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
 * 
 * This driver is based on work from Andreas Busse, but most of
 * the code is rewritten.
 * 
 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
 *
 * A driver for the onboard Sonic ethernet controller on Mips Jazz
 * systems (Acer Pica-61, Mips Magnum 4000, Olivetti M700 and
 * perhaps others, too)
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>

#include <asm/bootinfo.h>
#include <asm/system.h>
#include <asm/pgtable.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <asm/jazz.h>
#include <asm/jazzdma.h>

static char jazz_sonic_string[] = "jazzsonic";
static struct platform_device *jazz_sonic_device;

#define SONIC_MEM_SIZE	0x100

#include "sonic.h"

/*
 * Macros to access SONIC registers
 */
#define SONIC_READ(reg) (*((volatile unsigned int *)dev->base_addr+reg))

#define SONIC_WRITE(reg,val)						\
do {									\
	*((volatile unsigned int *)dev->base_addr+(reg)) = (val);		\
} while (0)


/* use 0 for production, 1 for verification, >1 for debug */
#ifdef SONIC_DEBUG
static unsigned int sonic_debug = SONIC_DEBUG;
#else 
static unsigned int sonic_debug = 1;
#endif

/*
 * Base address and interrupt of the SONIC controller on JAZZ boards
 */
static struct {
	unsigned int port;
	unsigned int irq;
} sonic_portlist[] = { {JAZZ_ETHERNET_BASE, JAZZ_ETHERNET_IRQ}, {0, 0}};

/*
 * We cannot use station (ethernet) address prefixes to detect the
 * sonic controller since these are board manufacturer depended.
 * So we check for known Silicon Revision IDs instead. 
 */
static unsigned short known_revisions[] =
{
	0x04,			/* Mips Magnum 4000 */
	0xffff			/* end of list */
};

static int __init sonic_probe1(struct net_device *dev)
{
	static unsigned version_printed;
	unsigned int silicon_revision;
	unsigned int val;
	struct sonic_local *lp = netdev_priv(dev);
	int err = -ENODEV;
	int i;

	if (!request_mem_region(dev->base_addr, SONIC_MEM_SIZE, jazz_sonic_string))
		return -EBUSY;

	/*
	 * get the Silicon Revision ID. If this is one of the known
	 * one assume that we found a SONIC ethernet controller at
	 * the expected location.
	 */
	silicon_revision = SONIC_READ(SONIC_SR);
	if (sonic_debug > 1)
		printk("SONIC Silicon Revision = 0x%04x\n",silicon_revision);

	i = 0;
	while (known_revisions[i] != 0xffff
	       && known_revisions[i] != silicon_revision)
		i++;

	if (known_revisions[i] == 0xffff) {
		printk("SONIC ethernet controller not found (0x%4x)\n",
		       silicon_revision);
		goto out;
	}
    
	if (sonic_debug  &&  version_printed++ == 0)
		printk(version);

	printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ", lp->device->bus_id, dev->base_addr);

	/*
	 * Put the sonic into software reset, then
	 * retrieve and print the ethernet address.
	 */
	SONIC_WRITE(SONIC_CMD,SONIC_CR_RST);
	SONIC_WRITE(SONIC_CEP,0);
	for (i=0; i<3; i++) {
		val = SONIC_READ(SONIC_CAP0-i);
		dev->dev_addr[i*2] = val;
		dev->dev_addr[i*2+1] = val >> 8;
	}

	err = -ENOMEM;
    
	/* Initialize the device structure. */

	lp->dma_bitmode = SONIC_BITMODE32;

	/* Allocate the entire chunk of memory for the descriptors.
           Note that this cannot cross a 64K boundary. */
	if ((lp->descriptors = dma_alloc_coherent(lp->device,
				SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
				&lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
		printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
		goto out;
	}

	/* Now set up the pointers to point to the appropriate places */
	lp->cda = lp->descriptors;
	lp->tda = lp->cda + (SIZEOF_SONIC_CDA
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));
	lp->rda = lp->tda + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));
	lp->rra = lp->rda + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));

	lp->cda_laddr = lp->descriptors_laddr;
	lp->tda_laddr = lp->cda_laddr + (SIZEOF_SONIC_CDA
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));
	lp->rda_laddr = lp->tda_laddr + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));
	lp->rra_laddr = lp->rda_laddr + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
	                     * SONIC_BUS_SCALE(lp->dma_bitmode));

	dev->open = sonic_open;
	dev->stop = sonic_close;
	dev->hard_start_xmit = sonic_send_packet;
	dev->get_stats = sonic_get_stats;
	dev->set_multicast_list = &sonic_multicast_list;
	dev->tx_timeout = sonic_tx_timeout;
	dev->watchdog_timeo = TX_TIMEOUT;

	/*
	 * clear tally counter
	 */
	SONIC_WRITE(SONIC_CRCT,0xffff);
	SONIC_WRITE(SONIC_FAET,0xffff);
	SONIC_WRITE(SONIC_MPT,0xffff);

	return 0;
out:
	release_region(dev->base_addr, SONIC_MEM_SIZE);
	return err;
}

/*
 * Probe for a SONIC ethernet controller on a Mips Jazz board.
 * Actually probing is superfluous but we're paranoid.
 */
static int __init jazz_sonic_probe(struct device *device)
{
	struct net_device *dev;
	struct sonic_local *lp;
	int err = 0;
	int i;

	/*
	 * Don't probe if we're not running on a Jazz board.
	 */
	if (mips_machgroup != MACH_GROUP_JAZZ)
		return -ENODEV;

	dev = alloc_etherdev(sizeof(struct sonic_local));
	if (!dev)
		return -ENOMEM;

	lp = netdev_priv(dev);
	lp->device = device;
	SET_NETDEV_DEV(dev, device);
 	SET_MODULE_OWNER(dev);

	netdev_boot_setup_check(dev);

	if (dev->base_addr >= KSEG0) { /* Check a single specified location. */
		err = sonic_probe1(dev);
	} else if (dev->base_addr != 0) { /* Don't probe at all. */
		err = -ENXIO;
	} else {
		for (i = 0; sonic_portlist[i].port; i++) {
			dev->base_addr = sonic_portlist[i].port;
			dev->irq = sonic_portlist[i].irq;
			if (sonic_probe1(dev) == 0)
				break;
		}
		if (!sonic_portlist[i].port)
			err = -ENODEV;
	}
	if (err)
		goto out;
	err = register_netdev(dev);
	if (err)
		goto out1;

	printk("%s: MAC ", dev->name);
	for (i = 0; i < 6; i++) {
		printk("%2.2x", dev->dev_addr[i]);
		if (i < 5)
			printk(":");
	}
	printk(" IRQ %d\n", dev->irq);

	return 0;

out1:
	release_region(dev->base_addr, SONIC_MEM_SIZE);
out:
	free_netdev(dev);

	return err;
}

MODULE_DESCRIPTION("Jazz SONIC ethernet driver");
module_param(sonic_debug, int, 0);
MODULE_PARM_DESC(sonic_debug, "jazzsonic debug level (1-4)");

#define SONIC_IRQ_FLAG SA_INTERRUPT

#include "sonic.c"

static int __devexit jazz_sonic_device_remove (struct device *device)
{
	struct net_device *dev = device->driver_data;
	struct sonic_local* lp = netdev_priv(dev);

	unregister_netdev (dev);
	dma_free_coherent(lp->device, SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
	                  lp->descriptors, lp->descriptors_laddr);
	release_region (dev->base_addr, SONIC_MEM_SIZE);
	free_netdev (dev);

	return 0;
}

static struct device_driver jazz_sonic_driver = {
	.name	= jazz_sonic_string,
	.bus	= &platform_bus_type,
	.probe	= jazz_sonic_probe,
	.remove	= __devexit_p(jazz_sonic_device_remove),
};

static void jazz_sonic_platform_release (struct device *device)
{
	struct platform_device *pldev;

	/* free device */
	pldev = to_platform_device (device);
	kfree (pldev);
}

static int __init jazz_sonic_init_module(void)
{
	struct platform_device *pldev;
	int err;

	if ((err = driver_register(&jazz_sonic_driver))) {
		printk(KERN_ERR "Driver registration failed\n");
		return err;
	}

	jazz_sonic_device = NULL;

	if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
		goto out_unregister;
	}

	memset(pldev, 0, sizeof (*pldev));
	pldev->name		= jazz_sonic_string;
	pldev->id		= 0;
	pldev->dev.release	= jazz_sonic_platform_release;
	jazz_sonic_device	= pldev;

	if (platform_device_register (pldev)) {
		kfree(pldev);
		jazz_sonic_device = NULL;
	}

	return 0;

out_unregister:
	platform_device_unregister(pldev);

	return -ENOMEM;
}

static void __exit jazz_sonic_cleanup_module(void)
{
	driver_unregister(&jazz_sonic_driver);

	if (jazz_sonic_device) {
		platform_device_unregister(jazz_sonic_device);
		jazz_sonic_device = NULL;
	}
}

module_init(jazz_sonic_init_module);
module_exit(jazz_sonic_cleanup_module);
Commit	Line	Data
1da177e4	1	/*
efcce839 FT	2	* jazzsonic.c
	3	*
	4	* (C) 2005 Finn Thain
	5	*
	6	* Converted to DMA API, and (from the mac68k project) introduced
	7	* dhd's support for 16-bit cards.
1da177e4 LT	8	*
	9	* (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
	10	*
	11	* This driver is based on work from Andreas Busse, but most of
	12	* the code is rewritten.
	13	*
	14	* (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
	15	*
	16	* A driver for the onboard Sonic ethernet controller on Mips Jazz
	17	* systems (Acer Pica-61, Mips Magnum 4000, Olivetti M700 and
	18	* perhaps others, too)
	19	*/
	20
	21	#include <linux/kernel.h>
	22	#include <linux/module.h>
	23	#include <linux/types.h>
	24	#include <linux/fcntl.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/init.h>
	27	#include <linux/ioport.h>
	28	#include <linux/in.h>
	29	#include <linux/slab.h>
	30	#include <linux/string.h>
	31	#include <linux/delay.h>
	32	#include <linux/errno.h>
	33	#include <linux/netdevice.h>
	34	#include <linux/etherdevice.h>
	35	#include <linux/skbuff.h>
d052d1be	36	#include <linux/platform_device.h>
efcce839	37	#include <linux/dma-mapping.h>
1da177e4 LT	38
	39	#include <asm/bootinfo.h>
	40	#include <asm/system.h>
	41	#include <asm/pgtable.h>
	42	#include <asm/io.h>
	43	#include <asm/dma.h>
	44	#include <asm/jazz.h>
	45	#include <asm/jazzdma.h>
	46
	47	static char jazz_sonic_string[] = "jazzsonic";
	48	static struct platform_device *jazz_sonic_device;
	49
	50	#define SONIC_MEM_SIZE 0x100
	51
1da177e4 LT	52	#include "sonic.h"
	53
	54	/*
	55	* Macros to access SONIC registers
	56	*/
efcce839	57	#define SONIC_READ(reg) (((volatile unsigned int )dev->base_addr+reg))
1da177e4 LT	58
	59	#define SONIC_WRITE(reg,val) \
	60	do { \
efcce839	61	((volatile unsigned int )dev->base_addr+(reg)) = (val); \
1da177e4 LT	62	} while (0)
	63
	64
efcce839	65	/* use 0 for production, 1 for verification, >1 for debug */
1da177e4 LT	66	#ifdef SONIC_DEBUG
	67	static unsigned int sonic_debug = SONIC_DEBUG;
	68	#else
	69	static unsigned int sonic_debug = 1;
	70	#endif
	71
	72	/*
	73	* Base address and interrupt of the SONIC controller on JAZZ boards
	74	*/
	75	static struct {
	76	unsigned int port;
	77	unsigned int irq;
	78	} sonic_portlist[] = { {JAZZ_ETHERNET_BASE, JAZZ_ETHERNET_IRQ}, {0, 0}};
	79
	80	/*
	81	* We cannot use station (ethernet) address prefixes to detect the
	82	* sonic controller since these are board manufacturer depended.
	83	* So we check for known Silicon Revision IDs instead.
	84	*/
	85	static unsigned short known_revisions[] =
	86	{
	87	0x04, /* Mips Magnum 4000 */
	88	0xffff /* end of list */
	89	};
	90
efcce839	91	static int __init sonic_probe1(struct net_device *dev)
1da177e4 LT	92	{
	93	static unsigned version_printed;
	94	unsigned int silicon_revision;
	95	unsigned int val;
efcce839	96	struct sonic_local *lp = netdev_priv(dev);
1da177e4 LT	97	int err = -ENODEV;
	98	int i;
	99
efcce839	100	if (!request_mem_region(dev->base_addr, SONIC_MEM_SIZE, jazz_sonic_string))
1da177e4	101	return -EBUSY;
efcce839	102
1da177e4 LT	103	/*
	104	* get the Silicon Revision ID. If this is one of the known
	105	* one assume that we found a SONIC ethernet controller at
	106	* the expected location.
	107	*/
	108	silicon_revision = SONIC_READ(SONIC_SR);
	109	if (sonic_debug > 1)
	110	printk("SONIC Silicon Revision = 0x%04x\n",silicon_revision);
	111
	112	i = 0;
	113	while (known_revisions[i] != 0xffff
	114	&& known_revisions[i] != silicon_revision)
	115	i++;
	116
	117	if (known_revisions[i] == 0xffff) {
	118	printk("SONIC ethernet controller not found (0x%4x)\n",
	119	silicon_revision);
	120	goto out;
	121	}
	122
	123	if (sonic_debug && version_printed++ == 0)
	124	printk(version);
	125
efcce839	126	printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ", lp->device->bus_id, dev->base_addr);
1da177e4 LT	127
	128	/*
	129	* Put the sonic into software reset, then
	130	* retrieve and print the ethernet address.
	131	*/
	132	SONIC_WRITE(SONIC_CMD,SONIC_CR_RST);
	133	SONIC_WRITE(SONIC_CEP,0);
	134	for (i=0; i<3; i++) {
	135	val = SONIC_READ(SONIC_CAP0-i);
	136	dev->dev_addr[i*2] = val;
	137	dev->dev_addr[i*2+1] = val >> 8;
	138	}
	139
1da177e4 LT	140	err = -ENOMEM;
	141
	142	/* Initialize the device structure. */
1da177e4	143
efcce839	144	lp->dma_bitmode = SONIC_BITMODE32;
1da177e4	145
efcce839 FT	146	/* Allocate the entire chunk of memory for the descriptors.
	147	Note that this cannot cross a 64K boundary. */
	148	if ((lp->descriptors = dma_alloc_coherent(lp->device,
	149	SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
	150	&lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
	151	printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
	152	goto out;
1da177e4 LT	153	}
1da177e4 LT	154
efcce839 FT	155	/* Now set up the pointers to point to the appropriate places */
	156	lp->cda = lp->descriptors;
	157	lp->tda = lp->cda + (SIZEOF_SONIC_CDA
	158	* SONIC_BUS_SCALE(lp->dma_bitmode));
	159	lp->rda = lp->tda + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
	160	* SONIC_BUS_SCALE(lp->dma_bitmode));
	161	lp->rra = lp->rda + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
	162	* SONIC_BUS_SCALE(lp->dma_bitmode));
	163
	164	lp->cda_laddr = lp->descriptors_laddr;
	165	lp->tda_laddr = lp->cda_laddr + (SIZEOF_SONIC_CDA
	166	* SONIC_BUS_SCALE(lp->dma_bitmode));
	167	lp->rda_laddr = lp->tda_laddr + (SIZEOF_SONIC_TD * SONIC_NUM_TDS
	168	* SONIC_BUS_SCALE(lp->dma_bitmode));
	169	lp->rra_laddr = lp->rda_laddr + (SIZEOF_SONIC_RD * SONIC_NUM_RDS
	170	* SONIC_BUS_SCALE(lp->dma_bitmode));
	171
1da177e4 LT	172	dev->open = sonic_open;
	173	dev->stop = sonic_close;
	174	dev->hard_start_xmit = sonic_send_packet;
efcce839	175	dev->get_stats = sonic_get_stats;
1da177e4	176	dev->set_multicast_list = &sonic_multicast_list;
efcce839	177	dev->tx_timeout = sonic_tx_timeout;
1da177e4 LT	178	dev->watchdog_timeo = TX_TIMEOUT;
	179
	180	/*
	181	* clear tally counter
	182	*/
	183	SONIC_WRITE(SONIC_CRCT,0xffff);
	184	SONIC_WRITE(SONIC_FAET,0xffff);
	185	SONIC_WRITE(SONIC_MPT,0xffff);
	186
	187	return 0;
1da177e4	188	out:
efcce839	189	release_region(dev->base_addr, SONIC_MEM_SIZE);
1da177e4 LT	190	return err;
	191	}
	192
	193	/*
	194	* Probe for a SONIC ethernet controller on a Mips Jazz board.
	195	* Actually probing is superfluous but we're paranoid.
	196	*/
	197	static int __init jazz_sonic_probe(struct device *device)
	198	{
	199	struct net_device *dev;
	200	struct sonic_local *lp;
1da177e4 LT	201	int err = 0;
	202	int i;
	203
	204	/*
	205	* Don't probe if we're not running on a Jazz board.
	206	*/
	207	if (mips_machgroup != MACH_GROUP_JAZZ)
	208	return -ENODEV;
	209
efcce839	210	dev = alloc_etherdev(sizeof(struct sonic_local));
1da177e4 LT	211	if (!dev)
	212	return -ENOMEM;
	213
efcce839 FT	214	lp = netdev_priv(dev);
	215	lp->device = device;
	216	SET_NETDEV_DEV(dev, device);
	217	SET_MODULE_OWNER(dev);
	218
1da177e4	219	netdev_boot_setup_check(dev);
1da177e4	220
efcce839 FT	221	if (dev->base_addr >= KSEG0) { /* Check a single specified location. */
	222	err = sonic_probe1(dev);
	223	} else if (dev->base_addr != 0) { /* Don't probe at all. */
1da177e4 LT	224	err = -ENXIO;
	225	} else {
	226	for (i = 0; sonic_portlist[i].port; i++) {
efcce839 FT	227	dev->base_addr = sonic_portlist[i].port;
	228	dev->irq = sonic_portlist[i].irq;
	229	if (sonic_probe1(dev) == 0)
1da177e4 LT	230	break;
	231	}
	232	if (!sonic_portlist[i].port)
	233	err = -ENODEV;
	234	}
	235	if (err)
	236	goto out;
	237	err = register_netdev(dev);
	238	if (err)
	239	goto out1;
	240
efcce839 FT	241	printk("%s: MAC ", dev->name);
	242	for (i = 0; i < 6; i++) {
	243	printk("%2.2x", dev->dev_addr[i]);
	244	if (i < 5)
	245	printk(":");
	246	}
	247	printk(" IRQ %d\n", dev->irq);
	248
1da177e4 LT	249	return 0;
	250
	251	out1:
1da177e4 LT	252	release_region(dev->base_addr, SONIC_MEM_SIZE);
	253	out:
	254	free_netdev(dev);
	255
	256	return err;
	257	}
	258
efcce839 FT	259	MODULE_DESCRIPTION("Jazz SONIC ethernet driver");
	260	module_param(sonic_debug, int, 0);
	261	MODULE_PARM_DESC(sonic_debug, "jazzsonic debug level (1-4)");
1da177e4	262
efcce839	263	#define SONIC_IRQ_FLAG SA_INTERRUPT
1da177e4 LT	264
	265	#include "sonic.c"
	266
	267	static int __devexit jazz_sonic_device_remove (struct device *device)
	268	{
	269	struct net_device *dev = device->driver_data;
efcce839	270	struct sonic_local* lp = netdev_priv(dev);
1da177e4 LT	271
1da177e4 LT	272	unregister_netdev (dev);
efcce839 FT	273	dma_free_coherent(lp->device, SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
efcce839 FT	274	lp->descriptors, lp->descriptors_laddr);
1da177e4 LT	275	release_region (dev->base_addr, SONIC_MEM_SIZE);
	276	free_netdev (dev);
	277
	278	return 0;
	279	}
	280
	281	static struct device_driver jazz_sonic_driver = {
	282	.name = jazz_sonic_string,
	283	.bus = &platform_bus_type,
	284	.probe = jazz_sonic_probe,
	285	.remove = __devexit_p(jazz_sonic_device_remove),
	286	};
efcce839	287
1da177e4 LT	288	static void jazz_sonic_platform_release (struct device *device)
	289	{
	290	struct platform_device *pldev;
	291
	292	/* free device */
	293	pldev = to_platform_device (device);
	294	kfree (pldev);
	295	}
	296
	297	static int __init jazz_sonic_init_module(void)
	298	{
	299	struct platform_device *pldev;
efcce839	300	int err;
1da177e4	301
efcce839	302	if ((err = driver_register(&jazz_sonic_driver))) {
1da177e4	303	printk(KERN_ERR "Driver registration failed\n");
efcce839	304	return err;
1da177e4 LT	305	}
	306
	307	jazz_sonic_device = NULL;
	308
	309	if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
	310	goto out_unregister;
	311	}
	312
	313	memset(pldev, 0, sizeof (*pldev));
	314	pldev->name = jazz_sonic_string;
	315	pldev->id = 0;
	316	pldev->dev.release = jazz_sonic_platform_release;
	317	jazz_sonic_device = pldev;
	318
	319	if (platform_device_register (pldev)) {
	320	kfree(pldev);
	321	jazz_sonic_device = NULL;
	322	}
	323
	324	return 0;
	325
	326	out_unregister:
	327	platform_device_unregister(pldev);
	328
	329	return -ENOMEM;
	330	}
	331
	332	static void __exit jazz_sonic_cleanup_module(void)
	333	{
	334	driver_unregister(&jazz_sonic_driver);
	335
	336	if (jazz_sonic_device) {
	337	platform_device_unregister(jazz_sonic_device);
	338	jazz_sonic_device = NULL;
	339	}
	340	}
	341
	342	module_init(jazz_sonic_init_module);
	343	module_exit(jazz_sonic_cleanup_module);