corner
struct input_mt_pos corner[4];
corner[0].x =
corner[0].y =
corner[1].x =
corner[1].y =
corner[2].x =
corner[2].y =
corner[3].x =
corner[3].y =
corner[i].x = priv->x_max - corner[i].x;
corner[i].y = priv->y_max - corner[i].y;
int dx = fields->st.x - corner[i].x;
int dy = fields->st.y - corner[i].y;
fields->mt[1] = corner[priv->second_touch];
if (f_high <= f_low || uV_high <= uV_low || f_high <= corner->freq)
return corner->uV;
struct corner *corner, *end;
corner = drv->corners;
end = &corner[drv->num_corners - 1];
for (apply_scaling = false, i = 0; corner <= end; corner++, i++) {
corner->fuse_corner = fuse;
corner->freq = cdata[i].freq;
corner->uV = fuse->uV;
fdata, corner);
} else if (corner->freq == fuse->max_freq) {
freq_diff = fuse->max_freq - corner->freq;
corner->quot_adjust = scaling * freq_diff_mhz / 1000;
corner->uV = cpr_interpolate(corner, step_volt, fdata);
corner->max_uV = fuse->max_uV;
corner->min_uV = fuse->min_uV;
corner->uV = clamp(corner->uV, corner->min_uV, corner->max_uV);
corner->last_uV = corner->uV;
if (desc->reduce_to_corner_uV && corner->uV < corner->max_uV)
corner->max_uV = corner->uV;
else if (desc->reduce_to_fuse_uV && fuse->uV < corner->max_uV)
corner->max_uV = max(corner->min_uV, fuse->uV);
corner->min_uV, corner->uV, corner->max_uV,
fuse->quot - corner->quot_adjust);
const struct corner *end;
struct corner *iter;
drv->corner = iter;
drv->corner = iter;
if (!drv->corner) {
struct corner *corner;
corner = drv->corner;
fuse_corner = corner->fuse_corner;
corner->last_uV);
struct corner *corner;
struct corner *corners;
static void cpr_ctl_enable(struct cpr_drv *drv, struct corner *corner)
corner->save_ctl);
cpr_irq_set(drv, corner->save_irq);
if (cpr_is_allowed(drv) && corner->max_uV > corner->min_uV)
static void cpr_corner_save(struct cpr_drv *drv, struct corner *corner)
corner->save_ctl = cpr_read(drv, REG_RBCPR_CTL);
corner->save_irq = cpr_read(drv, REG_RBIF_IRQ_EN(0));
static void cpr_corner_restore(struct cpr_drv *drv, struct corner *corner)
struct fuse_corner *fuse = corner->fuse_corner;
gcnt |= fuse->quot - corner->quot_adjust;
ctl = corner->save_ctl;
irq = corner->save_irq;
struct fuse_corner *prev_fuse_corner = drv->corner->fuse_corner;
struct fuse_corner *prev_fuse_corner = drv->corner->fuse_corner;
static int cpr_scale_voltage(struct cpr_drv *drv, struct corner *corner,
struct fuse_corner *fuse_corner = corner->fuse_corner;
return drv->corner ? drv->corner - drv->corners + 1 : 0;
struct corner *corner;
corner = drv->corner;
last_uV = corner->last_uV;
if (last_uV >= corner->max_uV) {
new_uV = min(new_uV, corner->max_uV);
if (last_uV <= corner->min_uV) {
new_uV = max(new_uV, corner->min_uV);
ret = cpr_scale_voltage(drv, corner, new_uV, dir);
drv->corner->last_uV = new_uV;
cpr_corner_save(drv, drv->corner);
if (cpr_is_allowed(drv) && drv->corner) {
cpr_corner_restore(drv, drv->corner);
cpr_ctl_enable(drv, drv->corner);
struct corner *corner;
corner = &drv->corners[i];
corner->save_ctl = val;
corner->save_irq = CPR_INT_DEFAULT;
struct corner *corner, *end;
corner = drv->corners + state - 1;
if (corner > end || corner < drv->corners)
if (drv->corner > corner)
else if (drv->corner < corner)
new_uV = corner->last_uV;
new_uV = corner->uV;
ret = cpr_scale_voltage(drv, corner, new_uV, dir);
if (drv->corner != corner)
cpr_corner_restore(drv, corner);
cpr_ctl_enable(drv, corner);
drv->corner = corner;
const struct corner *corner)
fuse = corner->fuse_corner;
static int cpr_interpolate(const struct corner *corner, int step_volt,
fuse = corner->fuse_corner;
f_diff = fuse->max_freq - corner->freq;
unsigned int corner;
corner = max(pd->corner, pd->enable_corner);
ret = rpmhpd_aggregate_corner(pd, corner);
pd->corner = i;
unsigned int corner;
corner = max(pd->corner, pd->enable_corner);
corner = 0;
ret = rpmhpd_aggregate_corner(pd, corner);
unsigned int corner;
unsigned int corner, bool sync)
.data = corner,
static void to_active_sleep(struct rpmhpd *pd, unsigned int corner,
*active = corner;
static int rpmhpd_aggregate_corner(struct rpmhpd *pd, unsigned int corner)
to_active_sleep(pd, corner, &this_active_corner, &this_sleep_corner);
peer_enabled_corner = max(peer->corner, peer->enable_corner);
to_active_sleep(pd, pd->corner, &this_active_corner, &this_sleep_corner);
to_active_sleep(peer, peer->corner, &peer_active_corner,
if (pd->corner)
pd->corner = state;
pd->corner = 0;
unsigned int corner;
static int rpmpd_send_corner(struct rpmpd *pd, int state, unsigned int corner)
.value = cpu_to_le32(corner),
static void to_active_sleep(struct rpmpd *pd, unsigned int corner,
*active = corner;