[linux-2.6-block.git] / drivers / media / dvb / b2c2 / flexcop.c

/*
 * Linux driver for digital TV devices equipped with B2C2 FlexcopII(b)/III
 * flexcop.c - main module part
 * Copyright (C) 2004-9 Patrick Boettcher <patrick.boettcher@desy.de>
 * based on skystar2-driver Copyright (C) 2003 Vadim Catana, skystar@moldova.cc
 *
 * Acknowledgements:
 *   John Jurrius from BBTI, Inc. for extensive support
 *                    with code examples and data books
 *   Bjarne Steinsbo, bjarne at steinsbo.com (some ideas for rewriting)
 *
 * Contributions to the skystar2-driver have been done by
 *   Vincenzo Di Massa, hawk.it at tiscalinet.it (several DiSEqC fixes)
 *   Roberto Ragusa, r.ragusa at libero.it (polishing, restyling the code)
 *   Uwe Bugla, uwe.bugla at gmx.de (doing tests, restyling code, writing docu)
 *   Niklas Peinecke, peinecke at gdv.uni-hannover.de (hardware pid/mac
 *               filtering)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include "flexcop.h"

#define DRIVER_NAME "B2C2 FlexcopII/II(b)/III digital TV receiver chip"
#define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de"

#ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
#define DEBSTATUS ""
#else
#define DEBSTATUS " (debugging is not enabled)"
#endif

int b2c2_flexcop_debug;
module_param_named(debug, b2c2_flexcop_debug,  int, 0644);
MODULE_PARM_DESC(debug,
		"set debug level (1=info,2=tuner,4=i2c,8=ts,"
		"16=sram,32=reg (|-able))."
		DEBSTATUS);
#undef DEBSTATUS

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

/* global zero for ibi values */
flexcop_ibi_value ibi_zero;

static int flexcop_dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
{
	struct flexcop_device *fc = dvbdmxfeed->demux->priv;
	return flexcop_pid_feed_control(fc, dvbdmxfeed, 1);
}

static int flexcop_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
{
	struct flexcop_device *fc = dvbdmxfeed->demux->priv;
	return flexcop_pid_feed_control(fc, dvbdmxfeed, 0);
}

static int flexcop_dvb_init(struct flexcop_device *fc)
{
	int ret = dvb_register_adapter(&fc->dvb_adapter,
			"FlexCop Digital TV device", fc->owner,
			fc->dev, adapter_nr);
	if (ret < 0) {
		err("error registering DVB adapter");
		return ret;
	}
	fc->dvb_adapter.priv = fc;

	fc->demux.dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING
			| DMX_MEMORY_BASED_FILTERING);
	fc->demux.priv = fc;
	fc->demux.filternum = fc->demux.feednum = FC_MAX_FEED;
	fc->demux.start_feed = flexcop_dvb_start_feed;
	fc->demux.stop_feed = flexcop_dvb_stop_feed;
	fc->demux.write_to_decoder = NULL;

	ret = dvb_dmx_init(&fc->demux);
	if (ret < 0) {
		err("dvb_dmx failed: error %d", ret);
		goto err_dmx;
	}

	fc->hw_frontend.source = DMX_FRONTEND_0;

	fc->dmxdev.filternum = fc->demux.feednum;
	fc->dmxdev.demux = &fc->demux.dmx;
	fc->dmxdev.capabilities = 0;
	ret = dvb_dmxdev_init(&fc->dmxdev, &fc->dvb_adapter);
	if (ret < 0) {
		err("dvb_dmxdev_init failed: error %d", ret);
		goto err_dmx_dev;
	}

	ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->hw_frontend);
	if (ret < 0) {
		err("adding hw_frontend to dmx failed: error %d", ret);
		goto err_dmx_add_hw_frontend;
	}

	fc->mem_frontend.source = DMX_MEMORY_FE;
	ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->mem_frontend);
	if (ret < 0) {
		err("adding mem_frontend to dmx failed: error %d", ret);
		goto err_dmx_add_mem_frontend;
	}

	ret = fc->demux.dmx.connect_frontend(&fc->demux.dmx, &fc->hw_frontend);
	if (ret < 0) {
		err("connect frontend failed: error %d", ret);
		goto err_connect_frontend;
	}

	ret = dvb_net_init(&fc->dvb_adapter, &fc->dvbnet, &fc->demux.dmx);
	if (ret < 0) {
		err("dvb_net_init failed: error %d", ret);
		goto err_net;
	}

	fc->init_state |= FC_STATE_DVB_INIT;
	return 0;

err_net:
	fc->demux.dmx.disconnect_frontend(&fc->demux.dmx);
err_connect_frontend:
	fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->mem_frontend);
err_dmx_add_mem_frontend:
	fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->hw_frontend);
err_dmx_add_hw_frontend:
	dvb_dmxdev_release(&fc->dmxdev);
err_dmx_dev:
	dvb_dmx_release(&fc->demux);
err_dmx:
	dvb_unregister_adapter(&fc->dvb_adapter);
	return ret;
}

static void flexcop_dvb_exit(struct flexcop_device *fc)
{
	if (fc->init_state & FC_STATE_DVB_INIT) {
		dvb_net_release(&fc->dvbnet);

		fc->demux.dmx.close(&fc->demux.dmx);
		fc->demux.dmx.remove_frontend(&fc->demux.dmx,
			&fc->mem_frontend);
		fc->demux.dmx.remove_frontend(&fc->demux.dmx,
			&fc->hw_frontend);
		dvb_dmxdev_release(&fc->dmxdev);
		dvb_dmx_release(&fc->demux);
		dvb_unregister_adapter(&fc->dvb_adapter);
		deb_info("deinitialized dvb stuff\n");
	}
	fc->init_state &= ~FC_STATE_DVB_INIT;
}

/* these methods are necessary to achieve the long-term-goal of hiding the
 * struct flexcop_device from the bus-parts */
void flexcop_pass_dmx_data(struct flexcop_device *fc, u8 *buf, u32 len)
{
	dvb_dmx_swfilter(&fc->demux, buf, len);
}
EXPORT_SYMBOL(flexcop_pass_dmx_data);

void flexcop_pass_dmx_packets(struct flexcop_device *fc, u8 *buf, u32 no)
{
	dvb_dmx_swfilter_packets(&fc->demux, buf, no);
}
EXPORT_SYMBOL(flexcop_pass_dmx_packets);

static void flexcop_reset(struct flexcop_device *fc)
{
	flexcop_ibi_value v210, v204;

	/* reset the flexcop itself */
	fc->write_ibi_reg(fc,ctrl_208,ibi_zero);

	v210.raw = 0;
	v210.sw_reset_210.reset_block_000 = 1;
	v210.sw_reset_210.reset_block_100 = 1;
	v210.sw_reset_210.reset_block_200 = 1;
	v210.sw_reset_210.reset_block_300 = 1;
	v210.sw_reset_210.reset_block_400 = 1;
	v210.sw_reset_210.reset_block_500 = 1;
	v210.sw_reset_210.reset_block_600 = 1;
	v210.sw_reset_210.reset_block_700 = 1;
	v210.sw_reset_210.Block_reset_enable = 0xb2;
	v210.sw_reset_210.Special_controls = 0xc259;
	fc->write_ibi_reg(fc,sw_reset_210,v210);
	msleep(1);

	/* reset the periphical devices */

	v204 = fc->read_ibi_reg(fc,misc_204);
	v204.misc_204.Per_reset_sig = 0;
	fc->write_ibi_reg(fc,misc_204,v204);
	msleep(1);
	v204.misc_204.Per_reset_sig = 1;
	fc->write_ibi_reg(fc,misc_204,v204);
}

void flexcop_reset_block_300(struct flexcop_device *fc)
{
	flexcop_ibi_value v208_save = fc->read_ibi_reg(fc, ctrl_208),
			  v210 = fc->read_ibi_reg(fc, sw_reset_210);

	deb_rdump("208: %08x, 210: %08x\n", v208_save.raw, v210.raw);
	fc->write_ibi_reg(fc,ctrl_208,ibi_zero);

	v210.sw_reset_210.reset_block_300 = 1;
	v210.sw_reset_210.Block_reset_enable = 0xb2;

	fc->write_ibi_reg(fc,sw_reset_210,v210);
	fc->write_ibi_reg(fc,ctrl_208,v208_save);
}

struct flexcop_device *flexcop_device_kmalloc(size_t bus_specific_len)
{
	void *bus;
	struct flexcop_device *fc = kzalloc(sizeof(struct flexcop_device),
				GFP_KERNEL);
	if (!fc) {
		err("no memory");
		return NULL;
	}

	bus = kzalloc(bus_specific_len, GFP_KERNEL);
	if (!bus) {
		err("no memory");
		kfree(fc);
		return NULL;
	}

	fc->bus_specific = bus;

	return fc;
}
EXPORT_SYMBOL(flexcop_device_kmalloc);

void flexcop_device_kfree(struct flexcop_device *fc)
{
	kfree(fc->bus_specific);
	kfree(fc);
}
EXPORT_SYMBOL(flexcop_device_kfree);

int flexcop_device_initialize(struct flexcop_device *fc)
{
	int ret;
	ibi_zero.raw = 0;

	flexcop_reset(fc);
	flexcop_determine_revision(fc);
	flexcop_sram_init(fc);
	flexcop_hw_filter_init(fc);
	flexcop_smc_ctrl(fc, 0);

	ret = flexcop_dvb_init(fc);
	if (ret)
		goto error;

	/* i2c has to be done before doing EEProm stuff -
	 * because the EEProm is accessed via i2c */
	ret = flexcop_i2c_init(fc);
	if (ret)
		goto error;

	/* do the MAC address reading after initializing the dvb_adapter */
	if (fc->get_mac_addr(fc, 0) == 0) {
		u8 *b = fc->dvb_adapter.proposed_mac;
		info("MAC address = %pM", b);
		flexcop_set_mac_filter(fc,b);
		flexcop_mac_filter_ctrl(fc,1);
	} else
		warn("reading of MAC address failed.\n");

	ret = flexcop_frontend_init(fc);
	if (ret)
		goto error;

	flexcop_device_name(fc,"initialization of","complete");
	return 0;

error:
	flexcop_device_exit(fc);
	return ret;
}
EXPORT_SYMBOL(flexcop_device_initialize);

void flexcop_device_exit(struct flexcop_device *fc)
{
	flexcop_frontend_exit(fc);
	flexcop_i2c_exit(fc);
	flexcop_dvb_exit(fc);
}
EXPORT_SYMBOL(flexcop_device_exit);

static int flexcop_module_init(void)
{
	info(DRIVER_NAME " loaded successfully");
	return 0;
}

static void flexcop_module_cleanup(void)
{
	info(DRIVER_NAME " unloaded successfully");
}

module_init(flexcop_module_init);
module_exit(flexcop_module_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_NAME);
MODULE_LICENSE("GPL");
Commit	Line	Data
2add87a9	1	/*
1589a993 UB	2	* Linux driver for digital TV devices equipped with B2C2 FlexcopII(b)/III
	3	* flexcop.c - main module part
	4	* Copyright (C) 2004-9 Patrick Boettcher <patrick.boettcher@desy.de>
	5	* based on skystar2-driver Copyright (C) 2003 Vadim Catana, skystar@moldova.cc
2add87a9 JS	6	*
2add87a9 JS	7	* Acknowledgements:
1589a993 UB	8	* John Jurrius from BBTI, Inc. for extensive support
	9	* with code examples and data books
	10	* Bjarne Steinsbo, bjarne at steinsbo.com (some ideas for rewriting)
2add87a9 JS	11	*
2add87a9 JS	12	* Contributions to the skystar2-driver have been done by
1589a993 UB	13	* Vincenzo Di Massa, hawk.it at tiscalinet.it (several DiSEqC fixes)
	14	* Roberto Ragusa, r.ragusa at libero.it (polishing, restyling the code)
	15	* Uwe Bugla, uwe.bugla at gmx.de (doing tests, restyling code, writing docu)
	16	* Niklas Peinecke, peinecke at gdv.uni-hannover.de (hardware pid/mac
	17	* filtering)
2add87a9 JS	18	*
	19	* This program is free software; you can redistribute it and/or
	20	* modify it under the terms of the GNU Lesser General Public License
	21	* as published by the Free Software Foundation; either version 2.1
	22	* of the License, or (at your option) any later version.
	23	*
	24	* This program is distributed in the hope that it will be useful,
	25	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	26	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	27	* GNU General Public License for more details.
	28	*
	29	* You should have received a copy of the GNU Lesser General Public License
	30	* along with this program; if not, write to the Free Software
	31	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	32	*/
	33
	34	#include "flexcop.h"
	35
	36	#define DRIVER_NAME "B2C2 FlexcopII/II(b)/III digital TV receiver chip"
	37	#define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de"
	38
	39	#ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
	40	#define DEBSTATUS ""
	41	#else
	42	#define DEBSTATUS " (debugging is not enabled)"
	43	#endif
	44
	45	int b2c2_flexcop_debug;
	46	module_param_named(debug, b2c2_flexcop_debug, int, 0644);
1589a993 UB	47	MODULE_PARM_DESC(debug,
	48	"set debug level (1=info,2=tuner,4=i2c,8=ts,"
	49	"16=sram,32=reg (\|-able))."
	50	DEBSTATUS);
2add87a9 JS	51	#undef DEBSTATUS
2add87a9 JS	52
78e92006 JG	53	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
78e92006 JG	54
2add87a9 JS	55	/* global zero for ibi values */
	56	flexcop_ibi_value ibi_zero;
	57
	58	static int flexcop_dvb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
	59	{
	60	struct flexcop_device *fc = dvbdmxfeed->demux->priv;
1589a993	61	return flexcop_pid_feed_control(fc, dvbdmxfeed, 1);
2add87a9 JS	62	}
	63
	64	static int flexcop_dvb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
	65	{
	66	struct flexcop_device *fc = dvbdmxfeed->demux->priv;
1589a993	67	return flexcop_pid_feed_control(fc, dvbdmxfeed, 0);
2add87a9 JS	68	}
	69
	70	static int flexcop_dvb_init(struct flexcop_device *fc)
	71	{
78e92006	72	int ret = dvb_register_adapter(&fc->dvb_adapter,
1589a993 UB	73	"FlexCop Digital TV device", fc->owner,
1589a993 UB	74	fc->dev, adapter_nr);
78e92006	75	if (ret < 0) {
2add87a9 JS	76	err("error registering DVB adapter");
	77	return ret;
	78	}
	79	fc->dvb_adapter.priv = fc;
	80
1589a993 UB	81	fc->demux.dmx.capabilities = (DMX_TS_FILTERING \| DMX_SECTION_FILTERING
1589a993 UB	82	\| DMX_MEMORY_BASED_FILTERING);
2add87a9	83	fc->demux.priv = fc;
2add87a9	84	fc->demux.filternum = fc->demux.feednum = FC_MAX_FEED;
2add87a9 JS	85	fc->demux.start_feed = flexcop_dvb_start_feed;
	86	fc->demux.stop_feed = flexcop_dvb_stop_feed;
	87	fc->demux.write_to_decoder = NULL;
	88
efd279ec JN	89	ret = dvb_dmx_init(&fc->demux);
efd279ec JN	90	if (ret < 0) {
1589a993	91	err("dvb_dmx failed: error %d", ret);
2add87a9 JS	92	goto err_dmx;
	93	}
	94
	95	fc->hw_frontend.source = DMX_FRONTEND_0;
	96
	97	fc->dmxdev.filternum = fc->demux.feednum;
	98	fc->dmxdev.demux = &fc->demux.dmx;
	99	fc->dmxdev.capabilities = 0;
efd279ec JN	100	ret = dvb_dmxdev_init(&fc->dmxdev, &fc->dvb_adapter);
efd279ec JN	101	if (ret < 0) {
1589a993	102	err("dvb_dmxdev_init failed: error %d", ret);
2add87a9 JS	103	goto err_dmx_dev;
	104	}
	105
efd279ec JN	106	ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->hw_frontend);
efd279ec JN	107	if (ret < 0) {
1589a993	108	err("adding hw_frontend to dmx failed: error %d", ret);
2add87a9 JS	109	goto err_dmx_add_hw_frontend;
	110	}
	111
	112	fc->mem_frontend.source = DMX_MEMORY_FE;
efd279ec JN	113	ret = fc->demux.dmx.add_frontend(&fc->demux.dmx, &fc->mem_frontend);
efd279ec JN	114	if (ret < 0) {
1589a993	115	err("adding mem_frontend to dmx failed: error %d", ret);
2add87a9 JS	116	goto err_dmx_add_mem_frontend;
	117	}
	118
efd279ec JN	119	ret = fc->demux.dmx.connect_frontend(&fc->demux.dmx, &fc->hw_frontend);
efd279ec JN	120	if (ret < 0) {
1589a993	121	err("connect frontend failed: error %d", ret);
2add87a9 JS	122	goto err_connect_frontend;
	123	}
	124
01732eba JN	125	ret = dvb_net_init(&fc->dvb_adapter, &fc->dvbnet, &fc->demux.dmx);
	126	if (ret < 0) {
	127	err("dvb_net_init failed: error %d", ret);
	128	goto err_net;
	129	}
2add87a9 JS	130
2add87a9 JS	131	fc->init_state \|= FC_STATE_DVB_INIT;
8397703e	132	return 0;
2add87a9	133
01732eba JN	134	err_net:
01732eba JN	135	fc->demux.dmx.disconnect_frontend(&fc->demux.dmx);
2add87a9	136	err_connect_frontend:
1589a993	137	fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->mem_frontend);
2add87a9	138	err_dmx_add_mem_frontend:
1589a993	139	fc->demux.dmx.remove_frontend(&fc->demux.dmx, &fc->hw_frontend);
2add87a9 JS	140	err_dmx_add_hw_frontend:
	141	dvb_dmxdev_release(&fc->dmxdev);
	142	err_dmx_dev:
	143	dvb_dmx_release(&fc->demux);
	144	err_dmx:
	145	dvb_unregister_adapter(&fc->dvb_adapter);
	146	return ret;
2add87a9 JS	147	}
	148
	149	static void flexcop_dvb_exit(struct flexcop_device *fc)
	150	{
	151	if (fc->init_state & FC_STATE_DVB_INIT) {
	152	dvb_net_release(&fc->dvbnet);
	153
	154	fc->demux.dmx.close(&fc->demux.dmx);
1589a993 UB	155	fc->demux.dmx.remove_frontend(&fc->demux.dmx,
	156	&fc->mem_frontend);
	157	fc->demux.dmx.remove_frontend(&fc->demux.dmx,
	158	&fc->hw_frontend);
2add87a9 JS	159	dvb_dmxdev_release(&fc->dmxdev);
	160	dvb_dmx_release(&fc->demux);
	161	dvb_unregister_adapter(&fc->dvb_adapter);
2add87a9 JS	162	deb_info("deinitialized dvb stuff\n");
	163	}
	164	fc->init_state &= ~FC_STATE_DVB_INIT;
	165	}
	166
	167	/* these methods are necessary to achieve the long-term-goal of hiding the
	168	* struct flexcop_device from the bus-parts */
	169	void flexcop_pass_dmx_data(struct flexcop_device fc, u8 buf, u32 len)
	170	{
	171	dvb_dmx_swfilter(&fc->demux, buf, len);
	172	}
	173	EXPORT_SYMBOL(flexcop_pass_dmx_data);
	174
	175	void flexcop_pass_dmx_packets(struct flexcop_device fc, u8 buf, u32 no)
	176	{
	177	dvb_dmx_swfilter_packets(&fc->demux, buf, no);
	178	}
	179	EXPORT_SYMBOL(flexcop_pass_dmx_packets);
	180
	181	static void flexcop_reset(struct flexcop_device *fc)
	182	{
1589a993	183	flexcop_ibi_value v210, v204;
2add87a9	184
1589a993	185	/* reset the flexcop itself */
2add87a9 JS	186	fc->write_ibi_reg(fc,ctrl_208,ibi_zero);
	187
	188	v210.raw = 0;
64221be7 PB	189	v210.sw_reset_210.reset_block_000 = 1;
	190	v210.sw_reset_210.reset_block_100 = 1;
	191	v210.sw_reset_210.reset_block_200 = 1;
	192	v210.sw_reset_210.reset_block_300 = 1;
	193	v210.sw_reset_210.reset_block_400 = 1;
	194	v210.sw_reset_210.reset_block_500 = 1;
	195	v210.sw_reset_210.reset_block_600 = 1;
	196	v210.sw_reset_210.reset_block_700 = 1;
2add87a9	197	v210.sw_reset_210.Block_reset_enable = 0xb2;
64221be7	198	v210.sw_reset_210.Special_controls = 0xc259;
2add87a9	199	fc->write_ibi_reg(fc,sw_reset_210,v210);
64221be7	200	msleep(1);
2add87a9	201
1589a993	202	/* reset the periphical devices */
2add87a9 JS	203
	204	v204 = fc->read_ibi_reg(fc,misc_204);
	205	v204.misc_204.Per_reset_sig = 0;
	206	fc->write_ibi_reg(fc,misc_204,v204);
c0b11b91	207	msleep(1);
2add87a9 JS	208	v204.misc_204.Per_reset_sig = 1;
2add87a9 JS	209	fc->write_ibi_reg(fc,misc_204,v204);
2add87a9 JS	210	}
2add87a9 JS	211
64221be7 PB	212	void flexcop_reset_block_300(struct flexcop_device *fc)
64221be7 PB	213	{
1589a993 UB	214	flexcop_ibi_value v208_save = fc->read_ibi_reg(fc, ctrl_208),
1589a993 UB	215	v210 = fc->read_ibi_reg(fc, sw_reset_210);
64221be7	216
1589a993	217	deb_rdump("208: %08x, 210: %08x\n", v208_save.raw, v210.raw);
64221be7 PB	218	fc->write_ibi_reg(fc,ctrl_208,ibi_zero);
	219
	220	v210.sw_reset_210.reset_block_300 = 1;
	221	v210.sw_reset_210.Block_reset_enable = 0xb2;
	222
	223	fc->write_ibi_reg(fc,sw_reset_210,v210);
64221be7 PB	224	fc->write_ibi_reg(fc,ctrl_208,v208_save);
64221be7 PB	225	}
64221be7	226
2add87a9 JS	227	struct flexcop_device *flexcop_device_kmalloc(size_t bus_specific_len)
	228	{
	229	void *bus;
1589a993 UB	230	struct flexcop_device *fc = kzalloc(sizeof(struct flexcop_device),
1589a993 UB	231	GFP_KERNEL);
2add87a9 JS	232	if (!fc) {
	233	err("no memory");
	234	return NULL;
	235	}
2add87a9	236
7408187d	237	bus = kzalloc(bus_specific_len, GFP_KERNEL);
2add87a9 JS	238	if (!bus) {
	239	err("no memory");
	240	kfree(fc);
	241	return NULL;
	242	}
2add87a9 JS	243
	244	fc->bus_specific = bus;
	245
	246	return fc;
	247	}
	248	EXPORT_SYMBOL(flexcop_device_kmalloc);
	249
	250	void flexcop_device_kfree(struct flexcop_device *fc)
	251	{
	252	kfree(fc->bus_specific);
	253	kfree(fc);
	254	}
	255	EXPORT_SYMBOL(flexcop_device_kfree);
	256
	257	int flexcop_device_initialize(struct flexcop_device *fc)
	258	{
	259	int ret;
	260	ibi_zero.raw = 0;
	261
	262	flexcop_reset(fc);
	263	flexcop_determine_revision(fc);
	264	flexcop_sram_init(fc);
	265	flexcop_hw_filter_init(fc);
2add87a9 JS	266	flexcop_smc_ctrl(fc, 0);
2add87a9 JS	267
efd279ec JN	268	ret = flexcop_dvb_init(fc);
efd279ec JN	269	if (ret)
77824131 JS	270	goto error;
77824131 JS	271
6394cf53 PB	272	/* i2c has to be done before doing EEProm stuff -
	273	* because the EEProm is accessed via i2c */
	274	ret = flexcop_i2c_init(fc);
	275	if (ret)
	276	goto error;
	277
77824131	278	/* do the MAC address reading after initializing the dvb_adapter */
2add87a9	279	if (fc->get_mac_addr(fc, 0) == 0) {
77824131	280	u8 *b = fc->dvb_adapter.proposed_mac;
7c510e4b	281	info("MAC address = %pM", b);
77824131	282	flexcop_set_mac_filter(fc,b);
2add87a9 JS	283	flexcop_mac_filter_ctrl(fc,1);
	284	} else
	285	warn("reading of MAC address failed.\n");
	286
efd279ec JN	287	ret = flexcop_frontend_init(fc);
efd279ec JN	288	if (ret)
2add87a9 JS	289	goto error;
	290
	291	flexcop_device_name(fc,"initialization of","complete");
8397703e TP	292	return 0;
8397703e TP	293
2add87a9 JS	294	error:
2add87a9 JS	295	flexcop_device_exit(fc);
2add87a9 JS	296	return ret;
	297	}
	298	EXPORT_SYMBOL(flexcop_device_initialize);
	299
	300	void flexcop_device_exit(struct flexcop_device *fc)
	301	{
	302	flexcop_frontend_exit(fc);
	303	flexcop_i2c_exit(fc);
	304	flexcop_dvb_exit(fc);
	305	}
	306	EXPORT_SYMBOL(flexcop_device_exit);
	307
	308	static int flexcop_module_init(void)
	309	{
	310	info(DRIVER_NAME " loaded successfully");
	311	return 0;
	312	}
	313
	314	static void flexcop_module_cleanup(void)
	315	{
	316	info(DRIVER_NAME " unloaded successfully");
	317	}
	318
	319	module_init(flexcop_module_init);
	320	module_exit(flexcop_module_cleanup);
	321
	322	MODULE_AUTHOR(DRIVER_AUTHOR);
	323	MODULE_DESCRIPTION(DRIVER_NAME);
	324	MODULE_LICENSE("GPL");