Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 28a59df4d7cb8f749ba92ad304df4063ccf108fd

Authored by Mauro Carvalho Chehab 2013-03-21 20:27:37 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

[media] siano: remove the remaining CamelCase compliants

Remove the remaining CamelCase checkpatch.pl compliants.
There are still a few left, but those are due to USB and
DVB APIs.

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Showing 8 changed files with 253 additions and 253 deletions Inline Diff

drivers/media/common/siano/sms-cards.c
drivers/media/common/siano/smscoreapi.c
drivers/media/common/siano/smscoreapi.h
drivers/media/common/siano/smsdvb-debugfs.c
drivers/media/common/siano/smsdvb-main.c
drivers/media/common/siano/smsdvb.h
drivers/media/common/siano/smsendian.c
drivers/media/usb/siano/smsusb.c

drivers/media/common/siano/sms-cards.c

Diff comments View file @ 28a59df

drivers/media/common/siano/smscoreapi.c

Diff comments View file @ 28a59df

drivers/media/common/siano/smscoreapi.h

Diff comments View file @ 28a59df

drivers/media/common/siano/smsdvb-debugfs.c

Diff comments View file @ 28a59df

drivers/media/common/siano/smsdvb-main.c

Diff comments View file @ 28a59df

1	/****************************************************************	1	/****************************************************************
2		2
3	Siano Mobile Silicon, Inc.	3	Siano Mobile Silicon, Inc.
4	MDTV receiver kernel modules.	4	MDTV receiver kernel modules.
5	Copyright (C) 2006-2008, Uri Shkolnik	5	Copyright (C) 2006-2008, Uri Shkolnik
6		6
7	This program is free software: you can redistribute it and/or modify	7	This program is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation, either version 2 of the License, or	9	the Free Software Foundation, either version 2 of the License, or
10	(at your option) any later version.	10	(at your option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	15	GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>.	18	along with this program. If not, see <http://www.gnu.org/licenses/>.
19		19
20	****************************************************************/	20	****************************************************************/
21		21
22	#include <linux/module.h>	22	#include <linux/module.h>
23	#include <linux/slab.h>	23	#include <linux/slab.h>
24	#include <linux/init.h>	24	#include <linux/init.h>
25		25
26	#include "dmxdev.h"	26	#include "dmxdev.h"
27	#include "dvbdev.h"	27	#include "dvbdev.h"
28	#include "dvb_demux.h"	28	#include "dvb_demux.h"
29	#include "dvb_frontend.h"	29	#include "dvb_frontend.h"
30		30
31	#include "smscoreapi.h"	31	#include "smscoreapi.h"
32	#include "sms-cards.h"	32	#include "sms-cards.h"
33		33
34	#include "smsdvb.h"	34	#include "smsdvb.h"
35		35
36	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);	36	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
37		37
38	static struct list_head g_smsdvb_clients;	38	static struct list_head g_smsdvb_clients;
39	static struct mutex g_smsdvb_clientslock;	39	static struct mutex g_smsdvb_clientslock;
40		40
41	static int sms_dbg;	41	static int sms_dbg;
42	module_param_named(debug, sms_dbg, int, 0644);	42	module_param_named(debug, sms_dbg, int, 0644);
43	MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");	43	MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
44		44
45		45
46	u32 sms_to_guard_interval_table[] = {	46	u32 sms_to_guard_interval_table[] = {
47	[0] = GUARD_INTERVAL_1_32,	47	[0] = GUARD_INTERVAL_1_32,
48	[1] = GUARD_INTERVAL_1_16,	48	[1] = GUARD_INTERVAL_1_16,
49	[2] = GUARD_INTERVAL_1_8,	49	[2] = GUARD_INTERVAL_1_8,
50	[3] = GUARD_INTERVAL_1_4,	50	[3] = GUARD_INTERVAL_1_4,
51	};	51	};
52		52
53	u32 sms_to_code_rate_table[] = {	53	u32 sms_to_code_rate_table[] = {
54	[0] = FEC_1_2,	54	[0] = FEC_1_2,
55	[1] = FEC_2_3,	55	[1] = FEC_2_3,
56	[2] = FEC_3_4,	56	[2] = FEC_3_4,
57	[3] = FEC_5_6,	57	[3] = FEC_5_6,
58	[4] = FEC_7_8,	58	[4] = FEC_7_8,
59	};	59	};
60		60
61		61
62	u32 sms_to_hierarchy_table[] = {	62	u32 sms_to_hierarchy_table[] = {
63	[0] = HIERARCHY_NONE,	63	[0] = HIERARCHY_NONE,
64	[1] = HIERARCHY_1,	64	[1] = HIERARCHY_1,
65	[2] = HIERARCHY_2,	65	[2] = HIERARCHY_2,
66	[3] = HIERARCHY_4,	66	[3] = HIERARCHY_4,
67	};	67	};
68		68
69	u32 sms_to_modulation_table[] = {	69	u32 sms_to_modulation_table[] = {
70	[0] = QPSK,	70	[0] = QPSK,
71	[1] = QAM_16,	71	[1] = QAM_16,
72	[2] = QAM_64,	72	[2] = QAM_64,
73	[3] = DQPSK,	73	[3] = DQPSK,
74	};	74	};
75		75
76		76
77	/* Events that may come from DVB v3 adapter */	77	/* Events that may come from DVB v3 adapter */
78	static void sms_board_dvb3_event(struct smsdvb_client_t *client,	78	static void sms_board_dvb3_event(struct smsdvb_client_t *client,
79	enum SMS_DVB3_EVENTS event) {	79	enum SMS_DVB3_EVENTS event) {
80		80
81	struct smscore_device_t *coredev = client->coredev;	81	struct smscore_device_t *coredev = client->coredev;
82	switch (event) {	82	switch (event) {
83	case DVB3_EVENT_INIT:	83	case DVB3_EVENT_INIT:
84	sms_debug("DVB3_EVENT_INIT");	84	sms_debug("DVB3_EVENT_INIT");
85	sms_board_event(coredev, BOARD_EVENT_BIND);	85	sms_board_event(coredev, BOARD_EVENT_BIND);
86	break;	86	break;
87	case DVB3_EVENT_SLEEP:	87	case DVB3_EVENT_SLEEP:
88	sms_debug("DVB3_EVENT_SLEEP");	88	sms_debug("DVB3_EVENT_SLEEP");
89	sms_board_event(coredev, BOARD_EVENT_POWER_SUSPEND);	89	sms_board_event(coredev, BOARD_EVENT_POWER_SUSPEND);
90	break;	90	break;
91	case DVB3_EVENT_HOTPLUG:	91	case DVB3_EVENT_HOTPLUG:
92	sms_debug("DVB3_EVENT_HOTPLUG");	92	sms_debug("DVB3_EVENT_HOTPLUG");
93	sms_board_event(coredev, BOARD_EVENT_POWER_INIT);	93	sms_board_event(coredev, BOARD_EVENT_POWER_INIT);
94	break;	94	break;
95	case DVB3_EVENT_FE_LOCK:	95	case DVB3_EVENT_FE_LOCK:
96	if (client->event_fe_state != DVB3_EVENT_FE_LOCK) {	96	if (client->event_fe_state != DVB3_EVENT_FE_LOCK) {
97	client->event_fe_state = DVB3_EVENT_FE_LOCK;	97	client->event_fe_state = DVB3_EVENT_FE_LOCK;
98	sms_debug("DVB3_EVENT_FE_LOCK");	98	sms_debug("DVB3_EVENT_FE_LOCK");
99	sms_board_event(coredev, BOARD_EVENT_FE_LOCK);	99	sms_board_event(coredev, BOARD_EVENT_FE_LOCK);
100	}	100	}
101	break;	101	break;
102	case DVB3_EVENT_FE_UNLOCK:	102	case DVB3_EVENT_FE_UNLOCK:
103	if (client->event_fe_state != DVB3_EVENT_FE_UNLOCK) {	103	if (client->event_fe_state != DVB3_EVENT_FE_UNLOCK) {
104	client->event_fe_state = DVB3_EVENT_FE_UNLOCK;	104	client->event_fe_state = DVB3_EVENT_FE_UNLOCK;
105	sms_debug("DVB3_EVENT_FE_UNLOCK");	105	sms_debug("DVB3_EVENT_FE_UNLOCK");
106	sms_board_event(coredev, BOARD_EVENT_FE_UNLOCK);	106	sms_board_event(coredev, BOARD_EVENT_FE_UNLOCK);
107	}	107	}
108	break;	108	break;
109	case DVB3_EVENT_UNC_OK:	109	case DVB3_EVENT_UNC_OK:
110	if (client->event_unc_state != DVB3_EVENT_UNC_OK) {	110	if (client->event_unc_state != DVB3_EVENT_UNC_OK) {
111	client->event_unc_state = DVB3_EVENT_UNC_OK;	111	client->event_unc_state = DVB3_EVENT_UNC_OK;
112	sms_debug("DVB3_EVENT_UNC_OK");	112	sms_debug("DVB3_EVENT_UNC_OK");
113	sms_board_event(coredev, BOARD_EVENT_MULTIPLEX_OK);	113	sms_board_event(coredev, BOARD_EVENT_MULTIPLEX_OK);
114	}	114	}
115	break;	115	break;
116	case DVB3_EVENT_UNC_ERR:	116	case DVB3_EVENT_UNC_ERR:
117	if (client->event_unc_state != DVB3_EVENT_UNC_ERR) {	117	if (client->event_unc_state != DVB3_EVENT_UNC_ERR) {
118	client->event_unc_state = DVB3_EVENT_UNC_ERR;	118	client->event_unc_state = DVB3_EVENT_UNC_ERR;
119	sms_debug("DVB3_EVENT_UNC_ERR");	119	sms_debug("DVB3_EVENT_UNC_ERR");
120	sms_board_event(coredev, BOARD_EVENT_MULTIPLEX_ERRORS);	120	sms_board_event(coredev, BOARD_EVENT_MULTIPLEX_ERRORS);
121	}	121	}
122	break;	122	break;
123		123
124	default:	124	default:
125	sms_err("Unknown dvb3 api event");	125	sms_err("Unknown dvb3 api event");
126	break;	126	break;
127	}	127	}
128	}	128	}
129		129
130	static void smsdvb_stats_not_ready(struct dvb_frontend *fe)	130	static void smsdvb_stats_not_ready(struct dvb_frontend *fe)
131	{	131	{
132	struct smsdvb_client_t *client =	132	struct smsdvb_client_t *client =
133	container_of(fe, struct smsdvb_client_t, frontend);	133	container_of(fe, struct smsdvb_client_t, frontend);
134	struct smscore_device_t *coredev = client->coredev;	134	struct smscore_device_t *coredev = client->coredev;
135	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	135	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
136	int i, n_layers;	136	int i, n_layers;
137		137
138	switch (smscore_get_device_mode(coredev)) {	138	switch (smscore_get_device_mode(coredev)) {
139	case DEVICE_MODE_ISDBT:	139	case DEVICE_MODE_ISDBT:
140	case DEVICE_MODE_ISDBT_BDA:	140	case DEVICE_MODE_ISDBT_BDA:
141	n_layers = 4;	141	n_layers = 4;
142	default:	142	default:
143	n_layers = 1;	143	n_layers = 1;
144	}	144	}
145		145
146	/* Global stats */	146	/* Global stats */
147	c->strength.len = 1;	147	c->strength.len = 1;
148	c->cnr.len = 1;	148	c->cnr.len = 1;
149	c->strength.stat[0].scale = FE_SCALE_DECIBEL;	149	c->strength.stat[0].scale = FE_SCALE_DECIBEL;
150	c->cnr.stat[0].scale = FE_SCALE_DECIBEL;	150	c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
151		151
152	/* Per-layer stats */	152	/* Per-layer stats */
153	c->post_bit_error.len = n_layers;	153	c->post_bit_error.len = n_layers;
154	c->post_bit_count.len = n_layers;	154	c->post_bit_count.len = n_layers;
155	c->block_error.len = n_layers;	155	c->block_error.len = n_layers;
156	c->block_count.len = n_layers;	156	c->block_count.len = n_layers;
157		157
158	/*	158	/*
159	* Put all of them at FE_SCALE_NOT_AVAILABLE. They're dynamically	159	* Put all of them at FE_SCALE_NOT_AVAILABLE. They're dynamically
160	* changed when the stats become available.	160	* changed when the stats become available.
161	*/	161	*/
162	for (i = 0; i < n_layers; i++) {	162	for (i = 0; i < n_layers; i++) {
163	c->post_bit_error.stat[i].scale = FE_SCALE_NOT_AVAILABLE;	163	c->post_bit_error.stat[i].scale = FE_SCALE_NOT_AVAILABLE;
164	c->post_bit_count.stat[i].scale = FE_SCALE_NOT_AVAILABLE;	164	c->post_bit_count.stat[i].scale = FE_SCALE_NOT_AVAILABLE;
165	c->block_error.stat[i].scale = FE_SCALE_NOT_AVAILABLE;	165	c->block_error.stat[i].scale = FE_SCALE_NOT_AVAILABLE;
166	c->block_count.stat[i].scale = FE_SCALE_NOT_AVAILABLE;	166	c->block_count.stat[i].scale = FE_SCALE_NOT_AVAILABLE;
167	}	167	}
168	}	168	}
169		169
170	static inline int sms_to_mode(u32 mode)	170	static inline int sms_to_mode(u32 mode)
171	{	171	{
172	switch (mode) {	172	switch (mode) {
173	case 2:	173	case 2:
174	return TRANSMISSION_MODE_2K;	174	return TRANSMISSION_MODE_2K;
175	case 4:	175	case 4:
176	return TRANSMISSION_MODE_4K;	176	return TRANSMISSION_MODE_4K;
177	case 8:	177	case 8:
178	return TRANSMISSION_MODE_8K;	178	return TRANSMISSION_MODE_8K;
179	}	179	}
180	return TRANSMISSION_MODE_AUTO;	180	return TRANSMISSION_MODE_AUTO;
181	}	181	}
182		182
183	static inline int sms_to_status(u32 is_demod_locked, u32 is_rf_locked)	183	static inline int sms_to_status(u32 is_demod_locked, u32 is_rf_locked)
184	{	184	{
185	if (is_demod_locked)	185	if (is_demod_locked)
186	return FE_HAS_SIGNAL \| FE_HAS_CARRIER \| FE_HAS_VITERBI \|	186	return FE_HAS_SIGNAL \| FE_HAS_CARRIER \| FE_HAS_VITERBI \|
187	FE_HAS_SYNC \| FE_HAS_LOCK;	187	FE_HAS_SYNC \| FE_HAS_LOCK;
188		188
189	if (is_rf_locked)	189	if (is_rf_locked)
190	return FE_HAS_SIGNAL \| FE_HAS_CARRIER;	190	return FE_HAS_SIGNAL \| FE_HAS_CARRIER;
191		191
192	return 0;	192	return 0;
193	}	193	}
194		194
195	static inline u32 sms_to_bw(u32 value)	195	static inline u32 sms_to_bw(u32 value)
196	{	196	{
197	return value * 1000000;	197	return value * 1000000;
198	}	198	}
199		199
200	#define convert_from_table(value, table, defval) ({ \	200	#define convert_from_table(value, table, defval) ({ \
201	u32 __ret; \	201	u32 __ret; \
202	if (value < ARRAY_SIZE(table)) \	202	if (value < ARRAY_SIZE(table)) \
203	__ret = table[value]; \	203	__ret = table[value]; \
204	else \	204	else \
205	__ret = defval; \	205	__ret = defval; \
206	__ret; \	206	__ret; \
207	})	207	})
208		208
209	#define sms_to_guard_interval(value) \	209	#define sms_to_guard_interval(value) \
210	convert_from_table(value, sms_to_guard_interval_table, \	210	convert_from_table(value, sms_to_guard_interval_table, \
211	GUARD_INTERVAL_AUTO);	211	GUARD_INTERVAL_AUTO);
212		212
213	#define sms_to_code_rate(value) \	213	#define sms_to_code_rate(value) \
214	convert_from_table(value, sms_to_code_rate_table, \	214	convert_from_table(value, sms_to_code_rate_table, \
215	FEC_NONE);	215	FEC_NONE);
216		216
217	#define sms_to_hierarchy(value) \	217	#define sms_to_hierarchy(value) \
218	convert_from_table(value, sms_to_hierarchy_table, \	218	convert_from_table(value, sms_to_hierarchy_table, \
219	FEC_NONE);	219	FEC_NONE);
220		220
221	#define sms_to_modulation(value) \	221	#define sms_to_modulation(value) \
222	convert_from_table(value, sms_to_modulation_table, \	222	convert_from_table(value, sms_to_modulation_table, \
223	FEC_NONE);	223	FEC_NONE);
224		224
225	static void smsdvb_update_tx_params(struct smsdvb_client_t *client,	225	static void smsdvb_update_tx_params(struct smsdvb_client_t *client,
226	struct sms_tx_stats *p)	226	struct sms_tx_stats *p)
227	{	227	{
228	struct dvb_frontend *fe = &client->frontend;	228	struct dvb_frontend *fe = &client->frontend;
229	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	229	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
230		230
231	c->frequency = p->frequency;	231	c->frequency = p->frequency;
232	client->fe_status = sms_to_status(p->is_demod_locked, 0);	232	client->fe_status = sms_to_status(p->is_demod_locked, 0);
233	c->bandwidth_hz = sms_to_bw(p->bandwidth);	233	c->bandwidth_hz = sms_to_bw(p->bandwidth);
234	c->transmission_mode = sms_to_mode(p->transmission_mode);	234	c->transmission_mode = sms_to_mode(p->transmission_mode);
235	c->guard_interval = sms_to_guard_interval(p->guard_interval);	235	c->guard_interval = sms_to_guard_interval(p->guard_interval);
236	c->code_rate_HP = sms_to_code_rate(p->code_rate);	236	c->code_rate_HP = sms_to_code_rate(p->code_rate);
237	c->code_rate_LP = sms_to_code_rate(p->lp_code_rate);	237	c->code_rate_LP = sms_to_code_rate(p->lp_code_rate);
238	c->hierarchy = sms_to_hierarchy(p->hierarchy);	238	c->hierarchy = sms_to_hierarchy(p->hierarchy);
239	c->modulation = sms_to_modulation(p->constellation);	239	c->modulation = sms_to_modulation(p->constellation);
240	}	240	}
241		241
242	static void smsdvb_update_per_slices(struct smsdvb_client_t *client,	242	static void smsdvb_update_per_slices(struct smsdvb_client_t *client,
243	struct RECEPTION_STATISTICS_PER_SLICES_S *p)	243	struct RECEPTION_STATISTICS_PER_SLICES_S *p)
244	{	244	{
245	struct dvb_frontend *fe = &client->frontend;	245	struct dvb_frontend *fe = &client->frontend;
246	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	246	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
247		247
248	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);	248	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);
249	c->modulation = sms_to_modulation(p->constellation);	249	c->modulation = sms_to_modulation(p->constellation);
250		250
251	/* signal Strength, in DBm */	251	/* signal Strength, in DBm */
252	c->strength.stat[0].uvalue = p->in_band_power * 1000;	252	c->strength.stat[0].uvalue = p->in_band_power * 1000;
253		253
254	/* Carrier to noise ratio, in DB */	254	/* Carrier to noise ratio, in DB */
255	c->cnr.stat[0].svalue = p->snr * 1000;	255	c->cnr.stat[0].svalue = p->snr * 1000;
256		256
257	/* PER/BER requires demod lock */	257	/* PER/BER requires demod lock */
258	if (!p->is_demod_locked)	258	if (!p->is_demod_locked)
259	return;	259	return;
260		260
261	/* TS PER */	261	/* TS PER */
262	client->last_per = c->block_error.stat[0].uvalue;	262	client->last_per = c->block_error.stat[0].uvalue;
263	c->block_error.stat[0].scale = FE_SCALE_COUNTER;	263	c->block_error.stat[0].scale = FE_SCALE_COUNTER;
264	c->block_count.stat[0].scale = FE_SCALE_COUNTER;	264	c->block_count.stat[0].scale = FE_SCALE_COUNTER;
265	c->block_error.stat[0].uvalue += p->ets_packets;	265	c->block_error.stat[0].uvalue += p->ets_packets;
266	c->block_count.stat[0].uvalue += p->ets_packets + p->ts_packets;	266	c->block_count.stat[0].uvalue += p->ets_packets + p->ts_packets;
267		267
268	/* BER */	268	/* ber */
269	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;	269	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
270	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;	270	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
271	c->post_bit_error.stat[0].uvalue += p->ber_error_count;	271	c->post_bit_error.stat[0].uvalue += p->ber_error_count;
272	c->post_bit_count.stat[0].uvalue += p->ber_bit_count;	272	c->post_bit_count.stat[0].uvalue += p->ber_bit_count;
273		273
274	/* Legacy PER/BER */	274	/* Legacy PER/BER */
275	client->legacy_per = (p->ets_packets * 65535) /	275	client->legacy_per = (p->ets_packets * 65535) /
276	(p->ts_packets + p->ets_packets);	276	(p->ts_packets + p->ets_packets);
277	}	277	}
278		278
279	static void smsdvb_update_dvb_stats(struct smsdvb_client_t *client,	279	static void smsdvb_update_dvb_stats(struct smsdvb_client_t *client,
280	struct sms_stats *p)	280	struct sms_stats *p)
281	{	281	{
282	struct dvb_frontend *fe = &client->frontend;	282	struct dvb_frontend *fe = &client->frontend;
283	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	283	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
284		284
285	if (client->prt_dvb_stats)	285	if (client->prt_dvb_stats)
286	client->prt_dvb_stats(client->debug_data, p);	286	client->prt_dvb_stats(client->debug_data, p);
287		287
288	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);	288	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);
289		289
290	/* Update DVB modulation parameters */	290	/* Update DVB modulation parameters */
291	c->frequency = p->frequency;	291	c->frequency = p->frequency;
292	client->fe_status = sms_to_status(p->is_demod_locked, 0);	292	client->fe_status = sms_to_status(p->is_demod_locked, 0);
293	c->bandwidth_hz = sms_to_bw(p->bandwidth);	293	c->bandwidth_hz = sms_to_bw(p->bandwidth);
294	c->transmission_mode = sms_to_mode(p->transmission_mode);	294	c->transmission_mode = sms_to_mode(p->transmission_mode);
295	c->guard_interval = sms_to_guard_interval(p->guard_interval);	295	c->guard_interval = sms_to_guard_interval(p->guard_interval);
296	c->code_rate_HP = sms_to_code_rate(p->code_rate);	296	c->code_rate_HP = sms_to_code_rate(p->code_rate);
297	c->code_rate_LP = sms_to_code_rate(p->lp_code_rate);	297	c->code_rate_LP = sms_to_code_rate(p->lp_code_rate);
298	c->hierarchy = sms_to_hierarchy(p->hierarchy);	298	c->hierarchy = sms_to_hierarchy(p->hierarchy);
299	c->modulation = sms_to_modulation(p->constellation);	299	c->modulation = sms_to_modulation(p->constellation);
300		300
301	/* update reception data */	301	/* update reception data */
302	c->lna = p->is_external_lna_on ? 1 : 0;	302	c->lna = p->is_external_lna_on ? 1 : 0;
303		303
304	/* Carrier to noise ratio, in DB */	304	/* Carrier to noise ratio, in DB */
305	c->cnr.stat[0].svalue = p->SNR * 1000;	305	c->cnr.stat[0].svalue = p->SNR * 1000;
306		306
307	/* signal Strength, in DBm */	307	/* signal Strength, in DBm */
308	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;	308	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;
309		309
310	/* PER/BER requires demod lock */	310	/* PER/BER requires demod lock */
311	if (!p->is_demod_locked)	311	if (!p->is_demod_locked)
312	return;	312	return;
313		313
314	/* TS PER */	314	/* TS PER */
315	client->last_per = c->block_error.stat[0].uvalue;	315	client->last_per = c->block_error.stat[0].uvalue;
316	c->block_error.stat[0].scale = FE_SCALE_COUNTER;	316	c->block_error.stat[0].scale = FE_SCALE_COUNTER;
317	c->block_count.stat[0].scale = FE_SCALE_COUNTER;	317	c->block_count.stat[0].scale = FE_SCALE_COUNTER;
318	c->block_error.stat[0].uvalue += p->error_ts_packets;	318	c->block_error.stat[0].uvalue += p->error_ts_packets;
319	c->block_count.stat[0].uvalue += p->total_ts_packets;	319	c->block_count.stat[0].uvalue += p->total_ts_packets;
320		320
321	/* BER */	321	/* ber */
322	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;	322	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
323	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;	323	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
324	c->post_bit_error.stat[0].uvalue += p->ber_error_count;	324	c->post_bit_error.stat[0].uvalue += p->ber_error_count;
325	c->post_bit_count.stat[0].uvalue += p->ber_bit_count;	325	c->post_bit_count.stat[0].uvalue += p->ber_bit_count;
326		326
327	/* Legacy PER/BER */	327	/* Legacy PER/BER */
328	client->legacy_ber = p->BER;	328	client->legacy_ber = p->ber;
329	};	329	};
330		330
331	static void smsdvb_update_isdbt_stats(struct smsdvb_client_t *client,	331	static void smsdvb_update_isdbt_stats(struct smsdvb_client_t *client,
332	struct sms_isdbt_stats *p)	332	struct sms_isdbt_stats *p)
333	{	333	{
334	struct dvb_frontend *fe = &client->frontend;	334	struct dvb_frontend *fe = &client->frontend;
335	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	335	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
336	struct sms_isdbt_layer_stats *lr;	336	struct sms_isdbt_layer_stats *lr;
337	int i, n_layers;	337	int i, n_layers;
338		338
339	if (client->prt_isdb_stats)	339	if (client->prt_isdb_stats)
340	client->prt_isdb_stats(client->debug_data, p);	340	client->prt_isdb_stats(client->debug_data, p);
341		341
342	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);	342	client->fe_status = sms_to_status(p->is_demod_locked, p->is_rf_locked);
343		343
344	/*	344	/*
345	* Firmware 2.1 seems to report only lock status and	345	* Firmware 2.1 seems to report only lock status and
346	* signal strength. The signal strength indicator is at the	346	* signal strength. The signal strength indicator is at the
347	* wrong field.	347	* wrong field.
348	*/	348	*/
349	if (p->statistics_type == 0) {	349	if (p->statistics_type == 0) {
350	c->strength.stat[0].uvalue = ((s32)p->transmission_mode) * 1000;	350	c->strength.stat[0].uvalue = ((s32)p->transmission_mode) * 1000;
351	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;	351	c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
352	return;	352	return;
353	}	353	}
354		354
355	/* Update ISDB-T transmission parameters */	355	/* Update ISDB-T transmission parameters */
356	c->frequency = p->frequency;	356	c->frequency = p->frequency;
357	c->bandwidth_hz = sms_to_bw(p->bandwidth);	357	c->bandwidth_hz = sms_to_bw(p->bandwidth);
358	c->transmission_mode = sms_to_mode(p->transmission_mode);	358	c->transmission_mode = sms_to_mode(p->transmission_mode);
359	c->guard_interval = sms_to_guard_interval(p->guard_interval);	359	c->guard_interval = sms_to_guard_interval(p->guard_interval);
360	c->isdbt_partial_reception = p->partial_reception ? 1 : 0;	360	c->isdbt_partial_reception = p->partial_reception ? 1 : 0;
361	n_layers = p->num_of_layers;	361	n_layers = p->num_of_layers;
362	if (n_layers < 1)	362	if (n_layers < 1)
363	n_layers = 1;	363	n_layers = 1;
364	if (n_layers > 3)	364	if (n_layers > 3)
365	n_layers = 3;	365	n_layers = 3;
366	c->isdbt_layer_enabled = 0;	366	c->isdbt_layer_enabled = 0;
367		367
368	/* update reception data */	368	/* update reception data */
369	c->lna = p->is_external_lna_on ? 1 : 0;	369	c->lna = p->is_external_lna_on ? 1 : 0;
370		370
371	/* Carrier to noise ratio, in DB */	371	/* Carrier to noise ratio, in DB */
372	c->cnr.stat[0].svalue = p->SNR * 1000;	372	c->cnr.stat[0].svalue = p->SNR * 1000;
373		373
374	/* signal Strength, in DBm */	374	/* signal Strength, in DBm */
375	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;	375	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;
376		376
377	/* PER/BER and per-layer stats require demod lock */	377	/* PER/BER and per-layer stats require demod lock */
378	if (!p->is_demod_locked)	378	if (!p->is_demod_locked)
379	return;	379	return;
380		380
381	client->last_per = c->block_error.stat[0].uvalue;	381	client->last_per = c->block_error.stat[0].uvalue;
382		382
383	/* Clears global counters, as the code below will sum it again */	383	/* Clears global counters, as the code below will sum it again */
384	c->block_error.stat[0].uvalue = 0;	384	c->block_error.stat[0].uvalue = 0;
385	c->block_count.stat[0].uvalue = 0;	385	c->block_count.stat[0].uvalue = 0;
386	c->block_error.stat[0].scale = FE_SCALE_COUNTER;	386	c->block_error.stat[0].scale = FE_SCALE_COUNTER;
387	c->block_count.stat[0].scale = FE_SCALE_COUNTER;	387	c->block_count.stat[0].scale = FE_SCALE_COUNTER;
388	c->post_bit_error.stat[0].uvalue = 0;	388	c->post_bit_error.stat[0].uvalue = 0;
389	c->post_bit_count.stat[0].uvalue = 0;	389	c->post_bit_count.stat[0].uvalue = 0;
390	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;	390	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
391	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;	391	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
392		392
393	for (i = 0; i < n_layers; i++) {	393	for (i = 0; i < n_layers; i++) {
394	lr = &p->LayerInfo[i];	394	lr = &p->layer_info[i];
395		395
396	/* Update per-layer transmission parameters */	396	/* Update per-layer transmission parameters */
397	if (lr->number_of_segments > 0 && lr->number_of_segments < 13) {	397	if (lr->number_of_segments > 0 && lr->number_of_segments < 13) {
398	c->isdbt_layer_enabled \|= 1 << i;	398	c->isdbt_layer_enabled \|= 1 << i;
399	c->layer[i].segment_count = lr->number_of_segments;	399	c->layer[i].segment_count = lr->number_of_segments;
400	} else {	400	} else {
401	continue;	401	continue;
402	}	402	}
403	c->layer[i].modulation = sms_to_modulation(lr->constellation);	403	c->layer[i].modulation = sms_to_modulation(lr->constellation);
404		404
405	/* TS PER */	405	/* TS PER */
406	c->block_error.stat[i + 1].scale = FE_SCALE_COUNTER;	406	c->block_error.stat[i + 1].scale = FE_SCALE_COUNTER;
407	c->block_count.stat[i + 1].scale = FE_SCALE_COUNTER;	407	c->block_count.stat[i + 1].scale = FE_SCALE_COUNTER;
408	c->block_error.stat[i + 1].uvalue += lr->error_ts_packets;	408	c->block_error.stat[i + 1].uvalue += lr->error_ts_packets;
409	c->block_count.stat[i + 1].uvalue += lr->total_ts_packets;	409	c->block_count.stat[i + 1].uvalue += lr->total_ts_packets;
410		410
411	/* Update global PER counter */	411	/* Update global PER counter */
412	c->block_error.stat[0].uvalue += lr->error_ts_packets;	412	c->block_error.stat[0].uvalue += lr->error_ts_packets;
413	c->block_count.stat[0].uvalue += lr->total_ts_packets;	413	c->block_count.stat[0].uvalue += lr->total_ts_packets;
414		414
415	/* BER */	415	/* BER */
416	c->post_bit_error.stat[i + 1].scale = FE_SCALE_COUNTER;	416	c->post_bit_error.stat[i + 1].scale = FE_SCALE_COUNTER;
417	c->post_bit_count.stat[i + 1].scale = FE_SCALE_COUNTER;	417	c->post_bit_count.stat[i + 1].scale = FE_SCALE_COUNTER;
418	c->post_bit_error.stat[i + 1].uvalue += lr->ber_error_count;	418	c->post_bit_error.stat[i + 1].uvalue += lr->ber_error_count;
419	c->post_bit_count.stat[i + 1].uvalue += lr->ber_bit_count;	419	c->post_bit_count.stat[i + 1].uvalue += lr->ber_bit_count;
420		420
421	/* Update global BER counter */	421	/* Update global BER counter */
422	c->post_bit_error.stat[0].uvalue += lr->ber_error_count;	422	c->post_bit_error.stat[0].uvalue += lr->ber_error_count;
423	c->post_bit_count.stat[0].uvalue += lr->ber_bit_count;	423	c->post_bit_count.stat[0].uvalue += lr->ber_bit_count;
424	}	424	}
425	}	425	}
426		426
427	static void smsdvb_update_isdbt_stats_ex(struct smsdvb_client_t *client,	427	static void smsdvb_update_isdbt_stats_ex(struct smsdvb_client_t *client,
428	struct sms_isdbt_stats_ex *p)	428	struct sms_isdbt_stats_ex *p)
429	{	429	{
430	struct dvb_frontend *fe = &client->frontend;	430	struct dvb_frontend *fe = &client->frontend;
431	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	431	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
432	struct sms_isdbt_layer_stats *lr;	432	struct sms_isdbt_layer_stats *lr;
433	int i, n_layers;	433	int i, n_layers;
434		434
435	if (client->prt_isdb_stats_ex)	435	if (client->prt_isdb_stats_ex)
436	client->prt_isdb_stats_ex(client->debug_data, p);	436	client->prt_isdb_stats_ex(client->debug_data, p);
437		437
438	/* Update ISDB-T transmission parameters */	438	/* Update ISDB-T transmission parameters */
439	c->frequency = p->frequency;	439	c->frequency = p->frequency;
440	client->fe_status = sms_to_status(p->is_demod_locked, 0);	440	client->fe_status = sms_to_status(p->is_demod_locked, 0);
441	c->bandwidth_hz = sms_to_bw(p->bandwidth);	441	c->bandwidth_hz = sms_to_bw(p->bandwidth);
442	c->transmission_mode = sms_to_mode(p->transmission_mode);	442	c->transmission_mode = sms_to_mode(p->transmission_mode);
443	c->guard_interval = sms_to_guard_interval(p->guard_interval);	443	c->guard_interval = sms_to_guard_interval(p->guard_interval);
444	c->isdbt_partial_reception = p->partial_reception ? 1 : 0;	444	c->isdbt_partial_reception = p->partial_reception ? 1 : 0;
445	n_layers = p->num_of_layers;	445	n_layers = p->num_of_layers;
446	if (n_layers < 1)	446	if (n_layers < 1)
447	n_layers = 1;	447	n_layers = 1;
448	if (n_layers > 3)	448	if (n_layers > 3)
449	n_layers = 3;	449	n_layers = 3;
450	c->isdbt_layer_enabled = 0;	450	c->isdbt_layer_enabled = 0;
451		451
452	/* update reception data */	452	/* update reception data */
453	c->lna = p->is_external_lna_on ? 1 : 0;	453	c->lna = p->is_external_lna_on ? 1 : 0;
454		454
455	/* Carrier to noise ratio, in DB */	455	/* Carrier to noise ratio, in DB */
456	c->cnr.stat[0].svalue = p->SNR * 1000;	456	c->cnr.stat[0].svalue = p->SNR * 1000;
457		457
458	/* signal Strength, in DBm */	458	/* signal Strength, in DBm */
459	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;	459	c->strength.stat[0].uvalue = p->in_band_pwr * 1000;
460		460
461	/* PER/BER and per-layer stats require demod lock */	461	/* PER/BER and per-layer stats require demod lock */
462	if (!p->is_demod_locked)	462	if (!p->is_demod_locked)
463	return;	463	return;
464		464
465	client->last_per = c->block_error.stat[0].uvalue;	465	client->last_per = c->block_error.stat[0].uvalue;
466		466
467	/* Clears global counters, as the code below will sum it again */	467	/* Clears global counters, as the code below will sum it again */
468	c->block_error.stat[0].uvalue = 0;	468	c->block_error.stat[0].uvalue = 0;
469	c->block_count.stat[0].uvalue = 0;	469	c->block_count.stat[0].uvalue = 0;
470	c->block_error.stat[0].scale = FE_SCALE_COUNTER;	470	c->block_error.stat[0].scale = FE_SCALE_COUNTER;
471	c->block_count.stat[0].scale = FE_SCALE_COUNTER;	471	c->block_count.stat[0].scale = FE_SCALE_COUNTER;
472	c->post_bit_error.stat[0].uvalue = 0;	472	c->post_bit_error.stat[0].uvalue = 0;
473	c->post_bit_count.stat[0].uvalue = 0;	473	c->post_bit_count.stat[0].uvalue = 0;
474	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;	474	c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
475	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;	475	c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
476		476
477	c->post_bit_error.len = n_layers + 1;	477	c->post_bit_error.len = n_layers + 1;
478	c->post_bit_count.len = n_layers + 1;	478	c->post_bit_count.len = n_layers + 1;
479	c->block_error.len = n_layers + 1;	479	c->block_error.len = n_layers + 1;
480	c->block_count.len = n_layers + 1;	480	c->block_count.len = n_layers + 1;
481	for (i = 0; i < n_layers; i++) {	481	for (i = 0; i < n_layers; i++) {
482	lr = &p->LayerInfo[i];	482	lr = &p->layer_info[i];
483		483
484	/* Update per-layer transmission parameters */	484	/* Update per-layer transmission parameters */
485	if (lr->number_of_segments > 0 && lr->number_of_segments < 13) {	485	if (lr->number_of_segments > 0 && lr->number_of_segments < 13) {
486	c->isdbt_layer_enabled \|= 1 << i;	486	c->isdbt_layer_enabled \|= 1 << i;
487	c->layer[i].segment_count = lr->number_of_segments;	487	c->layer[i].segment_count = lr->number_of_segments;
488	} else {	488	} else {
489	continue;	489	continue;
490	}	490	}
491	c->layer[i].modulation = sms_to_modulation(lr->constellation);	491	c->layer[i].modulation = sms_to_modulation(lr->constellation);
492		492
493	/* TS PER */	493	/* TS PER */
494	c->block_error.stat[i + 1].scale = FE_SCALE_COUNTER;	494	c->block_error.stat[i + 1].scale = FE_SCALE_COUNTER;
495	c->block_count.stat[i + 1].scale = FE_SCALE_COUNTER;	495	c->block_count.stat[i + 1].scale = FE_SCALE_COUNTER;
496	c->block_error.stat[i + 1].uvalue += lr->error_ts_packets;	496	c->block_error.stat[i + 1].uvalue += lr->error_ts_packets;
497	c->block_count.stat[i + 1].uvalue += lr->total_ts_packets;	497	c->block_count.stat[i + 1].uvalue += lr->total_ts_packets;
498		498
499	/* Update global PER counter */	499	/* Update global PER counter */
500	c->block_error.stat[0].uvalue += lr->error_ts_packets;	500	c->block_error.stat[0].uvalue += lr->error_ts_packets;
501	c->block_count.stat[0].uvalue += lr->total_ts_packets;	501	c->block_count.stat[0].uvalue += lr->total_ts_packets;
502		502
503	/* BER */	503	/* ber */
504	c->post_bit_error.stat[i + 1].scale = FE_SCALE_COUNTER;	504	c->post_bit_error.stat[i + 1].scale = FE_SCALE_COUNTER;
505	c->post_bit_count.stat[i + 1].scale = FE_SCALE_COUNTER;	505	c->post_bit_count.stat[i + 1].scale = FE_SCALE_COUNTER;
506	c->post_bit_error.stat[i + 1].uvalue += lr->ber_error_count;	506	c->post_bit_error.stat[i + 1].uvalue += lr->ber_error_count;
507	c->post_bit_count.stat[i + 1].uvalue += lr->ber_bit_count;	507	c->post_bit_count.stat[i + 1].uvalue += lr->ber_bit_count;
508		508
509	/* Update global BER counter */	509	/* Update global ber counter */
510	c->post_bit_error.stat[0].uvalue += lr->ber_error_count;	510	c->post_bit_error.stat[0].uvalue += lr->ber_error_count;
511	c->post_bit_count.stat[0].uvalue += lr->ber_bit_count;	511	c->post_bit_count.stat[0].uvalue += lr->ber_bit_count;
512	}	512	}
513	}	513	}
514		514
515	static int smsdvb_onresponse(void context, struct smscore_buffer_t cb)	515	static int smsdvb_onresponse(void context, struct smscore_buffer_t cb)
516	{	516	{
517	struct smsdvb_client_t client = (struct smsdvb_client_t ) context;	517	struct smsdvb_client_t client = (struct smsdvb_client_t ) context;
518	struct sms_msg_hdr phdr = (struct sms_msg_hdr ) (((u8 *) cb->p)	518	struct sms_msg_hdr phdr = (struct sms_msg_hdr ) (((u8 *) cb->p)
519	+ cb->offset);	519	+ cb->offset);
520	void *p = phdr + 1;	520	void *p = phdr + 1;
521	struct dvb_frontend *fe = &client->frontend;	521	struct dvb_frontend *fe = &client->frontend;
522	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	522	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
523	bool is_status_update = false;	523	bool is_status_update = false;
524		524
525	switch (phdr->msg_type) {	525	switch (phdr->msg_type) {
526	case MSG_SMS_DVBT_BDA_DATA:	526	case MSG_SMS_DVBT_BDA_DATA:
527	/*	527	/*
528	* Only feed data to dvb demux if are there any feed listening	528	* Only feed data to dvb demux if are there any feed listening
529	* to it and if the device has tuned	529	* to it and if the device has tuned
530	*/	530	*/
531	if (client->feed_users && client->has_tuned)	531	if (client->feed_users && client->has_tuned)
532	dvb_dmx_swfilter(&client->demux, p,	532	dvb_dmx_swfilter(&client->demux, p,
533	cb->size - sizeof(struct sms_msg_hdr));	533	cb->size - sizeof(struct sms_msg_hdr));
534	break;	534	break;
535		535
536	case MSG_SMS_RF_TUNE_RES:	536	case MSG_SMS_RF_TUNE_RES:
537	case MSG_SMS_ISDBT_TUNE_RES:	537	case MSG_SMS_ISDBT_TUNE_RES:
538	complete(&client->tune_done);	538	complete(&client->tune_done);
539	break;	539	break;
540		540
541	case MSG_SMS_SIGNAL_DETECTED_IND:	541	case MSG_SMS_SIGNAL_DETECTED_IND:
542	client->fe_status = FE_HAS_SIGNAL \| FE_HAS_CARRIER \|	542	client->fe_status = FE_HAS_SIGNAL \| FE_HAS_CARRIER \|
543	FE_HAS_VITERBI \| FE_HAS_SYNC \|	543	FE_HAS_VITERBI \| FE_HAS_SYNC \|
544	FE_HAS_LOCK;	544	FE_HAS_LOCK;
545		545
546	is_status_update = true;	546	is_status_update = true;
547	break;	547	break;
548		548
549	case MSG_SMS_NO_SIGNAL_IND:	549	case MSG_SMS_NO_SIGNAL_IND:
550	client->fe_status = 0;	550	client->fe_status = 0;
551		551
552	is_status_update = true;	552	is_status_update = true;
553	break;	553	break;
554		554
555	case MSG_SMS_TRANSMISSION_IND:	555	case MSG_SMS_TRANSMISSION_IND:
556	smsdvb_update_tx_params(client, p);	556	smsdvb_update_tx_params(client, p);
557		557
558	is_status_update = true;	558	is_status_update = true;
559	break;	559	break;
560		560
561	case MSG_SMS_HO_PER_SLICES_IND:	561	case MSG_SMS_HO_PER_SLICES_IND:
562	smsdvb_update_per_slices(client, p);	562	smsdvb_update_per_slices(client, p);
563		563
564	is_status_update = true;	564	is_status_update = true;
565	break;	565	break;
566		566
567	case MSG_SMS_GET_STATISTICS_RES:	567	case MSG_SMS_GET_STATISTICS_RES:
568	switch (smscore_get_device_mode(client->coredev)) {	568	switch (smscore_get_device_mode(client->coredev)) {
569	case DEVICE_MODE_ISDBT:	569	case DEVICE_MODE_ISDBT:
570	case DEVICE_MODE_ISDBT_BDA:	570	case DEVICE_MODE_ISDBT_BDA:
571	smsdvb_update_isdbt_stats(client, p);	571	smsdvb_update_isdbt_stats(client, p);
572	break;	572	break;
573	default:	573	default:
574	/* Skip sms_msg_statistics_info:request_result field */	574	/* Skip sms_msg_statistics_info:request_result field */
575	smsdvb_update_dvb_stats(client, p + sizeof(u32));	575	smsdvb_update_dvb_stats(client, p + sizeof(u32));
576	}	576	}
577		577
578	is_status_update = true;	578	is_status_update = true;
579	break;	579	break;
580		580
581	/* Only for ISDB-T */	581	/* Only for ISDB-T */
582	case MSG_SMS_GET_STATISTICS_EX_RES:	582	case MSG_SMS_GET_STATISTICS_EX_RES:
583	/* Skip sms_msg_statistics_info:request_result field? */	583	/* Skip sms_msg_statistics_info:request_result field? */
584	smsdvb_update_isdbt_stats_ex(client, p + sizeof(u32));	584	smsdvb_update_isdbt_stats_ex(client, p + sizeof(u32));
585	is_status_update = true;	585	is_status_update = true;
586	break;	586	break;
587	default:	587	default:
588	sms_info("message not handled");	588	sms_info("message not handled");
589	}	589	}
590	smscore_putbuffer(client->coredev, cb);	590	smscore_putbuffer(client->coredev, cb);
591		591
592	if (is_status_update) {	592	if (is_status_update) {
593	if (client->fe_status & FE_HAS_LOCK) {	593	if (client->fe_status & FE_HAS_LOCK) {
594	sms_board_dvb3_event(client, DVB3_EVENT_FE_LOCK);	594	sms_board_dvb3_event(client, DVB3_EVENT_FE_LOCK);
595	if (client->last_per == c->block_error.stat[0].uvalue)	595	if (client->last_per == c->block_error.stat[0].uvalue)
596	sms_board_dvb3_event(client, DVB3_EVENT_UNC_OK);	596	sms_board_dvb3_event(client, DVB3_EVENT_UNC_OK);
597	else	597	else
598	sms_board_dvb3_event(client, DVB3_EVENT_UNC_ERR);	598	sms_board_dvb3_event(client, DVB3_EVENT_UNC_ERR);
599	client->has_tuned = true;	599	client->has_tuned = true;
600	} else {	600	} else {
601	smsdvb_stats_not_ready(fe);	601	smsdvb_stats_not_ready(fe);
602	client->has_tuned = false;	602	client->has_tuned = false;
603	sms_board_dvb3_event(client, DVB3_EVENT_FE_UNLOCK);	603	sms_board_dvb3_event(client, DVB3_EVENT_FE_UNLOCK);
604	}	604	}
605	complete(&client->stats_done);	605	complete(&client->stats_done);
606	}	606	}
607		607
608	return 0;	608	return 0;
609	}	609	}
610		610
611	static void smsdvb_unregister_client(struct smsdvb_client_t *client)	611	static void smsdvb_unregister_client(struct smsdvb_client_t *client)
612	{	612	{
613	/* must be called under clientslock */	613	/* must be called under clientslock */
614		614
615	list_del(&client->entry);	615	list_del(&client->entry);
616		616
617	smsdvb_debugfs_release(client);	617	smsdvb_debugfs_release(client);
618	smscore_unregister_client(client->smsclient);	618	smscore_unregister_client(client->smsclient);
619	dvb_unregister_frontend(&client->frontend);	619	dvb_unregister_frontend(&client->frontend);
620	dvb_dmxdev_release(&client->dmxdev);	620	dvb_dmxdev_release(&client->dmxdev);
621	dvb_dmx_release(&client->demux);	621	dvb_dmx_release(&client->demux);
622	dvb_unregister_adapter(&client->adapter);	622	dvb_unregister_adapter(&client->adapter);
623	kfree(client);	623	kfree(client);
624	}	624	}
625		625
626	static void smsdvb_onremove(void *context)	626	static void smsdvb_onremove(void *context)
627	{	627	{
628	kmutex_lock(&g_smsdvb_clientslock);	628	kmutex_lock(&g_smsdvb_clientslock);
629		629
630	smsdvb_unregister_client((struct smsdvb_client_t *) context);	630	smsdvb_unregister_client((struct smsdvb_client_t *) context);
631		631
632	kmutex_unlock(&g_smsdvb_clientslock);	632	kmutex_unlock(&g_smsdvb_clientslock);
633	}	633	}
634		634
635	static int smsdvb_start_feed(struct dvb_demux_feed *feed)	635	static int smsdvb_start_feed(struct dvb_demux_feed *feed)
636	{	636	{
637	struct smsdvb_client_t *client =	637	struct smsdvb_client_t *client =
638	container_of(feed->demux, struct smsdvb_client_t, demux);	638	container_of(feed->demux, struct smsdvb_client_t, demux);
639	struct sms_msg_data PidMsg;	639	struct sms_msg_data pid_msg;
640		640
641	sms_debug("add pid %d(%x)",	641	sms_debug("add pid %d(%x)",
642	feed->pid, feed->pid);	642	feed->pid, feed->pid);
643		643
644	client->feed_users++;	644	client->feed_users++;
645		645
646	PidMsg.x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;	646	pid_msg.x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
647	PidMsg.x_msg_header.msg_dst_id = HIF_TASK;	647	pid_msg.x_msg_header.msg_dst_id = HIF_TASK;
648	PidMsg.x_msg_header.msg_flags = 0;	648	pid_msg.x_msg_header.msg_flags = 0;
649	PidMsg.x_msg_header.msg_type = MSG_SMS_ADD_PID_FILTER_REQ;	649	pid_msg.x_msg_header.msg_type = MSG_SMS_ADD_PID_FILTER_REQ;
650	PidMsg.x_msg_header.msg_length = sizeof(PidMsg);	650	pid_msg.x_msg_header.msg_length = sizeof(pid_msg);
651	PidMsg.msgData[0] = feed->pid;	651	pid_msg.msg_data[0] = feed->pid;
652		652
653	return smsclient_sendrequest(client->smsclient,	653	return smsclient_sendrequest(client->smsclient,
654	&PidMsg, sizeof(PidMsg));	654	&pid_msg, sizeof(pid_msg));
655	}	655	}
656		656
657	static int smsdvb_stop_feed(struct dvb_demux_feed *feed)	657	static int smsdvb_stop_feed(struct dvb_demux_feed *feed)
658	{	658	{
659	struct smsdvb_client_t *client =	659	struct smsdvb_client_t *client =
660	container_of(feed->demux, struct smsdvb_client_t, demux);	660	container_of(feed->demux, struct smsdvb_client_t, demux);
661	struct sms_msg_data PidMsg;	661	struct sms_msg_data pid_msg;
662		662
663	sms_debug("remove pid %d(%x)",	663	sms_debug("remove pid %d(%x)",
664	feed->pid, feed->pid);	664	feed->pid, feed->pid);
665		665
666	client->feed_users--;	666	client->feed_users--;
667		667
668	PidMsg.x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;	668	pid_msg.x_msg_header.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
669	PidMsg.x_msg_header.msg_dst_id = HIF_TASK;	669	pid_msg.x_msg_header.msg_dst_id = HIF_TASK;
670	PidMsg.x_msg_header.msg_flags = 0;	670	pid_msg.x_msg_header.msg_flags = 0;
671	PidMsg.x_msg_header.msg_type = MSG_SMS_REMOVE_PID_FILTER_REQ;	671	pid_msg.x_msg_header.msg_type = MSG_SMS_REMOVE_PID_FILTER_REQ;
672	PidMsg.x_msg_header.msg_length = sizeof(PidMsg);	672	pid_msg.x_msg_header.msg_length = sizeof(pid_msg);
673	PidMsg.msgData[0] = feed->pid;	673	pid_msg.msg_data[0] = feed->pid;
674		674
675	return smsclient_sendrequest(client->smsclient,	675	return smsclient_sendrequest(client->smsclient,
676	&PidMsg, sizeof(PidMsg));	676	&pid_msg, sizeof(pid_msg));
677	}	677	}
678		678
679	static int smsdvb_sendrequest_and_wait(struct smsdvb_client_t *client,	679	static int smsdvb_sendrequest_and_wait(struct smsdvb_client_t *client,
680	void *buffer, size_t size,	680	void *buffer, size_t size,
681	struct completion *completion)	681	struct completion *completion)
682	{	682	{
683	int rc;	683	int rc;
684		684
685	rc = smsclient_sendrequest(client->smsclient, buffer, size);	685	rc = smsclient_sendrequest(client->smsclient, buffer, size);
686	if (rc < 0)	686	if (rc < 0)
687	return rc;	687	return rc;
688		688
689	return wait_for_completion_timeout(completion,	689	return wait_for_completion_timeout(completion,
690	msecs_to_jiffies(2000)) ?	690	msecs_to_jiffies(2000)) ?
691	0 : -ETIME;	691	0 : -ETIME;
692	}	692	}
693		693
694	static int smsdvb_send_statistics_request(struct smsdvb_client_t *client)	694	static int smsdvb_send_statistics_request(struct smsdvb_client_t *client)
695	{	695	{
696	int rc;	696	int rc;
697	struct sms_msg_hdr Msg;	697	struct sms_msg_hdr msg;
698		698
699	/* Don't request stats too fast */	699	/* Don't request stats too fast */
700	if (client->get_stats_jiffies &&	700	if (client->get_stats_jiffies &&
701	(!time_after(jiffies, client->get_stats_jiffies)))	701	(!time_after(jiffies, client->get_stats_jiffies)))
702	return 0;	702	return 0;
703	client->get_stats_jiffies = jiffies + msecs_to_jiffies(100);	703	client->get_stats_jiffies = jiffies + msecs_to_jiffies(100);
704		704
705	Msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;	705	msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
706	Msg.msg_dst_id = HIF_TASK;	706	msg.msg_dst_id = HIF_TASK;
707	Msg.msg_flags = 0;	707	msg.msg_flags = 0;
708	Msg.msg_length = sizeof(Msg);	708	msg.msg_length = sizeof(msg);
709		709
710	switch (smscore_get_device_mode(client->coredev)) {	710	switch (smscore_get_device_mode(client->coredev)) {
711	case DEVICE_MODE_ISDBT:	711	case DEVICE_MODE_ISDBT:
712	case DEVICE_MODE_ISDBT_BDA:	712	case DEVICE_MODE_ISDBT_BDA:
713	/*	713	/*
714	* Check for firmware version, to avoid breaking for old cards	714	* Check for firmware version, to avoid breaking for old cards
715	*/	715	*/
716	if (client->coredev->fw_version >= 0x800)	716	if (client->coredev->fw_version >= 0x800)
717	Msg.msg_type = MSG_SMS_GET_STATISTICS_EX_REQ;	717	msg.msg_type = MSG_SMS_GET_STATISTICS_EX_REQ;
718	else	718	else
719	Msg.msg_type = MSG_SMS_GET_STATISTICS_REQ;	719	msg.msg_type = MSG_SMS_GET_STATISTICS_REQ;
720	break;	720	break;
721	default:	721	default:
722	Msg.msg_type = MSG_SMS_GET_STATISTICS_REQ;	722	msg.msg_type = MSG_SMS_GET_STATISTICS_REQ;
723	}	723	}
724		724
725	rc = smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg),	725	rc = smsdvb_sendrequest_and_wait(client, &msg, sizeof(msg),
726	&client->stats_done);	726	&client->stats_done);
727		727
728	return rc;	728	return rc;
729	}	729	}
730		730
731	static inline int led_feedback(struct smsdvb_client_t *client)	731	static inline int led_feedback(struct smsdvb_client_t *client)
732	{	732	{
733	if (!(client->fe_status & FE_HAS_LOCK))	733	if (!(client->fe_status & FE_HAS_LOCK))
734	return sms_board_led_feedback(client->coredev, SMS_LED_OFF);	734	return sms_board_led_feedback(client->coredev, SMS_LED_OFF);
735		735
736	return sms_board_led_feedback(client->coredev,	736	return sms_board_led_feedback(client->coredev,
737	(client->legacy_ber == 0) ?	737	(client->legacy_ber == 0) ?
738	SMS_LED_HI : SMS_LED_LO);	738	SMS_LED_HI : SMS_LED_LO);
739	}	739	}
740		740
741	static int smsdvb_read_status(struct dvb_frontend fe, fe_status_t stat)	741	static int smsdvb_read_status(struct dvb_frontend fe, fe_status_t stat)
742	{	742	{
743	int rc;	743	int rc;
744	struct smsdvb_client_t *client;	744	struct smsdvb_client_t *client;
745	client = container_of(fe, struct smsdvb_client_t, frontend);	745	client = container_of(fe, struct smsdvb_client_t, frontend);
746		746
747	rc = smsdvb_send_statistics_request(client);	747	rc = smsdvb_send_statistics_request(client);
748		748
749	*stat = client->fe_status;	749	*stat = client->fe_status;
750		750
751	led_feedback(client);	751	led_feedback(client);
752		752
753	return rc;	753	return rc;
754	}	754	}
755		755
756	static int smsdvb_read_ber(struct dvb_frontend fe, u32 ber)	756	static int smsdvb_read_ber(struct dvb_frontend fe, u32 ber)
757	{	757	{
758	int rc;	758	int rc;
759	struct smsdvb_client_t *client;	759	struct smsdvb_client_t *client;
760		760
761	client = container_of(fe, struct smsdvb_client_t, frontend);	761	client = container_of(fe, struct smsdvb_client_t, frontend);
762		762
763	rc = smsdvb_send_statistics_request(client);	763	rc = smsdvb_send_statistics_request(client);
764		764
765	*ber = client->legacy_ber;	765	*ber = client->legacy_ber;
766		766
767	led_feedback(client);	767	led_feedback(client);
768		768
769	return rc;	769	return rc;
770	}	770	}
771		771
772	static int smsdvb_read_signal_strength(struct dvb_frontend fe, u16 strength)	772	static int smsdvb_read_signal_strength(struct dvb_frontend fe, u16 strength)
773	{	773	{
774	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	774	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
775	int rc;	775	int rc;
776	s32 power = (s32) c->strength.stat[0].uvalue;	776	s32 power = (s32) c->strength.stat[0].uvalue;
777	struct smsdvb_client_t *client;	777	struct smsdvb_client_t *client;
778		778
779	client = container_of(fe, struct smsdvb_client_t, frontend);	779	client = container_of(fe, struct smsdvb_client_t, frontend);
780		780
781	rc = smsdvb_send_statistics_request(client);	781	rc = smsdvb_send_statistics_request(client);
782		782
783	if (power < -95)	783	if (power < -95)
784	*strength = 0;	784	*strength = 0;
785	else if (power > -29)	785	else if (power > -29)
786	*strength = 65535;	786	*strength = 65535;
787	else	787	else
788	strength = (power + 95) 65535 / 66;	788	strength = (power + 95) 65535 / 66;
789		789
790	led_feedback(client);	790	led_feedback(client);
791		791
792	return rc;	792	return rc;
793	}	793	}
794		794
795	static int smsdvb_read_snr(struct dvb_frontend fe, u16 snr)	795	static int smsdvb_read_snr(struct dvb_frontend fe, u16 snr)
796	{	796	{
797	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	797	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
798	int rc;	798	int rc;
799	struct smsdvb_client_t *client;	799	struct smsdvb_client_t *client;
800		800
801	client = container_of(fe, struct smsdvb_client_t, frontend);	801	client = container_of(fe, struct smsdvb_client_t, frontend);
802		802
803	rc = smsdvb_send_statistics_request(client);	803	rc = smsdvb_send_statistics_request(client);
804		804
805	/* Preferred scale for SNR with legacy API: 0.1 dB */	805	/* Preferred scale for SNR with legacy API: 0.1 dB */
806	*snr = c->cnr.stat[0].svalue / 100;	806	*snr = c->cnr.stat[0].svalue / 100;
807		807
808	led_feedback(client);	808	led_feedback(client);
809		809
810	return rc;	810	return rc;
811	}	811	}
812		812
813	static int smsdvb_read_ucblocks(struct dvb_frontend fe, u32 ucblocks)	813	static int smsdvb_read_ucblocks(struct dvb_frontend fe, u32 ucblocks)
814	{	814	{
815	int rc;	815	int rc;
816	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	816	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
817	struct smsdvb_client_t *client;	817	struct smsdvb_client_t *client;
818		818
819	client = container_of(fe, struct smsdvb_client_t, frontend);	819	client = container_of(fe, struct smsdvb_client_t, frontend);
820		820
821	rc = smsdvb_send_statistics_request(client);	821	rc = smsdvb_send_statistics_request(client);
822		822
823	*ucblocks = c->block_error.stat[0].uvalue;	823	*ucblocks = c->block_error.stat[0].uvalue;
824		824
825	led_feedback(client);	825	led_feedback(client);
826		826
827	return rc;	827	return rc;
828	}	828	}
829		829
830	static int smsdvb_get_tune_settings(struct dvb_frontend *fe,	830	static int smsdvb_get_tune_settings(struct dvb_frontend *fe,
831	struct dvb_frontend_tune_settings *tune)	831	struct dvb_frontend_tune_settings *tune)
832	{	832	{
833	sms_debug("");	833	sms_debug("");
834		834
835	tune->min_delay_ms = 400;	835	tune->min_delay_ms = 400;
836	tune->step_size = 250000;	836	tune->step_size = 250000;
837	tune->max_drift = 0;	837	tune->max_drift = 0;
838	return 0;	838	return 0;
839	}	839	}
840		840
841	static int smsdvb_dvbt_set_frontend(struct dvb_frontend *fe)	841	static int smsdvb_dvbt_set_frontend(struct dvb_frontend *fe)
842	{	842	{
843	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	843	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
844	struct smsdvb_client_t *client =	844	struct smsdvb_client_t *client =
845	container_of(fe, struct smsdvb_client_t, frontend);	845	container_of(fe, struct smsdvb_client_t, frontend);
846		846
847	struct {	847	struct {
848	struct sms_msg_hdr Msg;	848	struct sms_msg_hdr msg;
849	u32 Data[3];	849	u32 Data[3];
850	} Msg;	850	} msg;
851		851
852	int ret;	852	int ret;
853		853
854	client->fe_status = 0;	854	client->fe_status = 0;
855	client->event_fe_state = -1;	855	client->event_fe_state = -1;
856	client->event_unc_state = -1;	856	client->event_unc_state = -1;
857	fe->dtv_property_cache.delivery_system = SYS_DVBT;	857	fe->dtv_property_cache.delivery_system = SYS_DVBT;
858		858
859	Msg.Msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;	859	msg.msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
860	Msg.Msg.msg_dst_id = HIF_TASK;	860	msg.msg.msg_dst_id = HIF_TASK;
861	Msg.Msg.msg_flags = 0;	861	msg.msg.msg_flags = 0;
862	Msg.Msg.msg_type = MSG_SMS_RF_TUNE_REQ;	862	msg.msg.msg_type = MSG_SMS_RF_TUNE_REQ;
863	Msg.Msg.msg_length = sizeof(Msg);	863	msg.msg.msg_length = sizeof(msg);
864	Msg.Data[0] = c->frequency;	864	msg.Data[0] = c->frequency;
865	Msg.Data[2] = 12000000;	865	msg.Data[2] = 12000000;
866		866
867	sms_info("%s: freq %d band %d", __func__, c->frequency,	867	sms_info("%s: freq %d band %d", __func__, c->frequency,
868	c->bandwidth_hz);	868	c->bandwidth_hz);
869		869
870	switch (c->bandwidth_hz / 1000000) {	870	switch (c->bandwidth_hz / 1000000) {
871	case 8:	871	case 8:
872	Msg.Data[1] = BW_8_MHZ;	872	msg.Data[1] = BW_8_MHZ;
873	break;	873	break;
874	case 7:	874	case 7:
875	Msg.Data[1] = BW_7_MHZ;	875	msg.Data[1] = BW_7_MHZ;
876	break;	876	break;
877	case 6:	877	case 6:
878	Msg.Data[1] = BW_6_MHZ;	878	msg.Data[1] = BW_6_MHZ;
879	break;	879	break;
880	case 0:	880	case 0:
881	return -EOPNOTSUPP;	881	return -EOPNOTSUPP;
882	default:	882	default:
883	return -EINVAL;	883	return -EINVAL;
884	}	884	}
885	/* Disable LNA, if any. An error is returned if no LNA is present */	885	/* Disable LNA, if any. An error is returned if no LNA is present */
886	ret = sms_board_lna_control(client->coredev, 0);	886	ret = sms_board_lna_control(client->coredev, 0);
887	if (ret == 0) {	887	if (ret == 0) {
888	fe_status_t status;	888	fe_status_t status;
889		889
890	/* tune with LNA off at first */	890	/* tune with LNA off at first */
891	ret = smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg),	891	ret = smsdvb_sendrequest_and_wait(client, &msg, sizeof(msg),
892	&client->tune_done);	892	&client->tune_done);
893		893
894	smsdvb_read_status(fe, &status);	894	smsdvb_read_status(fe, &status);
895		895
896	if (status & FE_HAS_LOCK)	896	if (status & FE_HAS_LOCK)
897	return ret;	897	return ret;
898		898
899	/* previous tune didn't lock - enable LNA and tune again */	899	/* previous tune didn't lock - enable LNA and tune again */
900	sms_board_lna_control(client->coredev, 1);	900	sms_board_lna_control(client->coredev, 1);
901	}	901	}
902		902
903	return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg),	903	return smsdvb_sendrequest_and_wait(client, &msg, sizeof(msg),
904	&client->tune_done);	904	&client->tune_done);
905	}	905	}
906		906
907	static int smsdvb_isdbt_set_frontend(struct dvb_frontend *fe)	907	static int smsdvb_isdbt_set_frontend(struct dvb_frontend *fe)
908	{	908	{
909	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	909	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
910	struct smsdvb_client_t *client =	910	struct smsdvb_client_t *client =
911	container_of(fe, struct smsdvb_client_t, frontend);	911	container_of(fe, struct smsdvb_client_t, frontend);
912	int board_id = smscore_get_board_id(client->coredev);	912	int board_id = smscore_get_board_id(client->coredev);
913	struct sms_board *board = sms_get_board(board_id);	913	struct sms_board *board = sms_get_board(board_id);
914	enum sms_device_type_st type = board->type;	914	enum sms_device_type_st type = board->type;
915	int ret;	915	int ret;
916		916
917	struct {	917	struct {
918	struct sms_msg_hdr Msg;	918	struct sms_msg_hdr msg;
919	u32 Data[4];	919	u32 Data[4];
920	} Msg;	920	} msg;
921		921
922	fe->dtv_property_cache.delivery_system = SYS_ISDBT;	922	fe->dtv_property_cache.delivery_system = SYS_ISDBT;
923		923
924	Msg.Msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;	924	msg.msg.msg_src_id = DVBT_BDA_CONTROL_MSG_ID;
925	Msg.Msg.msg_dst_id = HIF_TASK;	925	msg.msg.msg_dst_id = HIF_TASK;
926	Msg.Msg.msg_flags = 0;	926	msg.msg.msg_flags = 0;
927	Msg.Msg.msg_type = MSG_SMS_ISDBT_TUNE_REQ;	927	msg.msg.msg_type = MSG_SMS_ISDBT_TUNE_REQ;
928	Msg.Msg.msg_length = sizeof(Msg);	928	msg.msg.msg_length = sizeof(msg);
929		929
930	if (c->isdbt_sb_segment_idx == -1)	930	if (c->isdbt_sb_segment_idx == -1)
931	c->isdbt_sb_segment_idx = 0;	931	c->isdbt_sb_segment_idx = 0;
932		932
933	if (!c->isdbt_layer_enabled)	933	if (!c->isdbt_layer_enabled)
934	c->isdbt_layer_enabled = 7;	934	c->isdbt_layer_enabled = 7;
935		935
936	Msg.Data[0] = c->frequency;	936	msg.Data[0] = c->frequency;
937	Msg.Data[1] = BW_ISDBT_1SEG;	937	msg.Data[1] = BW_ISDBT_1SEG;
938	Msg.Data[2] = 12000000;	938	msg.Data[2] = 12000000;
939	Msg.Data[3] = c->isdbt_sb_segment_idx;	939	msg.Data[3] = c->isdbt_sb_segment_idx;
940		940
941	if (c->isdbt_partial_reception) {	941	if (c->isdbt_partial_reception) {
942	if ((type == SMS_PELE \|\| type == SMS_RIO) &&	942	if ((type == SMS_PELE \|\| type == SMS_RIO) &&
943	c->isdbt_sb_segment_count > 3)	943	c->isdbt_sb_segment_count > 3)
944	Msg.Data[1] = BW_ISDBT_13SEG;	944	msg.Data[1] = BW_ISDBT_13SEG;
945	else if (c->isdbt_sb_segment_count > 1)	945	else if (c->isdbt_sb_segment_count > 1)
946	Msg.Data[1] = BW_ISDBT_3SEG;	946	msg.Data[1] = BW_ISDBT_3SEG;
947	} else if (type == SMS_PELE \|\| type == SMS_RIO)	947	} else if (type == SMS_PELE \|\| type == SMS_RIO)
948	Msg.Data[1] = BW_ISDBT_13SEG;	948	msg.Data[1] = BW_ISDBT_13SEG;
949		949
950	c->bandwidth_hz = 6000000;	950	c->bandwidth_hz = 6000000;
951		951
952	sms_info("%s: freq %d segwidth %d segindex %d", __func__,	952	sms_info("%s: freq %d segwidth %d segindex %d", __func__,
953	c->frequency, c->isdbt_sb_segment_count,	953	c->frequency, c->isdbt_sb_segment_count,
954	c->isdbt_sb_segment_idx);	954	c->isdbt_sb_segment_idx);
955		955
956	/* Disable LNA, if any. An error is returned if no LNA is present */	956	/* Disable LNA, if any. An error is returned if no LNA is present */
957	ret = sms_board_lna_control(client->coredev, 0);	957	ret = sms_board_lna_control(client->coredev, 0);
958	if (ret == 0) {	958	if (ret == 0) {
959	fe_status_t status;	959	fe_status_t status;
960		960
961	/* tune with LNA off at first */	961	/* tune with LNA off at first */
962	ret = smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg),	962	ret = smsdvb_sendrequest_and_wait(client, &msg, sizeof(msg),
963	&client->tune_done);	963	&client->tune_done);
964		964
965	smsdvb_read_status(fe, &status);	965	smsdvb_read_status(fe, &status);
966		966
967	if (status & FE_HAS_LOCK)	967	if (status & FE_HAS_LOCK)
968	return ret;	968	return ret;
969		969
970	/* previous tune didn't lock - enable LNA and tune again */	970	/* previous tune didn't lock - enable LNA and tune again */
971	sms_board_lna_control(client->coredev, 1);	971	sms_board_lna_control(client->coredev, 1);
972	}	972	}
973	return smsdvb_sendrequest_and_wait(client, &Msg, sizeof(Msg),	973	return smsdvb_sendrequest_and_wait(client, &msg, sizeof(msg),
974	&client->tune_done);	974	&client->tune_done);
975	}	975	}
976		976
977	static int smsdvb_set_frontend(struct dvb_frontend *fe)	977	static int smsdvb_set_frontend(struct dvb_frontend *fe)
978	{	978	{
979	struct dtv_frontend_properties *c = &fe->dtv_property_cache;	979	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
980	struct smsdvb_client_t *client =	980	struct smsdvb_client_t *client =
981	container_of(fe, struct smsdvb_client_t, frontend);	981	container_of(fe, struct smsdvb_client_t, frontend);
982	struct smscore_device_t *coredev = client->coredev;	982	struct smscore_device_t *coredev = client->coredev;
983		983
984	smsdvb_stats_not_ready(fe);	984	smsdvb_stats_not_ready(fe);
985	c->strength.stat[0].uvalue = 0;	985	c->strength.stat[0].uvalue = 0;
986	c->cnr.stat[0].uvalue = 0;	986	c->cnr.stat[0].uvalue = 0;
987		987
988	client->has_tuned = false;	988	client->has_tuned = false;
989		989
990	switch (smscore_get_device_mode(coredev)) {	990	switch (smscore_get_device_mode(coredev)) {
991	case DEVICE_MODE_DVBT:	991	case DEVICE_MODE_DVBT:
992	case DEVICE_MODE_DVBT_BDA:	992	case DEVICE_MODE_DVBT_BDA:
993	return smsdvb_dvbt_set_frontend(fe);	993	return smsdvb_dvbt_set_frontend(fe);
994	case DEVICE_MODE_ISDBT:	994	case DEVICE_MODE_ISDBT:
995	case DEVICE_MODE_ISDBT_BDA:	995	case DEVICE_MODE_ISDBT_BDA:
996	return smsdvb_isdbt_set_frontend(fe);	996	return smsdvb_isdbt_set_frontend(fe);
997	default:	997	default:
998	return -EINVAL;	998	return -EINVAL;
999	}	999	}
1000	}	1000	}
1001		1001
1002	/* Nothing to do here, as stats are automatically updated */	1002	/* Nothing to do here, as stats are automatically updated */
1003	static int smsdvb_get_frontend(struct dvb_frontend *fe)	1003	static int smsdvb_get_frontend(struct dvb_frontend *fe)
1004	{	1004	{
1005	return 0;	1005	return 0;
1006	}	1006	}
1007		1007
1008	static int smsdvb_init(struct dvb_frontend *fe)	1008	static int smsdvb_init(struct dvb_frontend *fe)
1009	{	1009	{
1010	struct smsdvb_client_t *client =	1010	struct smsdvb_client_t *client =
1011	container_of(fe, struct smsdvb_client_t, frontend);	1011	container_of(fe, struct smsdvb_client_t, frontend);
1012		1012
1013	sms_board_power(client->coredev, 1);	1013	sms_board_power(client->coredev, 1);
1014		1014
1015	sms_board_dvb3_event(client, DVB3_EVENT_INIT);	1015	sms_board_dvb3_event(client, DVB3_EVENT_INIT);
1016	return 0;	1016	return 0;
1017	}	1017	}
1018		1018
1019	static int smsdvb_sleep(struct dvb_frontend *fe)	1019	static int smsdvb_sleep(struct dvb_frontend *fe)
1020	{	1020	{
1021	struct smsdvb_client_t *client =	1021	struct smsdvb_client_t *client =
1022	container_of(fe, struct smsdvb_client_t, frontend);	1022	container_of(fe, struct smsdvb_client_t, frontend);
1023		1023
1024	sms_board_led_feedback(client->coredev, SMS_LED_OFF);	1024	sms_board_led_feedback(client->coredev, SMS_LED_OFF);
1025	sms_board_power(client->coredev, 0);	1025	sms_board_power(client->coredev, 0);
1026		1026
1027	sms_board_dvb3_event(client, DVB3_EVENT_SLEEP);	1027	sms_board_dvb3_event(client, DVB3_EVENT_SLEEP);
1028		1028
1029	return 0;	1029	return 0;
1030	}	1030	}
1031		1031
1032	static void smsdvb_release(struct dvb_frontend *fe)	1032	static void smsdvb_release(struct dvb_frontend *fe)
1033	{	1033	{
1034	/* do nothing */	1034	/* do nothing */
1035	}	1035	}
1036		1036
1037	static struct dvb_frontend_ops smsdvb_fe_ops = {	1037	static struct dvb_frontend_ops smsdvb_fe_ops = {
1038	.info = {	1038	.info = {
1039	.name = "Siano Mobile Digital MDTV Receiver",	1039	.name = "Siano Mobile Digital MDTV Receiver",
1040	.frequency_min = 44250000,	1040	.frequency_min = 44250000,
1041	.frequency_max = 867250000,	1041	.frequency_max = 867250000,
1042	.frequency_stepsize = 250000,	1042	.frequency_stepsize = 250000,
1043	.caps = FE_CAN_INVERSION_AUTO \|	1043	.caps = FE_CAN_INVERSION_AUTO \|
1044	FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|	1044	FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
1045	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|	1045	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
1046	FE_CAN_QPSK \| FE_CAN_QAM_16 \| FE_CAN_QAM_64 \|	1046	FE_CAN_QPSK \| FE_CAN_QAM_16 \| FE_CAN_QAM_64 \|
1047	FE_CAN_QAM_AUTO \| FE_CAN_TRANSMISSION_MODE_AUTO \|	1047	FE_CAN_QAM_AUTO \| FE_CAN_TRANSMISSION_MODE_AUTO \|
1048	FE_CAN_GUARD_INTERVAL_AUTO \|	1048	FE_CAN_GUARD_INTERVAL_AUTO \|
1049	FE_CAN_RECOVER \|	1049	FE_CAN_RECOVER \|
1050	FE_CAN_HIERARCHY_AUTO,	1050	FE_CAN_HIERARCHY_AUTO,
1051	},	1051	},
1052		1052
1053	.release = smsdvb_release,	1053	.release = smsdvb_release,
1054		1054
1055	.set_frontend = smsdvb_set_frontend,	1055	.set_frontend = smsdvb_set_frontend,
1056	.get_frontend = smsdvb_get_frontend,	1056	.get_frontend = smsdvb_get_frontend,
1057	.get_tune_settings = smsdvb_get_tune_settings,	1057	.get_tune_settings = smsdvb_get_tune_settings,
1058		1058
1059	.read_status = smsdvb_read_status,	1059	.read_status = smsdvb_read_status,
1060	.read_ber = smsdvb_read_ber,	1060	.read_ber = smsdvb_read_ber,
1061	.read_signal_strength = smsdvb_read_signal_strength,	1061	.read_signal_strength = smsdvb_read_signal_strength,
1062	.read_snr = smsdvb_read_snr,	1062	.read_snr = smsdvb_read_snr,
1063	.read_ucblocks = smsdvb_read_ucblocks,	1063	.read_ucblocks = smsdvb_read_ucblocks,
1064		1064
1065	.init = smsdvb_init,	1065	.init = smsdvb_init,
1066	.sleep = smsdvb_sleep,	1066	.sleep = smsdvb_sleep,
1067	};	1067	};
1068		1068
1069	static int smsdvb_hotplug(struct smscore_device_t *coredev,	1069	static int smsdvb_hotplug(struct smscore_device_t *coredev,
1070	struct device *device, int arrival)	1070	struct device *device, int arrival)
1071	{	1071	{
1072	struct smsclient_params_t params;	1072	struct smsclient_params_t params;
1073	struct smsdvb_client_t *client;	1073	struct smsdvb_client_t *client;
1074	int rc;	1074	int rc;
1075		1075
1076	/* device removal handled by onremove callback */	1076	/* device removal handled by onremove callback */
1077	if (!arrival)	1077	if (!arrival)
1078	return 0;	1078	return 0;
1079	client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL);	1079	client = kzalloc(sizeof(struct smsdvb_client_t), GFP_KERNEL);
1080	if (!client) {	1080	if (!client) {
1081	sms_err("kmalloc() failed");	1081	sms_err("kmalloc() failed");
1082	return -ENOMEM;	1082	return -ENOMEM;
1083	}	1083	}
1084		1084
1085	/* register dvb adapter */	1085	/* register dvb adapter */
1086	rc = dvb_register_adapter(&client->adapter,	1086	rc = dvb_register_adapter(&client->adapter,
1087	sms_get_board(	1087	sms_get_board(
1088	smscore_get_board_id(coredev))->name,	1088	smscore_get_board_id(coredev))->name,
1089	THIS_MODULE, device, adapter_nr);	1089	THIS_MODULE, device, adapter_nr);
1090	if (rc < 0) {	1090	if (rc < 0) {
1091	sms_err("dvb_register_adapter() failed %d", rc);	1091	sms_err("dvb_register_adapter() failed %d", rc);
1092	goto adapter_error;	1092	goto adapter_error;
1093	}	1093	}
1094		1094
1095	/* init dvb demux */	1095	/* init dvb demux */
1096	client->demux.dmx.capabilities = DMX_TS_FILTERING;	1096	client->demux.dmx.capabilities = DMX_TS_FILTERING;
1097	client->demux.filternum = 32; /* todo: nova ??? */	1097	client->demux.filternum = 32; /* todo: nova ??? */
1098	client->demux.feednum = 32;	1098	client->demux.feednum = 32;
1099	client->demux.start_feed = smsdvb_start_feed;	1099	client->demux.start_feed = smsdvb_start_feed;
1100	client->demux.stop_feed = smsdvb_stop_feed;	1100	client->demux.stop_feed = smsdvb_stop_feed;
1101		1101
1102	rc = dvb_dmx_init(&client->demux);	1102	rc = dvb_dmx_init(&client->demux);
1103	if (rc < 0) {	1103	if (rc < 0) {
1104	sms_err("dvb_dmx_init failed %d", rc);	1104	sms_err("dvb_dmx_init failed %d", rc);
1105	goto dvbdmx_error;	1105	goto dvbdmx_error;
1106	}	1106	}
1107		1107
1108	/* init dmxdev */	1108	/* init dmxdev */
1109	client->dmxdev.filternum = 32;	1109	client->dmxdev.filternum = 32;
1110	client->dmxdev.demux = &client->demux.dmx;	1110	client->dmxdev.demux = &client->demux.dmx;
1111	client->dmxdev.capabilities = 0;	1111	client->dmxdev.capabilities = 0;
1112		1112
1113	rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter);	1113	rc = dvb_dmxdev_init(&client->dmxdev, &client->adapter);
1114	if (rc < 0) {	1114	if (rc < 0) {
1115	sms_err("dvb_dmxdev_init failed %d", rc);	1115	sms_err("dvb_dmxdev_init failed %d", rc);
1116	goto dmxdev_error;	1116	goto dmxdev_error;
1117	}	1117	}
1118		1118
1119	/* init and register frontend */	1119	/* init and register frontend */
1120	memcpy(&client->frontend.ops, &smsdvb_fe_ops,	1120	memcpy(&client->frontend.ops, &smsdvb_fe_ops,
1121	sizeof(struct dvb_frontend_ops));	1121	sizeof(struct dvb_frontend_ops));
1122		1122
1123	switch (smscore_get_device_mode(coredev)) {	1123	switch (smscore_get_device_mode(coredev)) {
1124	case DEVICE_MODE_DVBT:	1124	case DEVICE_MODE_DVBT:
1125	case DEVICE_MODE_DVBT_BDA:	1125	case DEVICE_MODE_DVBT_BDA:
1126	client->frontend.ops.delsys[0] = SYS_DVBT;	1126	client->frontend.ops.delsys[0] = SYS_DVBT;
1127	break;	1127	break;
1128	case DEVICE_MODE_ISDBT:	1128	case DEVICE_MODE_ISDBT:
1129	case DEVICE_MODE_ISDBT_BDA:	1129	case DEVICE_MODE_ISDBT_BDA:
1130	client->frontend.ops.delsys[0] = SYS_ISDBT;	1130	client->frontend.ops.delsys[0] = SYS_ISDBT;
1131	break;	1131	break;
1132	}	1132	}
1133		1133
1134	rc = dvb_register_frontend(&client->adapter, &client->frontend);	1134	rc = dvb_register_frontend(&client->adapter, &client->frontend);
1135	if (rc < 0) {	1135	if (rc < 0) {
1136	sms_err("frontend registration failed %d", rc);	1136	sms_err("frontend registration failed %d", rc);
1137	goto frontend_error;	1137	goto frontend_error;
1138	}	1138	}
1139		1139
1140	params.initial_id = 1;	1140	params.initial_id = 1;
1141	params.data_type = MSG_SMS_DVBT_BDA_DATA;	1141	params.data_type = MSG_SMS_DVBT_BDA_DATA;
1142	params.onresponse_handler = smsdvb_onresponse;	1142	params.onresponse_handler = smsdvb_onresponse;
1143	params.onremove_handler = smsdvb_onremove;	1143	params.onremove_handler = smsdvb_onremove;
1144	params.context = client;	1144	params.context = client;
1145		1145
1146	rc = smscore_register_client(coredev, &params, &client->smsclient);	1146	rc = smscore_register_client(coredev, &params, &client->smsclient);
1147	if (rc < 0) {	1147	if (rc < 0) {
1148	sms_err("smscore_register_client() failed %d", rc);	1148	sms_err("smscore_register_client() failed %d", rc);
1149	goto client_error;	1149	goto client_error;
1150	}	1150	}
1151		1151
1152	client->coredev = coredev;	1152	client->coredev = coredev;
1153		1153
1154	init_completion(&client->tune_done);	1154	init_completion(&client->tune_done);
1155	init_completion(&client->stats_done);	1155	init_completion(&client->stats_done);
1156		1156
1157	kmutex_lock(&g_smsdvb_clientslock);	1157	kmutex_lock(&g_smsdvb_clientslock);
1158		1158
1159	list_add(&client->entry, &g_smsdvb_clients);	1159	list_add(&client->entry, &g_smsdvb_clients);
1160		1160
1161	kmutex_unlock(&g_smsdvb_clientslock);	1161	kmutex_unlock(&g_smsdvb_clientslock);
1162		1162
1163	client->event_fe_state = -1;	1163	client->event_fe_state = -1;
1164	client->event_unc_state = -1;	1164	client->event_unc_state = -1;
1165	sms_board_dvb3_event(client, DVB3_EVENT_HOTPLUG);	1165	sms_board_dvb3_event(client, DVB3_EVENT_HOTPLUG);
1166		1166
1167	sms_info("success");	1167	sms_info("success");
1168	sms_board_setup(coredev);	1168	sms_board_setup(coredev);
1169		1169
1170	if (smsdvb_debugfs_create(client) < 0)	1170	if (smsdvb_debugfs_create(client) < 0)
1171	sms_info("failed to create debugfs node");	1171	sms_info("failed to create debugfs node");
1172		1172
1173	return 0;	1173	return 0;
1174		1174
1175	client_error:	1175	client_error:
1176	dvb_unregister_frontend(&client->frontend);	1176	dvb_unregister_frontend(&client->frontend);
1177		1177
1178	frontend_error:	1178	frontend_error:
1179	dvb_dmxdev_release(&client->dmxdev);	1179	dvb_dmxdev_release(&client->dmxdev);
1180		1180
1181	dmxdev_error:	1181	dmxdev_error:
1182	dvb_dmx_release(&client->demux);	1182	dvb_dmx_release(&client->demux);
1183		1183
1184	dvbdmx_error:	1184	dvbdmx_error:
1185	dvb_unregister_adapter(&client->adapter);	1185	dvb_unregister_adapter(&client->adapter);
1186		1186
1187	adapter_error:	1187	adapter_error:
1188	kfree(client);	1188	kfree(client);
1189	return rc;	1189	return rc;
1190	}	1190	}
1191		1191
1192	static int __init smsdvb_module_init(void)	1192	static int __init smsdvb_module_init(void)
1193	{	1193	{
1194	int rc;	1194	int rc;
1195		1195
1196	INIT_LIST_HEAD(&g_smsdvb_clients);	1196	INIT_LIST_HEAD(&g_smsdvb_clients);
1197	kmutex_init(&g_smsdvb_clientslock);	1197	kmutex_init(&g_smsdvb_clientslock);
1198		1198
1199	smsdvb_debugfs_register();	1199	smsdvb_debugfs_register();
1200		1200
1201	rc = smscore_register_hotplug(smsdvb_hotplug);	1201	rc = smscore_register_hotplug(smsdvb_hotplug);
1202		1202
1203	sms_debug("");	1203	sms_debug("");
1204		1204
1205	return rc;	1205	return rc;
1206	}	1206	}
1207		1207
1208	static void __exit smsdvb_module_exit(void)	1208	static void __exit smsdvb_module_exit(void)
1209	{	1209	{
1210	smscore_unregister_hotplug(smsdvb_hotplug);	1210	smscore_unregister_hotplug(smsdvb_hotplug);
1211		1211
1212	kmutex_lock(&g_smsdvb_clientslock);	1212	kmutex_lock(&g_smsdvb_clientslock);
1213		1213
1214	while (!list_empty(&g_smsdvb_clients))	1214	while (!list_empty(&g_smsdvb_clients))
1215	smsdvb_unregister_client((struct smsdvb_client_t *)g_smsdvb_clients.next);	1215	smsdvb_unregister_client((struct smsdvb_client_t *)g_smsdvb_clients.next);
1216		1216
1217	smsdvb_debugfs_unregister();	1217	smsdvb_debugfs_unregister();
1218		1218
1219	kmutex_unlock(&g_smsdvb_clientslock);	1219	kmutex_unlock(&g_smsdvb_clientslock);
1220	}	1220	}
1221		1221
1222	module_init(smsdvb_module_init);	1222	module_init(smsdvb_module_init);
1223	module_exit(smsdvb_module_exit);	1223	module_exit(smsdvb_module_exit);
1224		1224
1225	MODULE_DESCRIPTION("SMS DVB subsystem adaptation module");	1225	MODULE_DESCRIPTION("SMS DVB subsystem adaptation module");
1226	MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");	1226	MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");
1227	MODULE_LICENSE("GPL");	1227	MODULE_LICENSE("GPL");
1228		1228

drivers/media/common/siano/smsdvb.h

Diff comments View file @ 28a59df

1	/***********************************************************************	1	/***********************************************************************
2	*	2	*
3	* This program is free software: you can redistribute it and/or modify	3	* This program is free software: you can redistribute it and/or modify
4	* it under the terms of the GNU General Public License as published by	4	* it under the terms of the GNU General Public License as published by
5	* the Free Software Foundation, either version 2 of the License, or	5	* the Free Software Foundation, either version 2 of the License, or
6	* (at your option) any later version.	6	* (at your option) any later version.
7		7
8	* This program is distributed in the hope that it will be useful,	8	* This program is distributed in the hope that it will be useful,
9	* but WITHOUT ANY WARRANTY; without even the implied warranty of	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11	* GNU General Public License for more details.	11	* GNU General Public License for more details.
12	*	12	*
13	* You should have received a copy of the GNU General Public License	13	* You should have received a copy of the GNU General Public License
14	* along with this program. If not, see <http://www.gnu.org/licenses/>.	14	* along with this program. If not, see <http://www.gnu.org/licenses/>.
15	*	15	*
16	***********************************************************************/	16	***********************************************************************/
17		17
18	struct smsdvb_debugfs;	18	struct smsdvb_debugfs;
19	struct smsdvb_client_t;	19	struct smsdvb_client_t;
20		20
21	typedef void (sms_prt_dvb_stats_t)(struct smsdvb_debugfs debug_data,	21	typedef void (sms_prt_dvb_stats_t)(struct smsdvb_debugfs debug_data,
22	struct sms_stats *p);	22	struct sms_stats *p);
23		23
24	typedef void (sms_prt_isdb_stats_t)(struct smsdvb_debugfs debug_data,	24	typedef void (sms_prt_isdb_stats_t)(struct smsdvb_debugfs debug_data,
25	struct sms_isdbt_stats *p);	25	struct sms_isdbt_stats *p);
26		26
27	typedef void (*sms_prt_isdb_stats_ex_t)	27	typedef void (*sms_prt_isdb_stats_ex_t)
28	(struct smsdvb_debugfs *debug_data,	28	(struct smsdvb_debugfs *debug_data,
29	struct sms_isdbt_stats_ex *p);	29	struct sms_isdbt_stats_ex *p);
30		30
31		31
32	struct smsdvb_client_t {	32	struct smsdvb_client_t {
33	struct list_head entry;	33	struct list_head entry;
34		34
35	struct smscore_device_t *coredev;	35	struct smscore_device_t *coredev;
36	struct smscore_client_t *smsclient;	36	struct smscore_client_t *smsclient;
37		37
38	struct dvb_adapter adapter;	38	struct dvb_adapter adapter;
39	struct dvb_demux demux;	39	struct dvb_demux demux;
40	struct dmxdev dmxdev;	40	struct dmxdev dmxdev;
41	struct dvb_frontend frontend;	41	struct dvb_frontend frontend;
42		42
43	fe_status_t fe_status;	43	fe_status_t fe_status;
44		44
45	struct completion tune_done;	45	struct completion tune_done;
46	struct completion stats_done;	46	struct completion stats_done;
47		47
48	int last_per;	48	int last_per;
49		49
50	int legacy_ber, legacy_per;	50	int legacy_ber, legacy_per;
51		51
52	int event_fe_state;	52	int event_fe_state;
53	int event_unc_state;	53	int event_unc_state;
54		54
55	unsigned long get_stats_jiffies;	55	unsigned long get_stats_jiffies;
56		56
57	int feed_users;	57	int feed_users;
58	bool has_tuned;	58	bool has_tuned;
59		59
60	/* stats debugfs data */	60	/* stats debugfs data */
61	struct dentry *debugfs;	61	struct dentry *debugfs;
62		62
63	struct smsdvb_debugfs *debug_data;	63	struct smsdvb_debugfs *debug_data;
64		64
65	sms_prt_dvb_stats_t prt_dvb_stats;	65	sms_prt_dvb_stats_t prt_dvb_stats;
66	sms_prt_isdb_stats_t prt_isdb_stats;	66	sms_prt_isdb_stats_t prt_isdb_stats;
67	sms_prt_isdb_stats_ex_t prt_isdb_stats_ex;	67	sms_prt_isdb_stats_ex_t prt_isdb_stats_ex;
68	};	68	};
69		69
70	/*	70	/*
71	* This struct is a mix of struct sms_rx_stats_ex and	71	* This struct is a mix of struct sms_rx_stats_ex and
72	* struct sms_srvm_signal_status.	72	* struct sms_srvm_signal_status.
73	* It was obtained by comparing the way it was filled by the original code	73	* It was obtained by comparing the way it was filled by the original code
74	*/	74	*/
75	struct RECEPTION_STATISTICS_PER_SLICES_S {	75	struct RECEPTION_STATISTICS_PER_SLICES_S {
76	u32 result;	76	u32 result;
77	u32 snr;	77	u32 snr;
78	s32 in_band_power;	78	s32 in_band_power;
79	u32 ts_packets;	79	u32 ts_packets;
80	u32 ets_packets;	80	u32 ets_packets;
81	u32 constellation;	81	u32 constellation;
82	u32 hp_code;	82	u32 hp_code;
83	u32 tps_srv_ind_lp;	83	u32 tps_srv_ind_lp;
84	u32 tps_srv_ind_hp;	84	u32 tps_srv_ind_hp;
85	u32 cell_id;	85	u32 cell_id;
86	u32 reason;	86	u32 reason;
87	u32 request_id;	87	u32 request_id;
88	u32 modem_state; /* from SMSHOSTLIB_DVB_MODEM_STATE_ET */	88	u32 modem_state; /* from SMSHOSTLIB_DVB_MODEM_STATE_ET */
89		89
90	u32 BER; /* Post Viterbi BER [1E-5] */	90	u32 ber; /* Post Viterbi BER [1E-5] */
91	s32 RSSI; /* dBm */	91	s32 RSSI; /* dBm */
92	s32 carrier_offset; /* Carrier Offset in bin/1024 */	92	s32 carrier_offset; /* Carrier Offset in bin/1024 */
93		93
94	u32 is_rf_locked; /* 0 - not locked, 1 - locked */	94	u32 is_rf_locked; /* 0 - not locked, 1 - locked */
95	u32 is_demod_locked; /* 0 - not locked, 1 - locked */	95	u32 is_demod_locked; /* 0 - not locked, 1 - locked */
96		96
97	u32 ber_bit_count; /* Total number of SYNC bits. */	97	u32 ber_bit_count; /* Total number of SYNC bits. */
98	u32 ber_error_count; /* Number of erronous SYNC bits. */	98	u32 ber_error_count; /* Number of erronous SYNC bits. */
99		99
100	s32 MRC_SNR; /* dB */	100	s32 MRC_SNR; /* dB */
101	s32 mrc_in_band_pwr; /* In band power in dBM */	101	s32 mrc_in_band_pwr; /* In band power in dBM */
102	s32 MRC_RSSI; /* dBm */	102	s32 MRC_RSSI; /* dBm */
103	};	103	};
104		104
105	/* From smsdvb-debugfs.c */	105	/* From smsdvb-debugfs.c */
106	#ifdef CONFIG_SMS_SIANO_DEBUGFS	106	#ifdef CONFIG_SMS_SIANO_DEBUGFS
107		107
108	int smsdvb_debugfs_create(struct smsdvb_client_t *client);	108	int smsdvb_debugfs_create(struct smsdvb_client_t *client);
109	void smsdvb_debugfs_release(struct smsdvb_client_t *client);	109	void smsdvb_debugfs_release(struct smsdvb_client_t *client);
110	int smsdvb_debugfs_register(void);	110	int smsdvb_debugfs_register(void);
111	void smsdvb_debugfs_unregister(void);	111	void smsdvb_debugfs_unregister(void);
112		112
113	#else	113	#else
114		114
115	static inline int smsdvb_debugfs_create(struct smsdvb_client_t *client)	115	static inline int smsdvb_debugfs_create(struct smsdvb_client_t *client)
116	{	116	{
117	return 0;	117	return 0;
118	}	118	}
119		119
120	static inline void smsdvb_debugfs_release(struct smsdvb_client_t *client) {}	120	static inline void smsdvb_debugfs_release(struct smsdvb_client_t *client) {}
121		121
122	static inline int smsdvb_debugfs_register(void)	122	static inline int smsdvb_debugfs_register(void)
123	{	123	{
124	return 0;	124	return 0;
125	};	125	};
126		126
127	static inline void smsdvb_debugfs_unregister(void) {};	127	static inline void smsdvb_debugfs_unregister(void) {};
128		128
129	#endif	129	#endif
130		130
131		131

drivers/media/common/siano/smsendian.c

Diff comments View file @ 28a59df

1	/****************************************************************	1	/****************************************************************
2		2
3	Siano Mobile Silicon, Inc.	3	Siano Mobile Silicon, Inc.
4	MDTV receiver kernel modules.	4	MDTV receiver kernel modules.
5	Copyright (C) 2006-2009, Uri Shkolnik	5	Copyright (C) 2006-2009, Uri Shkolnik
6		6
7	This program is free software: you can redistribute it and/or modify	7	This program is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation, either version 2 of the License, or	9	the Free Software Foundation, either version 2 of the License, or
10	(at your option) any later version.	10	(at your option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	15	GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>.	18	along with this program. If not, see <http://www.gnu.org/licenses/>.
19		19
20	****************************************************************/	20	****************************************************************/
21		21
22	#include <linux/export.h>	22	#include <linux/export.h>
23	#include <asm/byteorder.h>	23	#include <asm/byteorder.h>
24		24
25	#include "smsendian.h"	25	#include "smsendian.h"
26	#include "smscoreapi.h"	26	#include "smscoreapi.h"
27		27
28	void smsendian_handle_tx_message(void *buffer)	28	void smsendian_handle_tx_message(void *buffer)
29	{	29	{
30	#ifdef __BIG_ENDIAN	30	#ifdef __BIG_ENDIAN
31	struct sms_msg_data msg = (struct sms_msg_data )buffer;	31	struct sms_msg_data msg = (struct sms_msg_data )buffer;
32	int i;	32	int i;
33	int msgWords;	33	int msg_words;
34		34
35	switch (msg->x_msg_header.msg_type) {	35	switch (msg->x_msg_header.msg_type) {
36	case MSG_SMS_DATA_DOWNLOAD_REQ:	36	case MSG_SMS_DATA_DOWNLOAD_REQ:
37	{	37	{
38	msg->msgData[0] = le32_to_cpu(msg->msgData[0]);	38	msg->msg_data[0] = le32_to_cpu(msg->msg_data[0]);
39	break;	39	break;
40	}	40	}
41		41
42	default:	42	default:
43	msgWords = (msg->x_msg_header.msg_length -	43	msg_words = (msg->x_msg_header.msg_length -
44	sizeof(struct sms_msg_hdr))/4;	44	sizeof(struct sms_msg_hdr))/4;
45		45
46	for (i = 0; i < msgWords; i++)	46	for (i = 0; i < msg_words; i++)
47	msg->msgData[i] = le32_to_cpu(msg->msgData[i]);	47	msg->msg_data[i] = le32_to_cpu(msg->msg_data[i]);
48		48
49	break;	49	break;
50	}	50	}
51	#endif /* __BIG_ENDIAN */	51	#endif /* __BIG_ENDIAN */
52	}	52	}
53	EXPORT_SYMBOL_GPL(smsendian_handle_tx_message);	53	EXPORT_SYMBOL_GPL(smsendian_handle_tx_message);
54		54
55	void smsendian_handle_rx_message(void *buffer)	55	void smsendian_handle_rx_message(void *buffer)
56	{	56	{
57	#ifdef __BIG_ENDIAN	57	#ifdef __BIG_ENDIAN
58	struct sms_msg_data msg = (struct sms_msg_data )buffer;	58	struct sms_msg_data msg = (struct sms_msg_data )buffer;
59	int i;	59	int i;
60	int msgWords;	60	int msg_words;
61		61
62	switch (msg->x_msg_header.msg_type) {	62	switch (msg->x_msg_header.msg_type) {
63	case MSG_SMS_GET_VERSION_EX_RES:	63	case MSG_SMS_GET_VERSION_EX_RES:
64	{	64	{
65	struct sms_version_res *ver =	65	struct sms_version_res *ver =
66	(struct sms_version_res *) msg;	66	(struct sms_version_res *) msg;
67	ver->chip_model = le16_to_cpu(ver->chip_model);	67	ver->chip_model = le16_to_cpu(ver->chip_model);
68	break;	68	break;
69	}	69	}
70		70
71	case MSG_SMS_DVBT_BDA_DATA:	71	case MSG_SMS_DVBT_BDA_DATA:
72	case MSG_SMS_DAB_CHANNEL:	72	case MSG_SMS_DAB_CHANNEL:
73	case MSG_SMS_DATA_MSG:	73	case MSG_SMS_DATA_MSG:
74	{	74	{
75	break;	75	break;
76	}	76	}
77		77
78	default:	78	default:
79	{	79	{
80	msgWords = (msg->x_msg_header.msg_length -	80	msg_words = (msg->x_msg_header.msg_length -
81	sizeof(struct sms_msg_hdr))/4;	81	sizeof(struct sms_msg_hdr))/4;
82		82
83	for (i = 0; i < msgWords; i++)	83	for (i = 0; i < msg_words; i++)
84	msg->msgData[i] = le32_to_cpu(msg->msgData[i]);	84	msg->msg_data[i] = le32_to_cpu(msg->msg_data[i]);
85		85
86	break;	86	break;
87	}	87	}
88	}	88	}
89	#endif /* __BIG_ENDIAN */	89	#endif /* __BIG_ENDIAN */
90	}	90	}
91	EXPORT_SYMBOL_GPL(smsendian_handle_rx_message);	91	EXPORT_SYMBOL_GPL(smsendian_handle_rx_message);
92		92
93	void smsendian_handle_message_header(void *msg)	93	void smsendian_handle_message_header(void *msg)
94	{	94	{
95	#ifdef __BIG_ENDIAN	95	#ifdef __BIG_ENDIAN
96	struct sms_msg_hdr phdr = (struct sms_msg_hdr )msg;	96	struct sms_msg_hdr phdr = (struct sms_msg_hdr )msg;
97		97
98	phdr->msg_type = le16_to_cpu(phdr->msg_type);	98	phdr->msg_type = le16_to_cpu(phdr->msg_type);
99	phdr->msg_length = le16_to_cpu(phdr->msg_length);	99	phdr->msg_length = le16_to_cpu(phdr->msg_length);
100	phdr->msg_flags = le16_to_cpu(phdr->msg_flags);	100	phdr->msg_flags = le16_to_cpu(phdr->msg_flags);
101	#endif /* __BIG_ENDIAN */	101	#endif /* __BIG_ENDIAN */
102	}	102	}
103	EXPORT_SYMBOL_GPL(smsendian_handle_message_header);	103	EXPORT_SYMBOL_GPL(smsendian_handle_message_header);
104		104

drivers/media/usb/siano/smsusb.c

Diff comments View file @ 28a59df

1	/****************************************************************	1	/****************************************************************
2		2
3	Siano Mobile Silicon, Inc.	3	Siano Mobile Silicon, Inc.
4	MDTV receiver kernel modules.	4	MDTV receiver kernel modules.
5	Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat	5	Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat
6		6
7	This program is free software: you can redistribute it and/or modify	7	This program is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation, either version 2 of the License, or	9	the Free Software Foundation, either version 2 of the License, or
10	(at your option) any later version.	10	(at your option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	15	GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>.	18	along with this program. If not, see <http://www.gnu.org/licenses/>.
19		19
20	****************************************************************/	20	****************************************************************/
21		21
22	#include <linux/kernel.h>	22	#include <linux/kernel.h>
23	#include <linux/init.h>	23	#include <linux/init.h>
24	#include <linux/usb.h>	24	#include <linux/usb.h>
25	#include <linux/firmware.h>	25	#include <linux/firmware.h>
26	#include <linux/slab.h>	26	#include <linux/slab.h>
27	#include <linux/module.h>	27	#include <linux/module.h>
28		28
29	#include "smscoreapi.h"	29	#include "smscoreapi.h"
30	#include "sms-cards.h"	30	#include "sms-cards.h"
31	#include "smsendian.h"	31	#include "smsendian.h"
32		32
33	static int sms_dbg;	33	static int sms_dbg;
34	module_param_named(debug, sms_dbg, int, 0644);	34	module_param_named(debug, sms_dbg, int, 0644);
35	MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");	35	MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
36		36
37	#define USB1_BUFFER_SIZE 0x1000	37	#define USB1_BUFFER_SIZE 0x1000
38	#define USB2_BUFFER_SIZE 0x2000	38	#define USB2_BUFFER_SIZE 0x2000
39		39
40	#define MAX_BUFFERS 50	40	#define MAX_BUFFERS 50
41	#define MAX_URBS 10	41	#define MAX_URBS 10
42		42
43	struct smsusb_device_t;	43	struct smsusb_device_t;
44		44
45	enum smsusb_state {	45	enum smsusb_state {
46	SMSUSB_DISCONNECTED,	46	SMSUSB_DISCONNECTED,
47	SMSUSB_SUSPENDED,	47	SMSUSB_SUSPENDED,
48	SMSUSB_ACTIVE	48	SMSUSB_ACTIVE
49	};	49	};
50		50
51	struct smsusb_urb_t {	51	struct smsusb_urb_t {
52	struct list_head entry;	52	struct list_head entry;
53	struct smscore_buffer_t *cb;	53	struct smscore_buffer_t *cb;
54	struct smsusb_device_t *dev;	54	struct smsusb_device_t *dev;
55		55
56	struct urb urb;	56	struct urb urb;
57	};	57	};
58		58
59	struct smsusb_device_t {	59	struct smsusb_device_t {
60	struct usb_device *udev;	60	struct usb_device *udev;
61	struct smscore_device_t *coredev;	61	struct smscore_device_t *coredev;
62		62
63	struct smsusb_urb_t surbs[MAX_URBS];	63	struct smsusb_urb_t surbs[MAX_URBS];
64		64
65	int response_alignment;	65	int response_alignment;
66	int buffer_size;	66	int buffer_size;
67		67
68	unsigned char in_ep;	68	unsigned char in_ep;
69	unsigned char out_ep;	69	unsigned char out_ep;
70	enum smsusb_state state;	70	enum smsusb_state state;
71	};	71	};
72		72
73	static int smsusb_submit_urb(struct smsusb_device_t *dev,	73	static int smsusb_submit_urb(struct smsusb_device_t *dev,
74	struct smsusb_urb_t *surb);	74	struct smsusb_urb_t *surb);
75		75
76	/**	76	/**
77	* Completing URB's callback handler - top half (interrupt context)	77	* Completing URB's callback handler - top half (interrupt context)
78	* adds completing sms urb to the global surbs list and activtes the worker	78	* adds completing sms urb to the global surbs list and activtes the worker
79	* thread the surb	79	* thread the surb
80	* IMPORTANT - blocking functions must not be called from here !!!	80	* IMPORTANT - blocking functions must not be called from here !!!
81		81
82	* @param urb pointer to a completing urb object	82	* @param urb pointer to a completing urb object
83	*/	83	*/
84	static void smsusb_onresponse(struct urb *urb)	84	static void smsusb_onresponse(struct urb *urb)
85	{	85	{
86	struct smsusb_urb_t surb = (struct smsusb_urb_t ) urb->context;	86	struct smsusb_urb_t surb = (struct smsusb_urb_t ) urb->context;
87	struct smsusb_device_t *dev = surb->dev;	87	struct smsusb_device_t *dev = surb->dev;
88		88
89	if (urb->status == -ESHUTDOWN) {	89	if (urb->status == -ESHUTDOWN) {
90	sms_err("error, urb status %d (-ESHUTDOWN), %d bytes",	90	sms_err("error, urb status %d (-ESHUTDOWN), %d bytes",
91	urb->status, urb->actual_length);	91	urb->status, urb->actual_length);
92	return;	92	return;
93	}	93	}
94		94
95	if ((urb->actual_length > 0) && (urb->status == 0)) {	95	if ((urb->actual_length > 0) && (urb->status == 0)) {
96	struct sms_msg_hdr phdr = (struct sms_msg_hdr )surb->cb->p;	96	struct sms_msg_hdr phdr = (struct sms_msg_hdr )surb->cb->p;
97		97
98	smsendian_handle_message_header(phdr);	98	smsendian_handle_message_header(phdr);
99	if (urb->actual_length >= phdr->msg_length) {	99	if (urb->actual_length >= phdr->msg_length) {
100	surb->cb->size = phdr->msg_length;	100	surb->cb->size = phdr->msg_length;
101		101
102	if (dev->response_alignment &&	102	if (dev->response_alignment &&
103	(phdr->msg_flags & MSG_HDR_FLAG_SPLIT_MSG)) {	103	(phdr->msg_flags & MSG_HDR_FLAG_SPLIT_MSG)) {
104		104
105	surb->cb->offset =	105	surb->cb->offset =
106	dev->response_alignment +	106	dev->response_alignment +
107	((phdr->msg_flags >> 8) & 3);	107	((phdr->msg_flags >> 8) & 3);
108		108
109	/* sanity check */	109	/* sanity check */
110	if (((int) phdr->msg_length +	110	if (((int) phdr->msg_length +
111	surb->cb->offset) > urb->actual_length) {	111	surb->cb->offset) > urb->actual_length) {
112	sms_err("invalid response "	112	sms_err("invalid response "
113	"msglen %d offset %d "	113	"msglen %d offset %d "
114	"size %d",	114	"size %d",
115	phdr->msg_length,	115	phdr->msg_length,
116	surb->cb->offset,	116	surb->cb->offset,
117	urb->actual_length);	117	urb->actual_length);
118	goto exit_and_resubmit;	118	goto exit_and_resubmit;
119	}	119	}
120		120
121	/* move buffer pointer and	121	/* move buffer pointer and
122	* copy header to its new location */	122	* copy header to its new location */
123	memcpy((char *) phdr + surb->cb->offset,	123	memcpy((char *) phdr + surb->cb->offset,
124	phdr, sizeof(struct sms_msg_hdr));	124	phdr, sizeof(struct sms_msg_hdr));
125	} else	125	} else
126	surb->cb->offset = 0;	126	surb->cb->offset = 0;
127		127
128	sms_debug("received %s(%d) size: %d",	128	sms_debug("received %s(%d) size: %d",
129	smscore_translate_msg(phdr->msg_type),	129	smscore_translate_msg(phdr->msg_type),
130	phdr->msg_type, phdr->msg_length);	130	phdr->msg_type, phdr->msg_length);
131		131
132	smsendian_handle_rx_message((struct sms_msg_data *) phdr);	132	smsendian_handle_rx_message((struct sms_msg_data *) phdr);
133		133
134	smscore_onresponse(dev->coredev, surb->cb);	134	smscore_onresponse(dev->coredev, surb->cb);
135	surb->cb = NULL;	135	surb->cb = NULL;
136	} else {	136	} else {
137	sms_err("invalid response "	137	sms_err("invalid response "
138	"msglen %d actual %d",	138	"msglen %d actual %d",
139	phdr->msg_length, urb->actual_length);	139	phdr->msg_length, urb->actual_length);
140	}	140	}
141	} else	141	} else
142	sms_err("error, urb status %d, %d bytes",	142	sms_err("error, urb status %d, %d bytes",
143	urb->status, urb->actual_length);	143	urb->status, urb->actual_length);
144		144
145		145
146	exit_and_resubmit:	146	exit_and_resubmit:
147	smsusb_submit_urb(dev, surb);	147	smsusb_submit_urb(dev, surb);
148	}	148	}
149		149
150	static int smsusb_submit_urb(struct smsusb_device_t *dev,	150	static int smsusb_submit_urb(struct smsusb_device_t *dev,
151	struct smsusb_urb_t *surb)	151	struct smsusb_urb_t *surb)
152	{	152	{
153	if (!surb->cb) {	153	if (!surb->cb) {
154	surb->cb = smscore_getbuffer(dev->coredev);	154	surb->cb = smscore_getbuffer(dev->coredev);
155	if (!surb->cb) {	155	if (!surb->cb) {
156	sms_err("smscore_getbuffer(...) returned NULL");	156	sms_err("smscore_getbuffer(...) returned NULL");
157	return -ENOMEM;	157	return -ENOMEM;
158	}	158	}
159	}	159	}
160		160
161	usb_fill_bulk_urb(	161	usb_fill_bulk_urb(
162	&surb->urb,	162	&surb->urb,
163	dev->udev,	163	dev->udev,
164	usb_rcvbulkpipe(dev->udev, dev->in_ep),	164	usb_rcvbulkpipe(dev->udev, dev->in_ep),
165	surb->cb->p,	165	surb->cb->p,
166	dev->buffer_size,	166	dev->buffer_size,
167	smsusb_onresponse,	167	smsusb_onresponse,
168	surb	168	surb
169	);	169	);
170	surb->urb.transfer_dma = surb->cb->phys;	170	surb->urb.transfer_dma = surb->cb->phys;
171	surb->urb.transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;	171	surb->urb.transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
172		172
173	return usb_submit_urb(&surb->urb, GFP_ATOMIC);	173	return usb_submit_urb(&surb->urb, GFP_ATOMIC);
174	}	174	}
175		175
176	static void smsusb_stop_streaming(struct smsusb_device_t *dev)	176	static void smsusb_stop_streaming(struct smsusb_device_t *dev)
177	{	177	{
178	int i;	178	int i;
179		179
180	for (i = 0; i < MAX_URBS; i++) {	180	for (i = 0; i < MAX_URBS; i++) {
181	usb_kill_urb(&dev->surbs[i].urb);	181	usb_kill_urb(&dev->surbs[i].urb);
182		182
183	if (dev->surbs[i].cb) {	183	if (dev->surbs[i].cb) {
184	smscore_putbuffer(dev->coredev, dev->surbs[i].cb);	184	smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
185	dev->surbs[i].cb = NULL;	185	dev->surbs[i].cb = NULL;
186	}	186	}
187	}	187	}
188	}	188	}
189		189
190	static int smsusb_start_streaming(struct smsusb_device_t *dev)	190	static int smsusb_start_streaming(struct smsusb_device_t *dev)
191	{	191	{
192	int i, rc;	192	int i, rc;
193		193
194	for (i = 0; i < MAX_URBS; i++) {	194	for (i = 0; i < MAX_URBS; i++) {
195	rc = smsusb_submit_urb(dev, &dev->surbs[i]);	195	rc = smsusb_submit_urb(dev, &dev->surbs[i]);
196	if (rc < 0) {	196	if (rc < 0) {
197	sms_err("smsusb_submit_urb(...) failed");	197	sms_err("smsusb_submit_urb(...) failed");
198	smsusb_stop_streaming(dev);	198	smsusb_stop_streaming(dev);
199	break;	199	break;
200	}	200	}
201	}	201	}
202		202
203	return rc;	203	return rc;
204	}	204	}
205		205
206	static int smsusb_sendrequest(void context, void buffer, size_t size)	206	static int smsusb_sendrequest(void context, void buffer, size_t size)
207	{	207	{
208	struct smsusb_device_t dev = (struct smsusb_device_t ) context;	208	struct smsusb_device_t dev = (struct smsusb_device_t ) context;
209	struct sms_msg_hdr phdr = (struct sms_msg_hdr ) buffer;	209	struct sms_msg_hdr phdr = (struct sms_msg_hdr ) buffer;
210	int dummy;	210	int dummy;
211		211
212	if (dev->state != SMSUSB_ACTIVE)	212	if (dev->state != SMSUSB_ACTIVE)
213	return -ENOENT;	213	return -ENOENT;
214		214
215	sms_debug("sending %s(%d) size: %d",	215	sms_debug("sending %s(%d) size: %d",
216	smscore_translate_msg(phdr->msg_type), phdr->msg_type,	216	smscore_translate_msg(phdr->msg_type), phdr->msg_type,
217	phdr->msg_length);	217	phdr->msg_length);
218		218
219	smsendian_handle_tx_message((struct sms_msg_data *) phdr);	219	smsendian_handle_tx_message((struct sms_msg_data *) phdr);
220	smsendian_handle_message_header((struct sms_msg_hdr *)buffer);	220	smsendian_handle_message_header((struct sms_msg_hdr *)buffer);
221	return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),	221	return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
222	buffer, size, &dummy, 1000);	222	buffer, size, &dummy, 1000);
223	}	223	}
224		224
225	static char *smsusb1_fw_lkup[] = {	225	static char *smsusb1_fw_lkup[] = {
226	"dvbt_stellar_usb.inp",	226	"dvbt_stellar_usb.inp",
227	"dvbh_stellar_usb.inp",	227	"dvbh_stellar_usb.inp",
228	"tdmb_stellar_usb.inp",	228	"tdmb_stellar_usb.inp",
229	"none",	229	"none",
230	"dvbt_bda_stellar_usb.inp",	230	"dvbt_bda_stellar_usb.inp",
231	};	231	};
232		232
233	static inline char *sms_get_fw_name(int mode, int board_id)	233	static inline char *sms_get_fw_name(int mode, int board_id)
234	{	234	{
235	char **fw = sms_get_board(board_id)->fw;	235	char **fw = sms_get_board(board_id)->fw;
236	return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];	236	return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];
237	}	237	}
238		238
239	static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)	239	static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)
240	{	240	{
241	const struct firmware *fw;	241	const struct firmware *fw;
242	u8 *fw_buffer;	242	u8 *fw_buffer;
243	int rc, dummy;	243	int rc, dummy;
244	char *fw_filename;	244	char *fw_filename;
245		245
246	if (id < DEVICE_MODE_DVBT \|\| id > DEVICE_MODE_DVBT_BDA) {	246	if (id < DEVICE_MODE_DVBT \|\| id > DEVICE_MODE_DVBT_BDA) {
247	sms_err("invalid firmware id specified %d", id);	247	sms_err("invalid firmware id specified %d", id);
248	return -EINVAL;	248	return -EINVAL;
249	}	249	}
250		250
251	fw_filename = sms_get_fw_name(id, board_id);	251	fw_filename = sms_get_fw_name(id, board_id);
252		252
253	rc = request_firmware(&fw, fw_filename, &udev->dev);	253	rc = request_firmware(&fw, fw_filename, &udev->dev);
254	if (rc < 0) {	254	if (rc < 0) {
255	sms_warn("failed to open \"%s\" mode %d, "	255	sms_warn("failed to open \"%s\" mode %d, "
256	"trying again with default firmware", fw_filename, id);	256	"trying again with default firmware", fw_filename, id);
257		257
258	fw_filename = smsusb1_fw_lkup[id];	258	fw_filename = smsusb1_fw_lkup[id];
259	rc = request_firmware(&fw, fw_filename, &udev->dev);	259	rc = request_firmware(&fw, fw_filename, &udev->dev);
260	if (rc < 0) {	260	if (rc < 0) {
261	sms_warn("failed to open \"%s\" mode %d",	261	sms_warn("failed to open \"%s\" mode %d",
262	fw_filename, id);	262	fw_filename, id);
263		263
264	return rc;	264	return rc;
265	}	265	}
266	}	266	}
267		267
268	fw_buffer = kmalloc(fw->size, GFP_KERNEL);	268	fw_buffer = kmalloc(fw->size, GFP_KERNEL);
269	if (fw_buffer) {	269	if (fw_buffer) {
270	memcpy(fw_buffer, fw->data, fw->size);	270	memcpy(fw_buffer, fw->data, fw->size);
271		271
272	rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),	272	rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
273	fw_buffer, fw->size, &dummy, 1000);	273	fw_buffer, fw->size, &dummy, 1000);
274		274
275	sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);	275	sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);
276		276
277	kfree(fw_buffer);	277	kfree(fw_buffer);
278	} else {	278	} else {
279	sms_err("failed to allocate firmware buffer");	279	sms_err("failed to allocate firmware buffer");
280	rc = -ENOMEM;	280	rc = -ENOMEM;
281	}	281	}
282	sms_info("read FW %s, size=%zd", fw_filename, fw->size);	282	sms_info("read FW %s, size=%zd", fw_filename, fw->size);
283		283
284	release_firmware(fw);	284	release_firmware(fw);
285		285
286	return rc;	286	return rc;
287	}	287	}
288		288
289	static void smsusb1_detectmode(void context, int mode)	289	static void smsusb1_detectmode(void context, int mode)
290	{	290	{
291	char *product_string =	291	char *product_string =
292	((struct smsusb_device_t *) context)->udev->product;	292	((struct smsusb_device_t *) context)->udev->product;
293		293
294	*mode = DEVICE_MODE_NONE;	294	*mode = DEVICE_MODE_NONE;
295		295
296	if (!product_string) {	296	if (!product_string) {
297	product_string = "none";	297	product_string = "none";
298	sms_err("product string not found");	298	sms_err("product string not found");
299	} else if (strstr(product_string, "DVBH"))	299	} else if (strstr(product_string, "DVBH"))
300	*mode = 1;	300	*mode = 1;
301	else if (strstr(product_string, "BDA"))	301	else if (strstr(product_string, "BDA"))
302	*mode = 4;	302	*mode = 4;
303	else if (strstr(product_string, "DVBT"))	303	else if (strstr(product_string, "DVBT"))
304	*mode = 0;	304	*mode = 0;
305	else if (strstr(product_string, "TDMB"))	305	else if (strstr(product_string, "TDMB"))
306	*mode = 2;	306	*mode = 2;
307		307
308	sms_info("%d \"%s\"", *mode, product_string);	308	sms_info("%d \"%s\"", *mode, product_string);
309	}	309	}
310		310
311	static int smsusb1_setmode(void *context, int mode)	311	static int smsusb1_setmode(void *context, int mode)
312	{	312	{
313	struct sms_msg_hdr Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,	313	struct sms_msg_hdr msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
314	sizeof(struct sms_msg_hdr), 0 };	314	sizeof(struct sms_msg_hdr), 0 };
315		315
316	if (mode < DEVICE_MODE_DVBT \|\| mode > DEVICE_MODE_DVBT_BDA) {	316	if (mode < DEVICE_MODE_DVBT \|\| mode > DEVICE_MODE_DVBT_BDA) {
317	sms_err("invalid firmware id specified %d", mode);	317	sms_err("invalid firmware id specified %d", mode);
318	return -EINVAL;	318	return -EINVAL;
319	}	319	}
320		320
321	return smsusb_sendrequest(context, &Msg, sizeof(Msg));	321	return smsusb_sendrequest(context, &msg, sizeof(msg));
322	}	322	}
323		323
324	static void smsusb_term_device(struct usb_interface *intf)	324	static void smsusb_term_device(struct usb_interface *intf)
325	{	325	{
326	struct smsusb_device_t *dev = usb_get_intfdata(intf);	326	struct smsusb_device_t *dev = usb_get_intfdata(intf);
327		327
328	if (dev) {	328	if (dev) {
329	dev->state = SMSUSB_DISCONNECTED;	329	dev->state = SMSUSB_DISCONNECTED;
330		330
331	smsusb_stop_streaming(dev);	331	smsusb_stop_streaming(dev);
332		332
333	/* unregister from smscore */	333	/* unregister from smscore */
334	if (dev->coredev)	334	if (dev->coredev)
335	smscore_unregister_device(dev->coredev);	335	smscore_unregister_device(dev->coredev);
336		336
337	sms_info("device 0x%p destroyed", dev);	337	sms_info("device 0x%p destroyed", dev);
338	kfree(dev);	338	kfree(dev);
339	}	339	}
340		340
341	usb_set_intfdata(intf, NULL);	341	usb_set_intfdata(intf, NULL);
342	}	342	}
343		343
344	static int smsusb_init_device(struct usb_interface *intf, int board_id)	344	static int smsusb_init_device(struct usb_interface *intf, int board_id)
345	{	345	{
346	struct smsdevice_params_t params;	346	struct smsdevice_params_t params;
347	struct smsusb_device_t *dev;	347	struct smsusb_device_t *dev;
348	int i, rc;	348	int i, rc;
349		349
350	/* create device object */	350	/* create device object */
351	dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);	351	dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
352	if (!dev) {	352	if (!dev) {
353	sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");	353	sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");
354	return -ENOMEM;	354	return -ENOMEM;
355	}	355	}
356		356
357	memset(&params, 0, sizeof(params));	357	memset(&params, 0, sizeof(params));
358	usb_set_intfdata(intf, dev);	358	usb_set_intfdata(intf, dev);
359	dev->udev = interface_to_usbdev(intf);	359	dev->udev = interface_to_usbdev(intf);
360	dev->state = SMSUSB_DISCONNECTED;	360	dev->state = SMSUSB_DISCONNECTED;
361		361
362	params.device_type = sms_get_board(board_id)->type;	362	params.device_type = sms_get_board(board_id)->type;
363		363
364	switch (params.device_type) {	364	switch (params.device_type) {
365	case SMS_STELLAR:	365	case SMS_STELLAR:
366	dev->buffer_size = USB1_BUFFER_SIZE;	366	dev->buffer_size = USB1_BUFFER_SIZE;
367		367
368	params.setmode_handler = smsusb1_setmode;	368	params.setmode_handler = smsusb1_setmode;
369	params.detectmode_handler = smsusb1_detectmode;	369	params.detectmode_handler = smsusb1_detectmode;
370	break;	370	break;
371	case SMS_UNKNOWN_TYPE:	371	case SMS_UNKNOWN_TYPE:
372	sms_err("Unspecified sms device type!");	372	sms_err("Unspecified sms device type!");
373	/* fall-thru */	373	/* fall-thru */
374	default:	374	default:
375	dev->buffer_size = USB2_BUFFER_SIZE;	375	dev->buffer_size = USB2_BUFFER_SIZE;
376	dev->response_alignment =	376	dev->response_alignment =
377	le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -	377	le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -
378	sizeof(struct sms_msg_hdr);	378	sizeof(struct sms_msg_hdr);
379		379
380	params.flags \|= SMS_DEVICE_FAMILY2;	380	params.flags \|= SMS_DEVICE_FAMILY2;
381	break;	381	break;
382	}	382	}
383		383
384	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {	384	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
385	if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)	385	if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)
386	dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;	386	dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
387	else	387	else
388	dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;	388	dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
389	}	389	}
390		390
391	sms_info("in_ep = %02x, out_ep = %02x",	391	sms_info("in_ep = %02x, out_ep = %02x",
392	dev->in_ep, dev->out_ep);	392	dev->in_ep, dev->out_ep);
393		393
394	params.device = &dev->udev->dev;	394	params.device = &dev->udev->dev;
395	params.buffer_size = dev->buffer_size;	395	params.buffer_size = dev->buffer_size;
396	params.num_buffers = MAX_BUFFERS;	396	params.num_buffers = MAX_BUFFERS;
397	params.sendrequest_handler = smsusb_sendrequest;	397	params.sendrequest_handler = smsusb_sendrequest;
398	params.context = dev;	398	params.context = dev;
399	usb_make_path(dev->udev, params.devpath, sizeof(params.devpath));	399	usb_make_path(dev->udev, params.devpath, sizeof(params.devpath));
400		400
401	/* register in smscore */	401	/* register in smscore */
402	rc = smscore_register_device(&params, &dev->coredev);	402	rc = smscore_register_device(&params, &dev->coredev);
403	if (rc < 0) {	403	if (rc < 0) {
404	sms_err("smscore_register_device(...) failed, rc %d", rc);	404	sms_err("smscore_register_device(...) failed, rc %d", rc);
405	smsusb_term_device(intf);	405	smsusb_term_device(intf);
406	return rc;	406	return rc;
407	}	407	}
408		408
409	smscore_set_board_id(dev->coredev, board_id);	409	smscore_set_board_id(dev->coredev, board_id);
410		410
411	dev->coredev->is_usb_device = true;	411	dev->coredev->is_usb_device = true;
412		412
413	/* initialize urbs */	413	/* initialize urbs */
414	for (i = 0; i < MAX_URBS; i++) {	414	for (i = 0; i < MAX_URBS; i++) {
415	dev->surbs[i].dev = dev;	415	dev->surbs[i].dev = dev;
416	usb_init_urb(&dev->surbs[i].urb);	416	usb_init_urb(&dev->surbs[i].urb);
417	}	417	}
418		418
419	sms_info("smsusb_start_streaming(...).");	419	sms_info("smsusb_start_streaming(...).");
420	rc = smsusb_start_streaming(dev);	420	rc = smsusb_start_streaming(dev);
421	if (rc < 0) {	421	if (rc < 0) {
422	sms_err("smsusb_start_streaming(...) failed");	422	sms_err("smsusb_start_streaming(...) failed");
423	smsusb_term_device(intf);	423	smsusb_term_device(intf);
424	return rc;	424	return rc;
425	}	425	}
426		426
427	dev->state = SMSUSB_ACTIVE;	427	dev->state = SMSUSB_ACTIVE;
428		428
429	rc = smscore_start_device(dev->coredev);	429	rc = smscore_start_device(dev->coredev);
430	if (rc < 0) {	430	if (rc < 0) {
431	sms_err("smscore_start_device(...) failed");	431	sms_err("smscore_start_device(...) failed");
432	smsusb_term_device(intf);	432	smsusb_term_device(intf);
433	return rc;	433	return rc;
434	}	434	}
435		435
436	sms_info("device 0x%p created", dev);	436	sms_info("device 0x%p created", dev);
437		437
438	return rc;	438	return rc;
439	}	439	}
440		440
441	static int smsusb_probe(struct usb_interface *intf,	441	static int smsusb_probe(struct usb_interface *intf,
442	const struct usb_device_id *id)	442	const struct usb_device_id *id)
443	{	443	{
444	struct usb_device *udev = interface_to_usbdev(intf);	444	struct usb_device *udev = interface_to_usbdev(intf);
445	char devpath[32];	445	char devpath[32];
446	int i, rc;	446	int i, rc;
447		447
448	sms_info("interface number %d",	448	sms_info("interface number %d",
449	intf->cur_altsetting->desc.bInterfaceNumber);	449	intf->cur_altsetting->desc.bInterfaceNumber);
450		450
451	if (sms_get_board(id->driver_info)->intf_num !=	451	if (sms_get_board(id->driver_info)->intf_num !=
452	intf->cur_altsetting->desc.bInterfaceNumber) {	452	intf->cur_altsetting->desc.bInterfaceNumber) {
453	sms_err("interface number is %d expecting %d",	453	sms_err("interface number is %d expecting %d",
454	sms_get_board(id->driver_info)->intf_num,	454	sms_get_board(id->driver_info)->intf_num,
455	intf->cur_altsetting->desc.bInterfaceNumber);	455	intf->cur_altsetting->desc.bInterfaceNumber);
456	return -ENODEV;	456	return -ENODEV;
457	}	457	}
458		458
459	if (intf->num_altsetting > 1) {	459	if (intf->num_altsetting > 1) {
460	rc = usb_set_interface(udev,	460	rc = usb_set_interface(udev,
461	intf->cur_altsetting->desc.bInterfaceNumber,	461	intf->cur_altsetting->desc.bInterfaceNumber,
462	0);	462	0);
463	if (rc < 0) {	463	if (rc < 0) {
464	sms_err("usb_set_interface failed, rc %d", rc);	464	sms_err("usb_set_interface failed, rc %d", rc);
465	return rc;	465	return rc;
466	}	466	}
467	}	467	}
468		468
469	sms_info("smsusb_probe %d",	469	sms_info("smsusb_probe %d",
470	intf->cur_altsetting->desc.bInterfaceNumber);	470	intf->cur_altsetting->desc.bInterfaceNumber);
471	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {	471	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
472	sms_info("endpoint %d %02x %02x %d", i,	472	sms_info("endpoint %d %02x %02x %d", i,
473	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,	473	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
474	intf->cur_altsetting->endpoint[i].desc.bmAttributes,	474	intf->cur_altsetting->endpoint[i].desc.bmAttributes,
475	intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);	475	intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
476	if (intf->cur_altsetting->endpoint[i].desc.bEndpointAddress &	476	if (intf->cur_altsetting->endpoint[i].desc.bEndpointAddress &
477	USB_DIR_IN)	477	USB_DIR_IN)
478	rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev,	478	rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev,
479	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));	479	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
480	else	480	else
481	rc = usb_clear_halt(udev, usb_sndbulkpipe(udev,	481	rc = usb_clear_halt(udev, usb_sndbulkpipe(udev,
482	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));	482	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
483	}	483	}
484	if ((udev->actconfig->desc.bNumInterfaces == 2) &&	484	if ((udev->actconfig->desc.bNumInterfaces == 2) &&
485	(intf->cur_altsetting->desc.bInterfaceNumber == 0)) {	485	(intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
486	sms_err("rom interface 0 is not used");	486	sms_err("rom interface 0 is not used");
487	return -ENODEV;	487	return -ENODEV;
488	}	488	}
489		489
490	if (id->driver_info == SMS1XXX_BOARD_SIANO_STELLAR_ROM) {	490	if (id->driver_info == SMS1XXX_BOARD_SIANO_STELLAR_ROM) {
491	sms_info("stellar device was found.");	491	sms_info("stellar device was found.");
492	snprintf(devpath, sizeof(devpath), "usb\\%d-%s",	492	snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
493	udev->bus->busnum, udev->devpath);	493	udev->bus->busnum, udev->devpath);
494	sms_info("stellar device was found.");	494	sms_info("stellar device was found.");
495	return smsusb1_load_firmware(	495	return smsusb1_load_firmware(
496	udev, smscore_registry_getmode(devpath),	496	udev, smscore_registry_getmode(devpath),
497	id->driver_info);	497	id->driver_info);
498	}	498	}
499		499
500	rc = smsusb_init_device(intf, id->driver_info);	500	rc = smsusb_init_device(intf, id->driver_info);
501	sms_info("rc %d", rc);	501	sms_info("rc %d", rc);
502	sms_board_load_modules(id->driver_info);	502	sms_board_load_modules(id->driver_info);
503	return rc;	503	return rc;
504	}	504	}
505		505
506	static void smsusb_disconnect(struct usb_interface *intf)	506	static void smsusb_disconnect(struct usb_interface *intf)
507	{	507	{
508	smsusb_term_device(intf);	508	smsusb_term_device(intf);
509	}	509	}
510		510
511	static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)	511	static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
512	{	512	{
513	struct smsusb_device_t *dev = usb_get_intfdata(intf);	513	struct smsusb_device_t *dev = usb_get_intfdata(intf);
514	printk(KERN_INFO "%s Entering status %d.\n", __func__, msg.event);	514	printk(KERN_INFO "%s Entering status %d.\n", __func__, msg.event);
515	dev->state = SMSUSB_SUSPENDED;	515	dev->state = SMSUSB_SUSPENDED;
516	/smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);/	516	/smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);/
517	smsusb_stop_streaming(dev);	517	smsusb_stop_streaming(dev);
518	return 0;	518	return 0;
519	}	519	}
520		520
521	static int smsusb_resume(struct usb_interface *intf)	521	static int smsusb_resume(struct usb_interface *intf)
522	{	522	{
523	int rc, i;	523	int rc, i;
524	struct smsusb_device_t *dev = usb_get_intfdata(intf);	524	struct smsusb_device_t *dev = usb_get_intfdata(intf);
525	struct usb_device *udev = interface_to_usbdev(intf);	525	struct usb_device *udev = interface_to_usbdev(intf);
526		526
527	printk(KERN_INFO "%s Entering.\n", __func__);	527	printk(KERN_INFO "%s Entering.\n", __func__);
528	usb_clear_halt(udev, usb_rcvbulkpipe(udev, dev->in_ep));	528	usb_clear_halt(udev, usb_rcvbulkpipe(udev, dev->in_ep));
529	usb_clear_halt(udev, usb_sndbulkpipe(udev, dev->out_ep));	529	usb_clear_halt(udev, usb_sndbulkpipe(udev, dev->out_ep));
530		530
531	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)	531	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
532	printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,	532	printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
533	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,	533	intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
534	intf->cur_altsetting->endpoint[i].desc.bmAttributes,	534	intf->cur_altsetting->endpoint[i].desc.bmAttributes,
535	intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);	535	intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
536		536
537	if (intf->num_altsetting > 0) {	537	if (intf->num_altsetting > 0) {
538	rc = usb_set_interface(udev,	538	rc = usb_set_interface(udev,
539	intf->cur_altsetting->desc.	539	intf->cur_altsetting->desc.
540	bInterfaceNumber, 0);	540	bInterfaceNumber, 0);
541	if (rc < 0) {	541	if (rc < 0) {
542	printk(KERN_INFO "%s usb_set_interface failed, "	542	printk(KERN_INFO "%s usb_set_interface failed, "
543	"rc %d\n", __func__, rc);	543	"rc %d\n", __func__, rc);
544	return rc;	544	return rc;
545	}	545	}
546	}	546	}
547		547
548	smsusb_start_streaming(dev);	548	smsusb_start_streaming(dev);
549	return 0;	549	return 0;
550	}	550	}
551		551
552	static const struct usb_device_id smsusb_id_table[] = {	552	static const struct usb_device_id smsusb_id_table[] = {
553	{ USB_DEVICE(0x187f, 0x0010),	553	{ USB_DEVICE(0x187f, 0x0010),
554	.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },	554	.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
555	{ USB_DEVICE(0x187f, 0x0100),	555	{ USB_DEVICE(0x187f, 0x0100),
556	.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },	556	.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
557	{ USB_DEVICE(0x187f, 0x0200),	557	{ USB_DEVICE(0x187f, 0x0200),
558	.driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },	558	.driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },
559	{ USB_DEVICE(0x187f, 0x0201),	559	{ USB_DEVICE(0x187f, 0x0201),
560	.driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },	560	.driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },
561	{ USB_DEVICE(0x187f, 0x0300),	561	{ USB_DEVICE(0x187f, 0x0300),
562	.driver_info = SMS1XXX_BOARD_SIANO_VEGA },	562	.driver_info = SMS1XXX_BOARD_SIANO_VEGA },
563	{ USB_DEVICE(0x2040, 0x1700),	563	{ USB_DEVICE(0x2040, 0x1700),
564	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },	564	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },
565	{ USB_DEVICE(0x2040, 0x1800),	565	{ USB_DEVICE(0x2040, 0x1800),
566	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },	566	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },
567	{ USB_DEVICE(0x2040, 0x1801),	567	{ USB_DEVICE(0x2040, 0x1801),
568	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },	568	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },
569	{ USB_DEVICE(0x2040, 0x2000),	569	{ USB_DEVICE(0x2040, 0x2000),
570	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },	570	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
571	{ USB_DEVICE(0x2040, 0x2009),	571	{ USB_DEVICE(0x2040, 0x2009),
572	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },	572	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },
573	{ USB_DEVICE(0x2040, 0x200a),	573	{ USB_DEVICE(0x2040, 0x200a),
574	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },	574	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
575	{ USB_DEVICE(0x2040, 0x2010),	575	{ USB_DEVICE(0x2040, 0x2010),
576	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },	576	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
577	{ USB_DEVICE(0x2040, 0x2011),	577	{ USB_DEVICE(0x2040, 0x2011),
578	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },	578	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
579	{ USB_DEVICE(0x2040, 0x2019),	579	{ USB_DEVICE(0x2040, 0x2019),
580	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },	580	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
581	{ USB_DEVICE(0x2040, 0x5500),	581	{ USB_DEVICE(0x2040, 0x5500),
582	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	582	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
583	{ USB_DEVICE(0x2040, 0x5510),	583	{ USB_DEVICE(0x2040, 0x5510),
584	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	584	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
585	{ USB_DEVICE(0x2040, 0x5520),	585	{ USB_DEVICE(0x2040, 0x5520),
586	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	586	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
587	{ USB_DEVICE(0x2040, 0x5530),	587	{ USB_DEVICE(0x2040, 0x5530),
588	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	588	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
589	{ USB_DEVICE(0x2040, 0x5580),	589	{ USB_DEVICE(0x2040, 0x5580),
590	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	590	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
591	{ USB_DEVICE(0x2040, 0x5590),	591	{ USB_DEVICE(0x2040, 0x5590),
592	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	592	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
593	{ USB_DEVICE(0x187f, 0x0202),	593	{ USB_DEVICE(0x187f, 0x0202),
594	.driver_info = SMS1XXX_BOARD_SIANO_NICE },	594	.driver_info = SMS1XXX_BOARD_SIANO_NICE },
595	{ USB_DEVICE(0x187f, 0x0301),	595	{ USB_DEVICE(0x187f, 0x0301),
596	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },	596	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
597	{ USB_DEVICE(0x2040, 0xb900),	597	{ USB_DEVICE(0x2040, 0xb900),
598	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	598	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
599	{ USB_DEVICE(0x2040, 0xb910),	599	{ USB_DEVICE(0x2040, 0xb910),
600	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	600	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
601	{ USB_DEVICE(0x2040, 0xb980),	601	{ USB_DEVICE(0x2040, 0xb980),
602	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	602	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
603	{ USB_DEVICE(0x2040, 0xb990),	603	{ USB_DEVICE(0x2040, 0xb990),
604	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	604	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
605	{ USB_DEVICE(0x2040, 0xc000),	605	{ USB_DEVICE(0x2040, 0xc000),
606	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	606	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
607	{ USB_DEVICE(0x2040, 0xc010),	607	{ USB_DEVICE(0x2040, 0xc010),
608	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	608	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
609	{ USB_DEVICE(0x2040, 0xc080),	609	{ USB_DEVICE(0x2040, 0xc080),
610	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	610	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
611	{ USB_DEVICE(0x2040, 0xc090),	611	{ USB_DEVICE(0x2040, 0xc090),
612	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	612	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
613	{ USB_DEVICE(0x2040, 0xc0a0),	613	{ USB_DEVICE(0x2040, 0xc0a0),
614	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	614	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
615	{ USB_DEVICE(0x2040, 0xf5a0),	615	{ USB_DEVICE(0x2040, 0xf5a0),
616	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },	616	.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
617	{ USB_DEVICE(0x187f, 0x0202),	617	{ USB_DEVICE(0x187f, 0x0202),
618	.driver_info = SMS1XXX_BOARD_SIANO_NICE },	618	.driver_info = SMS1XXX_BOARD_SIANO_NICE },
619	{ USB_DEVICE(0x187f, 0x0301),	619	{ USB_DEVICE(0x187f, 0x0301),
620	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },	620	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
621	{ USB_DEVICE(0x187f, 0x0302),	621	{ USB_DEVICE(0x187f, 0x0302),
622	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },	622	.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
623	{ USB_DEVICE(0x187f, 0x0310),	623	{ USB_DEVICE(0x187f, 0x0310),
624	.driver_info = SMS1XXX_BOARD_SIANO_MING },	624	.driver_info = SMS1XXX_BOARD_SIANO_MING },
625	{ USB_DEVICE(0x187f, 0x0500),	625	{ USB_DEVICE(0x187f, 0x0500),
626	.driver_info = SMS1XXX_BOARD_SIANO_PELE },	626	.driver_info = SMS1XXX_BOARD_SIANO_PELE },
627	{ USB_DEVICE(0x187f, 0x0600),	627	{ USB_DEVICE(0x187f, 0x0600),
628	.driver_info = SMS1XXX_BOARD_SIANO_RIO },	628	.driver_info = SMS1XXX_BOARD_SIANO_RIO },
629	{ USB_DEVICE(0x187f, 0x0700),	629	{ USB_DEVICE(0x187f, 0x0700),
630	.driver_info = SMS1XXX_BOARD_SIANO_DENVER_2160 },	630	.driver_info = SMS1XXX_BOARD_SIANO_DENVER_2160 },
631	{ USB_DEVICE(0x187f, 0x0800),	631	{ USB_DEVICE(0x187f, 0x0800),
632	.driver_info = SMS1XXX_BOARD_SIANO_DENVER_1530 },	632	.driver_info = SMS1XXX_BOARD_SIANO_DENVER_1530 },
633	{ USB_DEVICE(0x19D2, 0x0086),	633	{ USB_DEVICE(0x19D2, 0x0086),
634	.driver_info = SMS1XXX_BOARD_ZTE_DVB_DATA_CARD },	634	.driver_info = SMS1XXX_BOARD_ZTE_DVB_DATA_CARD },
635	{ USB_DEVICE(0x19D2, 0x0078),	635	{ USB_DEVICE(0x19D2, 0x0078),
636	.driver_info = SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD },	636	.driver_info = SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD },
637	{ } /* Terminating entry */	637	{ } /* Terminating entry */
638	};	638	};
639		639
640	MODULE_DEVICE_TABLE(usb, smsusb_id_table);	640	MODULE_DEVICE_TABLE(usb, smsusb_id_table);
641		641
642	static struct usb_driver smsusb_driver = {	642	static struct usb_driver smsusb_driver = {
643	.name = "smsusb",	643	.name = "smsusb",
644	.probe = smsusb_probe,	644	.probe = smsusb_probe,
645	.disconnect = smsusb_disconnect,	645	.disconnect = smsusb_disconnect,
646	.id_table = smsusb_id_table,	646	.id_table = smsusb_id_table,
647		647
648	.suspend = smsusb_suspend,	648	.suspend = smsusb_suspend,
649	.resume = smsusb_resume,	649	.resume = smsusb_resume,
650	};	650	};
651		651
652	module_usb_driver(smsusb_driver);	652	module_usb_driver(smsusb_driver);
653		653
654	MODULE_DESCRIPTION("Driver for the Siano SMS1xxx USB dongle");	654	MODULE_DESCRIPTION("Driver for the Siano SMS1xxx USB dongle");
655	MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");	655	MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
656	MODULE_LICENSE("GPL");	656	MODULE_LICENSE("GPL");
657		657

1	/*	1	/*
2	* Siano core API module	2	* Siano core API module
3	*	3	*
4	* This file contains implementation for the interface to sms core component	4	* This file contains implementation for the interface to sms core component
5	*	5	*
6	* author: Uri Shkolnik	6	* author: Uri Shkolnik
7	*	7	*
8	* Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.	8	* Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License version 2 as	11	* it under the terms of the GNU General Public License version 2 as
12	* published by the Free Software Foundation;	12	* published by the Free Software Foundation;
13	*	13	*
14	* Software distributed under the License is distributed on an "AS IS"	14	* Software distributed under the License is distributed on an "AS IS"
15	* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.	15	* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
16	*	16	*
17	* See the GNU General Public License for more details.	17	* See the GNU General Public License for more details.
18	*	18	*
19	* You should have received a copy of the GNU General Public License	19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software	20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22	*/	22	*/
23		23
24	#include <linux/kernel.h>	24	#include <linux/kernel.h>
25	#include <linux/init.h>	25	#include <linux/init.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
27	#include <linux/moduleparam.h>	27	#include <linux/moduleparam.h>
28	#include <linux/dma-mapping.h>	28	#include <linux/dma-mapping.h>
29	#include <linux/delay.h>	29	#include <linux/delay.h>
30	#include <linux/io.h>	30	#include <linux/io.h>
31	#include <linux/slab.h>	31	#include <linux/slab.h>
32		32
33	#include <linux/firmware.h>	33	#include <linux/firmware.h>
34	#include <linux/wait.h>	34	#include <linux/wait.h>
35	#include <asm/byteorder.h>	35	#include <asm/byteorder.h>
36		36
37	#include "smscoreapi.h"	37	#include "smscoreapi.h"
38	#include "sms-cards.h"	38	#include "sms-cards.h"
39	#include "smsir.h"	39	#include "smsir.h"
40		40