1 /* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
3 * Copyright (C) 2006 Aapo Tahkola (aet@rasterburn.org)
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the Free
7 * Software Foundation, version 2.
9 * see Documentation/dvb/README.dvb-usb for more information
15 #include "mt352_priv.h"
19 static int dvb_usb_m920x_debug
;
20 module_param_named(debug
,dvb_usb_m920x_debug
, int, 0644);
21 MODULE_PARM_DESC(debug
, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS
);
23 static struct dvb_usb_rc_key megasky_rc_keys
[] = {
24 { 0x0, 0x12, KEY_POWER
},
25 { 0x0, 0x1e, KEY_CYCLEWINDOWS
}, /* min/max */
26 { 0x0, 0x02, KEY_CHANNELUP
},
27 { 0x0, 0x05, KEY_CHANNELDOWN
},
28 { 0x0, 0x03, KEY_VOLUMEUP
},
29 { 0x0, 0x06, KEY_VOLUMEDOWN
},
30 { 0x0, 0x04, KEY_MUTE
},
31 { 0x0, 0x07, KEY_OK
}, /* TS */
32 { 0x0, 0x08, KEY_STOP
},
33 { 0x0, 0x09, KEY_MENU
}, /* swap */
34 { 0x0, 0x0a, KEY_REWIND
},
35 { 0x0, 0x1b, KEY_PAUSE
},
36 { 0x0, 0x1f, KEY_FASTFORWARD
},
37 { 0x0, 0x0c, KEY_RECORD
},
38 { 0x0, 0x0d, KEY_CAMERA
}, /* screenshot */
39 { 0x0, 0x0e, KEY_COFFEE
}, /* "MTS" */
42 static inline int m9206_read(struct usb_device
*udev
, u8 request
, u16 value
, u16 index
, void *data
, int size
)
46 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
47 request
, USB_TYPE_VENDOR
| USB_DIR_IN
,
48 value
, index
, data
, size
, 2000);
58 static inline int m9206_write(struct usb_device
*udev
, u8 request
, u16 value
, u16 index
)
62 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
63 request
, USB_TYPE_VENDOR
| USB_DIR_OUT
,
64 value
, index
, NULL
, 0, 2000);
68 static int m9206_rc_init(struct usb_device
*udev
)
72 /* Remote controller init. */
73 if ((ret
= m9206_write(udev
, M9206_CORE
, 0xa8, M9206_RC_INIT2
)) != 0)
76 if ((ret
= m9206_write(udev
, M9206_CORE
, 0x51, M9206_RC_INIT1
)) != 0)
82 static int m9206_rc_query(struct dvb_usb_device
*d
, u32
*event
, int *state
)
84 struct m9206_state
*m
= d
->priv
;
89 if ((ret
= m9206_read(d
->udev
, M9206_CORE
, 0x0, M9206_RC_STATE
, rc_state
, 1)) != 0)
92 if ((ret
= m9206_read(d
->udev
, M9206_CORE
, 0x0, M9206_RC_KEY
, rc_state
+ 1, 1)) != 0)
95 for (i
= 0; i
< ARRAY_SIZE(megasky_rc_keys
); i
++)
96 if (megasky_rc_keys
[i
].data
== rc_state
[1]) {
97 *event
= megasky_rc_keys
[i
].event
;
101 *state
= REMOTE_NO_KEY_PRESSED
;
107 *state
= REMOTE_KEY_PRESSED
;
112 if (++m
->rep_count
> 2)
113 *state
= REMOTE_KEY_REPEAT
;
117 deb_rc("Unexpected rc response %x\n", rc_state
[0]);
118 *state
= REMOTE_NO_KEY_PRESSED
;
123 if (rc_state
[1] != 0)
124 deb_rc("Unknown rc key %x\n", rc_state
[1]);
126 *state
= REMOTE_NO_KEY_PRESSED
;
135 static int m9206_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[], int num
)
137 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
141 /* Need to access d->adapter[0] */
142 if (d
->num_adapters_initialized
!= 1) {
143 deb_rc("Impossible happened!\n");
147 if (mutex_lock_interruptible(&d
->i2c_mutex
) < 0)
153 for (i
= 0; i
< num
; i
++) {
156 if ((ret
= m9206_write(d
->udev
, M9206_I2C
, msg
[i
].addr
, 0x80)) != 0)
159 if ((ret
= m9206_write(d
->udev
, M9206_I2C
, msg
[i
].buf
[0], 0x0)) != 0)
162 if (i
+ 1 < num
&& msg
[i
+ 1].flags
& I2C_M_RD
) {
163 /* Possibly device dependant */
164 if (msg
[i
].addr
== d
->adapter
[0].pll_addr
)
169 if ((ret
= m9206_write(d
->udev
, M9206_I2C
, w_len
, 0x80)) != 0)
172 if ((ret
= m9206_read(d
->udev
, M9206_I2C
, 0x0, 0x60, msg
[i
+ 1].buf
, msg
[i
+ 1].len
)) != 0)
180 if ((ret
= m9206_write(d
->udev
, M9206_I2C
, msg
[i
].buf
[1], 0x40)) != 0)
186 mutex_unlock(&d
->i2c_mutex
);
191 static u32
m9206_i2c_func(struct i2c_adapter
*adapter
)
196 static struct i2c_algorithm m9206_i2c_algo
= {
197 .master_xfer
= m9206_i2c_xfer
,
198 .functionality
= m9206_i2c_func
,
201 /* Callbacks for DVB USB */
202 static int megasky_identify_state(struct usb_device
*udev
,
203 struct dvb_usb_device_properties
*props
,
204 struct dvb_usb_device_description
**desc
,
207 struct usb_host_interface
*alt
;
209 alt
= usb_altnum_to_altsetting(usb_ifnum_to_if(udev
, 0), 1);
210 *cold
= (alt
== NULL
) ? 1 : 0;
215 static int megasky_mt352_demod_init(struct dvb_frontend
*fe
)
217 u8 config
[] = { CONFIG
, 0x3d };
218 u8 clock
[] = { CLOCK_CTL
, 0x30 };
219 u8 reset
[] = { RESET
, 0x80 };
220 u8 adc_ctl
[] = { ADC_CTL_1
, 0x40 };
221 u8 agc
[] = { AGC_TARGET
, 0x1c, 0x20 };
222 u8 sec_agc
[] = { 0x69, 0x00, 0xff, 0xff, 0x40, 0xff, 0x00, 0x40, 0x40 };
223 u8 unk1
[] = { 0x93, 0x1a };
224 u8 unk2
[] = { 0xb5, 0x7a };
226 mt352_write(fe
, config
, ARRAY_SIZE(config
));
227 mt352_write(fe
, clock
, ARRAY_SIZE(clock
));
228 mt352_write(fe
, reset
, ARRAY_SIZE(reset
));
229 mt352_write(fe
, adc_ctl
, ARRAY_SIZE(adc_ctl
));
230 mt352_write(fe
, agc
, ARRAY_SIZE(agc
));
231 mt352_write(fe
, sec_agc
, ARRAY_SIZE(sec_agc
));
232 mt352_write(fe
, unk1
, ARRAY_SIZE(unk1
));
233 mt352_write(fe
, unk2
, ARRAY_SIZE(unk2
));
235 deb_rc("Demod init!\n");
240 static struct mt352_config megasky_mt352_config
= {
241 .demod_address
= 0x1e,
243 .demod_init
= megasky_mt352_demod_init
,
246 static int megasky_frontend_attach(struct dvb_usb_adapter
*adap
)
248 deb_rc("megasky_frontend_attach!\n");
250 if ((adap
->fe
= dvb_attach(mt352_attach
, &megasky_mt352_config
, &adap
->dev
->i2c_adap
)) != NULL
) {
256 static int megasky_tuner_attach(struct dvb_usb_adapter
*adap
)
258 adap
->pll_addr
= 0xc4;
259 adap
->pll_desc
= NULL
;
260 adap
->fe
->ops
.tuner_ops
.set_params
= qt1010_set_params
;
265 static int m9206_set_filter(struct dvb_usb_adapter
*adap
, int type
, int idx
, int pid
)
274 if ((ret
= m9206_write(adap
->dev
->udev
, M9206_FILTER
, pid
, (type
<< 8) | (idx
* 4) )) != 0)
277 if ((ret
= m9206_write(adap
->dev
->udev
, M9206_FILTER
, 0, (type
<< 8) | (idx
* 4) )) != 0)
283 static int m9206_update_filters(struct dvb_usb_adapter
*adap
)
285 struct m9206_state
*m
= adap
->dev
->priv
;
286 int enabled
= m
->filtering_enabled
;
287 int i
, ret
= 0, filter
= 0;
289 for (i
= 0; i
< M9206_MAX_FILTERS
; i
++)
290 if (m
->filters
[i
] == 8192)
293 /* Disable all filters */
294 if ((ret
= m9206_set_filter(adap
, 0x81, 1, enabled
)) != 0)
297 for (i
= 0; i
< M9206_MAX_FILTERS
; i
++)
298 if ((ret
= m9206_set_filter(adap
, 0x81, i
+ 2, 0)) != 0)
301 if ((ret
= m9206_set_filter(adap
, 0x82, 0, 0x0)) != 0)
306 for (i
= 0; i
< M9206_MAX_FILTERS
; i
++) {
307 if (m
->filters
[i
] == 0)
310 if ((ret
= m9206_set_filter(adap
, 0x81, filter
+ 2, m
->filters
[i
])) != 0)
317 if ((ret
= m9206_set_filter(adap
, 0x82, 0, 0x02f5)) != 0)
323 static int m9206_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
325 struct m9206_state
*m
= adap
->dev
->priv
;
327 m
->filtering_enabled
= onoff
? 1 : 0;
329 return m9206_update_filters(adap
);
332 static int m9206_pid_filter(struct dvb_usb_adapter
*adap
, int index
, u16 pid
, int onoff
)
334 struct m9206_state
*m
= adap
->dev
->priv
;
336 m
->filters
[index
] = onoff
? pid
: 0;
338 return m9206_update_filters(adap
);
341 static int m9206_firmware_download(struct usb_device
*udev
, const struct firmware
*fw
)
343 u16 value
, index
, size
;
345 int i
, pass
, ret
= 0;
347 buff
= kmalloc(65536, GFP_KERNEL
);
349 if ((ret
= m9206_read(udev
, M9206_FILTER
, 0x0, 0x8000, read
, 4)) != 0)
351 deb_rc("%x %x %x %x\n", read
[0], read
[1], read
[2], read
[3]);
353 if ((ret
= m9206_read(udev
, M9206_FW
, 0x0, 0x0, read
, 1)) != 0)
355 deb_rc("%x\n", read
[0]);
357 for (pass
= 0; pass
< 2; pass
++) {
358 for (i
= 0; i
+ (sizeof(u16
) * 3) < fw
->size
;) {
359 value
= le16_to_cpu(*(u16
*)(fw
->data
+ i
));
362 index
= le16_to_cpu(*(u16
*)(fw
->data
+ i
));
365 size
= le16_to_cpu(*(u16
*)(fw
->data
+ i
));
369 /* Will stall if using fw->data ... */
370 memcpy(buff
, fw
->data
+ i
, size
);
372 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
,0),
374 USB_TYPE_VENDOR
| USB_DIR_OUT
,
375 value
, index
, buff
, size
, 20);
377 deb_rc("error while uploading fw!\n");
393 /* m9206 will disconnect itself from the bus after this. */
394 (void) m9206_write(udev
, M9206_CORE
, 0x01, M9206_FW_GO
);
395 deb_rc("firmware uploaded!\n");
403 /* DVB USB Driver stuff */
404 static struct dvb_usb_device_properties megasky_properties
;
406 static int m920x_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
408 struct dvb_usb_device
*d
;
409 struct usb_host_interface
*alt
;
412 if ((ret
= dvb_usb_device_init(intf
, &megasky_properties
, THIS_MODULE
, &d
)) == 0) {
415 alt
= usb_altnum_to_altsetting(intf
, 1);
417 deb_rc("not alt found!\n");
421 ret
= usb_set_interface(d
->udev
, alt
->desc
.bInterfaceNumber
, alt
->desc
.bAlternateSetting
);
425 deb_rc("Changed to alternate setting!\n");
427 if ((ret
= m9206_rc_init(d
->udev
)) != 0)
433 static struct usb_device_id m920x_table
[] = {
434 { USB_DEVICE(USB_VID_MSI
, USB_PID_MSI_MEGASKY580
) },
435 { } /* Terminating entry */
437 MODULE_DEVICE_TABLE (usb
, m920x_table
);
439 static struct dvb_usb_device_properties megasky_properties
= {
440 .usb_ctrl
= DEVICE_SPECIFIC
,
441 .firmware
= "dvb-usb-megasky-02.fw",
442 .download_firmware
= m9206_firmware_download
,
445 .rc_key_map
= megasky_rc_keys
,
446 .rc_key_map_size
= ARRAY_SIZE(megasky_rc_keys
),
447 .rc_query
= m9206_rc_query
,
449 .size_of_priv
= sizeof(struct m9206_state
),
451 .identify_state
= megasky_identify_state
,
454 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
| DVB_USB_ADAP_HAS_PID_FILTER
|
455 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
457 .pid_filter_count
= 8,
458 .pid_filter
= m9206_pid_filter
,
459 .pid_filter_ctrl
= m9206_pid_filter_ctrl
,
461 .frontend_attach
= megasky_frontend_attach
,
462 .tuner_attach
= megasky_tuner_attach
,
475 .i2c_algo
= &m9206_i2c_algo
,
477 .generic_bulk_ctrl_endpoint
= 0x01,
479 .num_device_descs
= 1,
481 { "MSI Mega Sky 580 DVB-T USB2.0",
482 { &m920x_table
[0], NULL
},
489 static struct usb_driver m920x_driver
= {
490 .name
= "dvb_usb_m920x",
491 .probe
= m920x_probe
,
492 .disconnect
= dvb_usb_device_exit
,
493 .id_table
= m920x_table
,
497 static int __init
m920x_module_init(void)
501 if ((ret
= usb_register(&m920x_driver
))) {
502 err("usb_register failed. Error number %d", ret
);
509 static void __exit
m920x_module_exit(void)
511 /* deregister this driver from the USB subsystem */
512 usb_deregister(&m920x_driver
);
515 module_init (m920x_module_init
);
516 module_exit (m920x_module_exit
);
518 MODULE_AUTHOR("Aapo Tahkola <aet@rasterburn.org>");
519 MODULE_DESCRIPTION("Driver MSI Mega Sky 580 DVB-T USB2.0 / Uli m920x");
520 MODULE_VERSION("0.1");
521 MODULE_LICENSE("GPL");