Page MenuHomeFreeBSD
Differential D48229

nv: Add <sys/_nv.h> header for nvlist_t declaration
ClosedPublic
Actions

Authored by jhb on Dec 28 2024, 9:15 PM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Mar 12, 11:22 AM
Unknown Object (File)
Feb 19 2025, 8:25 PM
Unknown Object (File)
Feb 10 2025, 6:30 PM
Unknown Object (File)
Feb 4 2025, 5:32 AM
Unknown Object (File)
Jan 29 2025, 9:17 AM
Unknown Object (File)
Jan 25 2025, 1:23 PM
Unknown Object (File)
Jan 25 2025, 10:52 AM
Unknown Object (File)
Jan 21 2025, 3:18 PM
View All 21 Files
Subscribers
None

Details

Reviewers
imp
chuck
oshogbo
Commits
rG8a50aa09019a: nv: Add <sys/_nv.h> header for nvlist_t declaration
Summary

This can be useful for headers that wish to use nvlist_t pointers in a
structure or function argument without pulling in all of the headers
from <sys/nv.h>.

Sponsored by: Chelsio Communications

Diff Detail

Repository
rG FreeBSD src repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

jhb requested review of this revision.Dec 28 2024, 9:15 PM
jhb created this revision.
Harbormaster completed remote builds in B61369: Diff 148483.Dec 28 2024, 9:15 PM
jhb added a child revision: D48230: nvmf: Switch several ioctls to using nvlists.Dec 28 2024, 9:15 PM
imp added inline comments.Dec 28 2024, 9:26 PM
sys/sys/cnv.h
40

Can't this be removed, here and elsewhere, since _nv.h includes it for !KERNEL and this is in !KERNEL?

jhb added a comment.Dec 30 2024, 3:33 PM

One thing I did not try to address is the other places that define nvlist_t (notably in libcasper). They do so _after_ including <sys/nv.h> which is kind of confusing to me and I'm not sure why that is so I've left them alone.

sys/sys/cnv.h
40

Yes in theory. The reason I did not is that conceptually I just want <sys/_nv.h> to ensure that nvlist_t is defined. These headers define other symbols that <sys/nv_namespace.h> renames such as cnvlist_*, etc.

jhb added a reviewer: oshogbo.Dec 30 2024, 3:33 PM
imp accepted this revision.Dec 30 2024, 5:54 PM

Ok. Those are good reasons.

This revision is now accepted and ready to land.Dec 30 2024, 5:54 PM
Closed by commit rG8a50aa09019a: nv: Add <sys/_nv.h> header for nvlist_t declaration (authored by jhb). · Explain WhyDec 30 2024, 6:53 PM
This revision was automatically updated to reflect the committed changes.
jhb added a commit: rG8a50aa09019a: nv: Add <sys/_nv.h> header for nvlist_t declaration.

Revision Contents
Changeset List

PathSize
sys/
sys/
45 lines
8 lines
8 lines
8 lines
tools/
build/
1 line

Diff 148572

View Options

sys/sys/_nv.h

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

sys/sys/cnv.h

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

sys/sys/dnv.h

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

sys/sys/nv.h

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines
View Options

tools/build/Makefile

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesrk8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
*udelay = 0; *udelay = 0;
return (0); return (0);
} }
static void static void
rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv) rk8xx_regnode_reg_to_voltage(struct rk8xx_reg_sc *sc, uint8_t val, int *uv)
{ {
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
int change;
change =
((sc->def->voltage_min2 - sc->def->voltage_min) /
sc->def->voltage_step);
if (val > change) {
if (val < sc->def->voltage_nstep) {
*uv = sc->def->voltage_min2 +
(val - change) *
sc->def->voltage_step2;
} else
*uv = sc->def->voltage_max2;
return;
}
}
if (val < sc->def->voltage_nstep) if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step; *uv = sc->def->voltage_min + val * sc->def->voltage_step;
else else
*uv = sc->def->voltage_max;
} else {
if (val < sc->def->voltage_nstep)
*uv = sc->def->voltage_min + val * sc->def->voltage_step;
else
*uv = sc->def->voltage_min + *uv = sc->def->voltage_min +
(sc->def->voltage_nstep * sc->def->voltage_step); (sc->def->voltage_nstep * sc->def->voltage_step);
} }
}
static int static int
rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt, rk8xx_regnode_voltage_to_reg(struct rk8xx_reg_sc *sc, int min_uvolt,
int max_uvolt, uint8_t *val) int max_uvolt, uint8_t *val)
{ {
uint8_t nval; uint8_t nval;
int nstep, uvolt; int nstep, uvolt;
struct rk8xx_softc *sc1;
sc1 = device_get_softc(sc->base_dev);
nval = 0; nval = 0;
uvolt = sc->def->voltage_min; uvolt = sc->def->voltage_min;
for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt; for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
nstep++) { nstep++) {
++nval; ++nval;
if (sc1->type == RK809 || sc1->type == RK817) {
if (sc->def->voltage_step2) {
if (uvolt < sc->def->voltage_min2)
uvolt += sc->def->voltage_step; uvolt += sc->def->voltage_step;
else
uvolt += sc->def->voltage_step2;
} else
uvolt += sc->def->voltage_step;
} else
uvolt += sc->def->voltage_step;
} }
if (uvolt > max_uvolt) if (uvolt > max_uvolt)
return (EINVAL); return (EINVAL);
*val = nval; *val = nval;
return (0); return (0);
} }
Show All 13 Linesrk8xx_regnode_status(struct regnode *regnode, int *status)
return (0); return (0);
} }
static int static int
rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt, rk8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
int max_uvolt, int *udelay) int max_uvolt, int *udelay)
{ {
struct rk8xx_reg_sc *sc; struct rk8xx_reg_sc *sc;
uint8_t val; uint8_t val, old;
int uvolt; int uvolt;
struct rk8xx_softc *sc1;
sc = regnode_get_softc(regnode); sc = regnode_get_softc(regnode);
sc1 = device_get_softc(sc->base_dev);
if (!sc->def->voltage_step) if (!sc->def->voltage_step)
return (ENXIO); return (ENXIO);
dprintf(sc, "Setting %s to %d<->%d uvolts\n", dprintf(sc, "Setting %s to %d<->%d uvolts\n",
sc->def->name, sc->def->name,
min_uvolt, min_uvolt,
max_uvolt); max_uvolt);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
old = val;
if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) if (rk8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
return (ERANGE); return (ERANGE);
if (sc1->type == RK809 || sc1->type == RK817)
val |= (old &= ~sc->def->voltage_mask);
rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); rk8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
*udelay = 0; *udelay = 0;
rk8xx_regnode_reg_to_voltage(sc, val, &uvolt); rk8xx_regnode_reg_to_voltage(sc, val, &uvolt);
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines