// SPDX-License-Identifier: GPL-2.0-or-later /* * Support for OR51132 (pcHDTV HD-3000) - VSB/QAM * * Copyright (C) 2007 Trent Piepho <[email protected]> * * Copyright (C) 2005 Kirk Lapray <[email protected]> * * Based on code from Jack Kelliher ([email protected]) * Copyright (C) 2002 & pcHDTV, inc. */ /* * This driver needs two external firmware files. Please copy * "dvb-fe-or51132-vsb.fw" and "dvb-fe-or51132-qam.fw" to * /usr/lib/hotplug/firmware/ or /lib/firmware/ * (depending on configuration of firmware hotplug). */ #define OR51132_VSB_FIRMWARE … #define OR51132_QAM_FIRMWARE … #include <linux/kernel.h> #include <linux/module.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/string.h> #include <linux/slab.h> #include <asm/byteorder.h> #include <linux/int_log.h> #include <media/dvb_frontend.h> #include "or51132.h" static int debug; #define dprintk(args...) … struct or51132_state { … }; /* Write buffer to demod */ static int or51132_writebuf(struct or51132_state *state, const u8 *buf, int len) { … } /* Write constant bytes, e.g. or51132_writebytes(state, 0x04, 0x42, 0x00); Less code and more efficient that loading a buffer on the stack with the bytes to send and then calling or51132_writebuf() on that. */ #define or51132_writebytes(state, data...) … /* Read data from demod into buffer. Returns 0 on success. */ static int or51132_readbuf(struct or51132_state *state, u8 *buf, int len) { … } /* Reads a 16-bit demod register. Returns <0 on error. */ static int or51132_readreg(struct or51132_state *state, u8 reg) { … } static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware *fw) { struct or51132_state* state = fe->demodulator_priv; static const u8 run_buf[] = {0x7F,0x01}; u8 rec_buf[8]; u32 firmwareAsize, firmwareBsize; int i,ret; dprintk("Firmware is %zd bytes\n",fw->size); /* Get size of firmware A and B */ firmwareAsize = le32_to_cpu(*((__le32*)fw->data)); dprintk("FirmwareA is %i bytes\n",firmwareAsize); firmwareBsize = le32_to_cpu(*((__le32*)(fw->data+4))); dprintk("FirmwareB is %i bytes\n",firmwareBsize); /* Upload firmware */ if ((ret = or51132_writebuf(state, &fw->data[8], firmwareAsize))) { printk(KERN_WARNING "or51132: load_firmware error 1\n"); return ret; } if ((ret = or51132_writebuf(state, &fw->data[8+firmwareAsize], firmwareBsize))) { printk(KERN_WARNING "or51132: load_firmware error 2\n"); return ret; } if ((ret = or51132_writebuf(state, run_buf, 2))) { printk(KERN_WARNING "or51132: load_firmware error 3\n"); return ret; } if ((ret = or51132_writebuf(state, run_buf, 2))) { printk(KERN_WARNING "or51132: load_firmware error 4\n"); return ret; } /* 50ms for operation to begin */ msleep(50); /* Read back ucode version to besure we loaded correctly and are really up and running */ /* Get uCode version */ if ((ret = or51132_writebytes(state, 0x10, 0x10, 0x00))) { printk(KERN_WARNING "or51132: load_firmware error a\n"); return ret; } if ((ret = or51132_writebytes(state, 0x04, 0x17))) { printk(KERN_WARNING "or51132: load_firmware error b\n"); return ret; } if ((ret = or51132_writebytes(state, 0x00, 0x00))) { printk(KERN_WARNING "or51132: load_firmware error c\n"); return ret; } for (i=0;i<4;i++) { /* Once upon a time, this command might have had something to do with getting the firmware version, but it's not used anymore: {0x04,0x00,0x30,0x00,i+1} */ /* Read 8 bytes, two bytes at a time */ if ((ret = or51132_readbuf(state, &rec_buf[i*2], 2))) { printk(KERN_WARNING "or51132: load_firmware error d - %d\n",i); return ret; } } printk(KERN_WARNING "or51132: Version: %02X%02X%02X%02X-%02X%02X%02X%02X (%02X%01X-%01X-%02X%01X-%01X)\n", rec_buf[1],rec_buf[0],rec_buf[3],rec_buf[2], rec_buf[5],rec_buf[4],rec_buf[7],rec_buf[6], rec_buf[3],rec_buf[2]>>4,rec_buf[2]&0x0f, rec_buf[5],rec_buf[4]>>4,rec_buf[4]&0x0f); if ((ret = or51132_writebytes(state, 0x10, 0x00, 0x00))) { printk(KERN_WARNING "or51132: load_firmware error e\n"); return ret; } return 0; }; static int or51132_init(struct dvb_frontend* fe) { … } static int or51132_read_ber(struct dvb_frontend* fe, u32* ber) { … } static int or51132_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks) { … } static int or51132_sleep(struct dvb_frontend* fe) { … } static int or51132_setmode(struct dvb_frontend* fe) { … } /* Some modulations use the same firmware. This classifies modulations by the firmware they use. */ #define MOD_FWCLASS_UNKNOWN … #define MOD_FWCLASS_VSB … #define MOD_FWCLASS_QAM … static int modulation_fw_class(enum fe_modulation modulation) { … } static int or51132_set_parameters(struct dvb_frontend *fe) { … } static int or51132_get_parameters(struct dvb_frontend* fe, struct dtv_frontend_properties *p) { … } static int or51132_read_status(struct dvb_frontend *fe, enum fe_status *status) { … } /* Calculate SNR estimation (scaled by 2^24) 8-VSB SNR and QAM equations from Oren datasheets For 8-VSB: SNR[dB] = 10 * log10(897152044.8282 / MSE^2 ) - K Where K = 0 if NTSC rejection filter is OFF; and K = 3 if NTSC rejection filter is ON For QAM64: SNR[dB] = 10 * log10(897152044.8282 / MSE^2 ) For QAM256: SNR[dB] = 10 * log10(907832426.314266 / MSE^2 ) We re-write the snr equation as: SNR * 2^24 = 10*(c - 2*intlog10(MSE)) Where for QAM256, c = log10(907832426.314266) * 2^24 and for 8-VSB and QAM64, c = log10(897152044.8282) * 2^24 */ static u32 calculate_snr(u32 mse, u32 c) { … } static int or51132_read_snr(struct dvb_frontend* fe, u16* snr) { … } static int or51132_read_signal_strength(struct dvb_frontend* fe, u16* strength) { … } static int or51132_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings) { … } static void or51132_release(struct dvb_frontend* fe) { … } static const struct dvb_frontend_ops or51132_ops; struct dvb_frontend* or51132_attach(const struct or51132_config* config, struct i2c_adapter* i2c) { … } static const struct dvb_frontend_ops or51132_ops = …; module_param(debug, int, 0644); MODULE_PARM_DESC(…) …; MODULE_DESCRIPTION(…) …; MODULE_AUTHOR(…) …; MODULE_AUTHOR(…) …; MODULE_LICENSE(…) …; EXPORT_SYMBOL_GPL(…);
Codebase Browser
linux