mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2026-08-14 06:22:34 +02:00
Linus Torvalds
bf4afc53b7
This was done entirely with mindless brute force, using
git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'
to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.
Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.
For the same reason the 'flex' versions will be done as a separate
conversion.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
297 lines
5.9 KiB
C
297 lines
5.9 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
Intersil ISL6423 SEC and LNB Power supply controller
|
|
|
|
Copyright (C) Manu Abraham <abraham.manu@gmail.com>
|
|
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/string.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <media/dvb_frontend.h>
|
|
#include "isl6423.h"
|
|
|
|
static unsigned int verbose;
|
|
module_param(verbose, int, 0644);
|
|
MODULE_PARM_DESC(verbose, "Set Verbosity level");
|
|
|
|
#define FE_ERROR 0
|
|
#define FE_NOTICE 1
|
|
#define FE_INFO 2
|
|
#define FE_DEBUG 3
|
|
#define FE_DEBUGREG 4
|
|
|
|
#define dprintk(__y, __z, format, arg...) do { \
|
|
if (__z) { \
|
|
if ((verbose > FE_ERROR) && (verbose > __y)) \
|
|
printk(KERN_ERR "%s: " format "\n", __func__ , ##arg); \
|
|
else if ((verbose > FE_NOTICE) && (verbose > __y)) \
|
|
printk(KERN_NOTICE "%s: " format "\n", __func__ , ##arg); \
|
|
else if ((verbose > FE_INFO) && (verbose > __y)) \
|
|
printk(KERN_INFO "%s: " format "\n", __func__ , ##arg); \
|
|
else if ((verbose > FE_DEBUG) && (verbose > __y)) \
|
|
printk(KERN_DEBUG "%s: " format "\n", __func__ , ##arg); \
|
|
} else { \
|
|
if (verbose > __y) \
|
|
printk(format, ##arg); \
|
|
} \
|
|
} while (0)
|
|
|
|
struct isl6423_dev {
|
|
const struct isl6423_config *config;
|
|
struct i2c_adapter *i2c;
|
|
|
|
u8 reg_3;
|
|
u8 reg_4;
|
|
|
|
unsigned int verbose;
|
|
};
|
|
|
|
static int isl6423_write(struct isl6423_dev *isl6423, u8 reg)
|
|
{
|
|
struct i2c_adapter *i2c = isl6423->i2c;
|
|
u8 addr = isl6423->config->addr;
|
|
int err = 0;
|
|
|
|
struct i2c_msg msg = { .addr = addr, .flags = 0, .buf = ®, .len = 1 };
|
|
|
|
dprintk(FE_DEBUG, 1, "write reg %02X", reg);
|
|
err = i2c_transfer(i2c, &msg, 1);
|
|
if (err < 0)
|
|
goto exit;
|
|
return 0;
|
|
|
|
exit:
|
|
dprintk(FE_ERROR, 1, "I/O error <%d>", err);
|
|
return err;
|
|
}
|
|
|
|
static int isl6423_set_modulation(struct dvb_frontend *fe)
|
|
{
|
|
struct isl6423_dev *isl6423 = (struct isl6423_dev *) fe->sec_priv;
|
|
const struct isl6423_config *config = isl6423->config;
|
|
int err = 0;
|
|
u8 reg_2 = 0;
|
|
|
|
reg_2 = 0x01 << 5;
|
|
|
|
if (config->mod_extern)
|
|
reg_2 |= (1 << 3);
|
|
else
|
|
reg_2 |= (1 << 4);
|
|
|
|
err = isl6423_write(isl6423, reg_2);
|
|
if (err < 0)
|
|
goto exit;
|
|
return 0;
|
|
|
|
exit:
|
|
dprintk(FE_ERROR, 1, "I/O error <%d>", err);
|
|
return err;
|
|
}
|
|
|
|
static int isl6423_voltage_boost(struct dvb_frontend *fe, long arg)
|
|
{
|
|
struct isl6423_dev *isl6423 = (struct isl6423_dev *) fe->sec_priv;
|
|
u8 reg_3 = isl6423->reg_3;
|
|
u8 reg_4 = isl6423->reg_4;
|
|
int err = 0;
|
|
|
|
if (arg) {
|
|
/* EN = 1, VSPEN = 1, VBOT = 1 */
|
|
reg_4 |= (1 << 4);
|
|
reg_4 |= 0x1;
|
|
reg_3 |= (1 << 3);
|
|
} else {
|
|
/* EN = 1, VSPEN = 1, VBOT = 0 */
|
|
reg_4 |= (1 << 4);
|
|
reg_4 &= ~0x1;
|
|
reg_3 |= (1 << 3);
|
|
}
|
|
err = isl6423_write(isl6423, reg_3);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
err = isl6423_write(isl6423, reg_4);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
isl6423->reg_3 = reg_3;
|
|
isl6423->reg_4 = reg_4;
|
|
|
|
return 0;
|
|
exit:
|
|
dprintk(FE_ERROR, 1, "I/O error <%d>", err);
|
|
return err;
|
|
}
|
|
|
|
|
|
static int isl6423_set_voltage(struct dvb_frontend *fe,
|
|
enum fe_sec_voltage voltage)
|
|
{
|
|
struct isl6423_dev *isl6423 = (struct isl6423_dev *) fe->sec_priv;
|
|
u8 reg_3 = isl6423->reg_3;
|
|
u8 reg_4 = isl6423->reg_4;
|
|
int err = 0;
|
|
|
|
switch (voltage) {
|
|
case SEC_VOLTAGE_OFF:
|
|
/* EN = 0 */
|
|
reg_4 &= ~(1 << 4);
|
|
break;
|
|
|
|
case SEC_VOLTAGE_13:
|
|
/* EN = 1, VSPEN = 1, VTOP = 0, VBOT = 0 */
|
|
reg_4 |= (1 << 4);
|
|
reg_4 &= ~0x3;
|
|
reg_3 |= (1 << 3);
|
|
break;
|
|
|
|
case SEC_VOLTAGE_18:
|
|
/* EN = 1, VSPEN = 1, VTOP = 1, VBOT = 0 */
|
|
reg_4 |= (1 << 4);
|
|
reg_4 |= 0x2;
|
|
reg_4 &= ~0x1;
|
|
reg_3 |= (1 << 3);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
err = isl6423_write(isl6423, reg_3);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
err = isl6423_write(isl6423, reg_4);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
isl6423->reg_3 = reg_3;
|
|
isl6423->reg_4 = reg_4;
|
|
|
|
return 0;
|
|
exit:
|
|
dprintk(FE_ERROR, 1, "I/O error <%d>", err);
|
|
return err;
|
|
}
|
|
|
|
static int isl6423_set_current(struct dvb_frontend *fe)
|
|
{
|
|
struct isl6423_dev *isl6423 = (struct isl6423_dev *) fe->sec_priv;
|
|
u8 reg_3 = isl6423->reg_3;
|
|
const struct isl6423_config *config = isl6423->config;
|
|
int err = 0;
|
|
|
|
switch (config->current_max) {
|
|
case SEC_CURRENT_275m:
|
|
/* 275mA */
|
|
/* ISELH = 0, ISELL = 0 */
|
|
reg_3 &= ~0x3;
|
|
break;
|
|
|
|
case SEC_CURRENT_515m:
|
|
/* 515mA */
|
|
/* ISELH = 0, ISELL = 1 */
|
|
reg_3 &= ~0x2;
|
|
reg_3 |= 0x1;
|
|
break;
|
|
|
|
case SEC_CURRENT_635m:
|
|
/* 635mA */
|
|
/* ISELH = 1, ISELL = 0 */
|
|
reg_3 &= ~0x1;
|
|
reg_3 |= 0x2;
|
|
break;
|
|
|
|
case SEC_CURRENT_800m:
|
|
/* 800mA */
|
|
/* ISELH = 1, ISELL = 1 */
|
|
reg_3 |= 0x3;
|
|
break;
|
|
}
|
|
|
|
err = isl6423_write(isl6423, reg_3);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
switch (config->curlim) {
|
|
case SEC_CURRENT_LIM_ON:
|
|
/* DCL = 0 */
|
|
reg_3 &= ~0x10;
|
|
break;
|
|
|
|
case SEC_CURRENT_LIM_OFF:
|
|
/* DCL = 1 */
|
|
reg_3 |= 0x10;
|
|
break;
|
|
}
|
|
|
|
err = isl6423_write(isl6423, reg_3);
|
|
if (err < 0)
|
|
goto exit;
|
|
|
|
isl6423->reg_3 = reg_3;
|
|
|
|
return 0;
|
|
exit:
|
|
dprintk(FE_ERROR, 1, "I/O error <%d>", err);
|
|
return err;
|
|
}
|
|
|
|
static void isl6423_release(struct dvb_frontend *fe)
|
|
{
|
|
isl6423_set_voltage(fe, SEC_VOLTAGE_OFF);
|
|
|
|
kfree(fe->sec_priv);
|
|
fe->sec_priv = NULL;
|
|
}
|
|
|
|
struct dvb_frontend *isl6423_attach(struct dvb_frontend *fe,
|
|
struct i2c_adapter *i2c,
|
|
const struct isl6423_config *config)
|
|
{
|
|
struct isl6423_dev *isl6423;
|
|
|
|
isl6423 = kzalloc_obj(struct isl6423_dev);
|
|
if (!isl6423)
|
|
return NULL;
|
|
|
|
isl6423->config = config;
|
|
isl6423->i2c = i2c;
|
|
fe->sec_priv = isl6423;
|
|
|
|
/* SR3H = 0, SR3M = 1, SR3L = 0 */
|
|
isl6423->reg_3 = 0x02 << 5;
|
|
/* SR4H = 0, SR4M = 1, SR4L = 1 */
|
|
isl6423->reg_4 = 0x03 << 5;
|
|
|
|
if (isl6423_set_current(fe))
|
|
goto exit;
|
|
|
|
if (isl6423_set_modulation(fe))
|
|
goto exit;
|
|
|
|
fe->ops.release_sec = isl6423_release;
|
|
fe->ops.set_voltage = isl6423_set_voltage;
|
|
fe->ops.enable_high_lnb_voltage = isl6423_voltage_boost;
|
|
isl6423->verbose = verbose;
|
|
|
|
return fe;
|
|
|
|
exit:
|
|
kfree(isl6423);
|
|
fe->sec_priv = NULL;
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(isl6423_attach);
|
|
|
|
MODULE_DESCRIPTION("ISL6423 SEC");
|
|
MODULE_AUTHOR("Manu Abraham");
|
|
MODULE_LICENSE("GPL");
|