From: Oleg Zadorozhnyi An output's state says whether it carries a signal: CONNECTED while it drives, DISCONNECTED while muted. Setting it forces the output's pads to Hi-Z, which leaves the divider alone. Output pins are registered from this patch on. A mute forces the slot's three Hi-Z pairs, differential, CMOS OutP and CMOS OutN, with the Page 3 debug window open; the force registers are outside the NVM, so no programming directive is written. An un-mute releases the force and the pads return to the loaded configuration. An output is reported muted only when both pads are forced off. Signed-off-by: Oleg Zadorozhnyi Signed-off-by: Ali Rouhi --- drivers/dpll/sit9531x/core.c | 313 +++++++++++++++++++++++++++++------ drivers/dpll/sit9531x/core.h | 15 ++ drivers/dpll/sit9531x/dpll.c | 142 +++++++++++++++- 3 files changed, 415 insertions(+), 55 deletions(-) diff --git a/drivers/dpll/sit9531x/core.c b/drivers/dpll/sit9531x/core.c index d3f6955b3bbd..eb1d10e1fde2 100644 --- a/drivers/dpll/sit9531x/core.c +++ b/drivers/dpll/sit9531x/core.c @@ -460,12 +460,78 @@ static int sit9531x_output_forced_hiz(struct sit9531x_dev *sitdev, return 0; } +/* Re-read an output's mute state. Caller must hold sitdev->multiop_lock. */ +int sit9531x_output_state_refresh(struct sit9531x_dev *sitdev, u8 out_idx) +{ + bool muted, part; + int rc; + + lockdep_assert_held(&sitdev->multiop_lock); + + rc = sit9531x_output_forced_hiz(sitdev, out_idx, &muted, &part); + if (rc) + return rc; + + sitdev->out[out_idx].enabled = !muted; + sitdev->out[out_idx].part_muted = part; + sitdev->out[out_idx].state_stale = false; + + return 0; +} + +static int sit9531x_hiz_set_bit(struct sit9531x_dev *sitdev, + unsigned int reg, u8 bit, bool set) +{ + u8 cur, new_val; + int rc; + + rc = sit9531x_read_u8(sitdev, reg, &cur); + if (rc) + return rc; + + new_val = set ? (cur | BIT(bit)) : (cur & ~BIT(bit)); + + return sit9531x_write_u8(sitdev, reg, new_val); +} + +/* + * The Page 3 debug key opens every debug register of the output system while + * it holds the unlock value. + */ +static int sit9531x_outsys_debug_open(struct sit9531x_dev *sitdev) +{ + int rc; + + rc = sit9531x_write_u8(sitdev, SIT9531X_REG_OUTSYS_DEBUG, + SIT9531X_DEBUG_UNLOCK_VAL); + if (rc) + sit9531x_write_close(sitdev, SIT9531X_REG_OUTSYS_DEBUG, + SIT9531X_DEBUG_LOCK_VAL); + + return rc; +} + +static void sit9531x_outsys_debug_close(struct sit9531x_dev *sitdev) +{ + int rc; + + rc = sit9531x_write_close(sitdev, SIT9531X_REG_OUTSYS_DEBUG, + SIT9531X_DEBUG_LOCK_VAL); + sitdev->outsys_key_pending = !!rc; + if (rc) + dev_warn(sitdev->dev, "output debug block left unlocked: %d\n", + rc); +} + #define SIT9531X_LOOP_LOCK_TRIES 3 -/* Close the loops and lock the debug block without committing */ -static void sit9531x_prg_abort(struct sit9531x_dev *sitdev) +/* + * Leave PRG_CMD: re-lock the loops and close the debug window. The sleep is + * the settling time after loop lock. + */ +static int sit9531x_prg_relock(struct sit9531x_dev *sitdev) { - int rc = -EIO; + int rc = 0; u8 attempt; for (attempt = 0; attempt < SIT9531X_LOOP_LOCK_TRIES; attempt++) { @@ -477,30 +543,49 @@ static void sit9531x_prg_abort(struct sit9531x_dev *sitdev) } if (rc) dev_err(sitdev->dev, - "output loops left unlocked after a failed entry: %d\n", + "output loops left unlocked after programming: %d\n", rc); - sit9531x_write_u8(sitdev, SIT9531X_REG_OUTSYS_DEBUG, - SIT9531X_DEBUG_LOCK_VAL); + sitdev->loops_open = !!rc; + + msleep(100); + + sit9531x_outsys_debug_close(sitdev); + + return rc; } /* - * Unlock the Page 3 debug registers and enter PRG_CMD; output-system writes - * take effect only in this state. + * Update the NVM bank and leave PRG_CMD. The bank update is issued once per + * programming sequence; a loop re-lock retried later does not repeat it. + */ +static int sit9531x_prg_commit(struct sit9531x_dev *sitdev) +{ + int rc, rc2; + + rc = sit9531x_write_u8(sitdev, SIT9531X_REG_PRG_DIR_GEN, + SIT9531X_UPDATE_NVM); + rc2 = sit9531x_prg_relock(sitdev); + + return rc ? rc : rc2; +} + +/* + * Open the Page 3 debug window and enter PRG_CMD; the output divider takes + * effect only in this state. */ static int sit9531x_prg_enter(struct sit9531x_dev *sitdev) { int rc; - rc = sit9531x_write_u8(sitdev, SIT9531X_REG_OUTSYS_DEBUG, - SIT9531X_DEBUG_UNLOCK_VAL); + rc = sit9531x_outsys_debug_open(sitdev); if (rc) return rc; rc = sit9531x_write_u8(sitdev, SIT9531X_REG_PRG_DIR_GEN, SIT9531X_PRG_CMD_STATE); if (rc) { - sit9531x_prg_abort(sitdev); + sit9531x_prg_relock(sitdev); return rc; } @@ -508,51 +593,144 @@ static int sit9531x_prg_enter(struct sit9531x_dev *sitdev) } /* - * Update the NVM shadow and re-lock the loops after sit9531x_prg_enter(). The - * sleep is the settling time after loop lock. + * Mute or unmute every Hi-Z pair of a slot. The force registers are outside + * the NVM, so no directive is written, as in Output_Disable_Control_HiZ.py. + * Caller must hold the debug window open. */ -static int sit9531x_prg_commit(struct sit9531x_dev *sitdev) +static int sit9531x_output_hiz_write(struct sit9531x_dev *sitdev, u8 slot, + bool mute, u8 keep) { - int rc, rc2 = 0, rc3; - u8 attempt; + u8 mask[SIT9531X_HIZ_PAIRS], state[SIT9531X_HIZ_PAIRS]; + struct sit9531x_hiz_pair p[SIT9531X_HIZ_PAIRS]; + int i, rc, undo_rc; - rc = sit9531x_write_u8(sitdev, SIT9531X_REG_PRG_DIR_GEN, - SIT9531X_UPDATE_NVM); + sit9531x_output_get_hiz_regs(slot, p); - for (attempt = 0; attempt < SIT9531X_LOOP_LOCK_TRIES; attempt++) { - rc2 = sit9531x_write_u8(sitdev, SIT9531X_REG_PRG_DIR_GEN, - SIT9531X_LOOP_LOCK); - if (!rc2) - break; - usleep_range(1000, 2000); + if (!mute) { + for (i = 0; i < SIT9531X_HIZ_PAIRS; i++) { + /* A pad the loaded configuration forces stays forced */ + if (keep & BIT(i)) + continue; + rc = sit9531x_hiz_set_bit(sitdev, p[i].mask, p[i].bit, + false); + if (rc) + return rc; + } + return 0; } - if (rc2) - dev_err(sitdev->dev, - "output loops left unlocked after programming: %d\n", - rc2); - sitdev->loops_open = !!rc2; - - msleep(100); + for (i = 0; i < SIT9531X_HIZ_PAIRS; i++) { + rc = sit9531x_read_u8(sitdev, p[i].state, &state[i]); + if (rc) + return rc; + rc = sit9531x_read_u8(sitdev, p[i].mask, &mask[i]); + if (rc) + return rc; + } /* - * The debug key register unlocks every debug register while it holds - * the unlock value. + * STATE before MASK: enabling the override first can drive the pad for + * one I2C transfer. */ - rc3 = sit9531x_write_close(sitdev, SIT9531X_REG_OUTSYS_DEBUG, - SIT9531X_DEBUG_LOCK_VAL); + for (i = 0; i < SIT9531X_HIZ_PAIRS; i++) { + rc = sit9531x_hiz_set_bit(sitdev, p[i].state, p[i].bit, false); + if (!rc) + rc = sit9531x_hiz_set_bit(sitdev, p[i].mask, p[i].bit, + true); + if (rc) + break; + } + if (!rc) + return 0; + for (; i >= 0; i--) { + u8 bit = BIT(p[i].bit); + + undo_rc = sit9531x_hiz_set_bit(sitdev, p[i].mask, p[i].bit, + mask[i] & bit); + if (!undo_rc) + undo_rc = sit9531x_hiz_set_bit(sitdev, p[i].state, + p[i].bit, + state[i] & bit); + if (undo_rc) + dev_err(sitdev->dev, + "slot%u: Hi-Z override left part applied (%d)\n", + slot, undo_rc); + } + + return rc; +} + +/* Caller must hold sitdev->multiop_lock. */ +int sit9531x_output_disable(struct sit9531x_dev *sitdev, u8 index) +{ + const struct sit9531x_chip_info *info = sitdev->info; + int rc, state_rc; + bool muted, part; + u8 slot; + + lockdep_assert_held(&sitdev->multiop_lock); + + if (index >= info->num_outputs) + return -EINVAL; + + slot = info->clkout_map[index]; + rc = sit9531x_outsys_debug_open(sitdev); if (rc) return rc; - if (rc2) - return rc2; - if (rc3) - dev_warn(sitdev->dev, - "output debug block left unlocked after programming: %d\n", - rc3); + rc = sit9531x_output_hiz_write(sitdev, slot, true, 0); + sit9531x_outsys_debug_close(sitdev); - return 0; + /* Read back the Hi-Z state */ + state_rc = sit9531x_output_forced_hiz(sitdev, index, &muted, &part); + if (!state_rc) { + sitdev->out[index].enabled = !muted; + sitdev->out[index].part_muted = part; + sitdev->out[index].state_stale = false; + } else { + sitdev->out[index].state_stale = true; + if (!rc) + rc = state_rc; + } + + return rc; +} + +/* Caller must hold sitdev->multiop_lock. */ +int sit9531x_output_enable(struct sit9531x_dev *sitdev, u8 index) +{ + const struct sit9531x_chip_info *info = sitdev->info; + int rc, state_rc; + bool muted, part; + u8 slot; + + lockdep_assert_held(&sitdev->multiop_lock); + + if (index >= info->num_outputs) + return -EINVAL; + + slot = info->clkout_map[index]; + rc = sit9531x_outsys_debug_open(sitdev); + if (rc) + return rc; + + rc = sit9531x_output_hiz_write(sitdev, slot, false, + sitdev->out[index].hiz_keep); + sit9531x_outsys_debug_close(sitdev); + + state_rc = sit9531x_output_forced_hiz(sitdev, index, &muted, &part); + if (!state_rc) { + sitdev->out[index].enabled = !muted; + sitdev->out[index].part_muted = part; + sitdev->out[index].state_stale = false; + } else { + sitdev->out[index].state_stale = true; + if (!rc) + rc = state_rc; + } + + return rc; } /* @@ -2085,6 +2263,24 @@ static int sit9531x_out_state_fetch(struct sit9531x_dev *sitdev, u8 index) return rc; sitdev->out[index].part_muted = part; + sitdev->out[index].state_stale = false; + + /* Record the pads the loaded configuration forces on a driven output */ + out->hiz_keep = 0; + if (part) { + struct sit9531x_hiz_pair p[SIT9531X_HIZ_PAIRS]; + bool forced; + int i; + + sit9531x_output_get_hiz_regs(slot, p); + for (i = 0; i < SIT9531X_HIZ_PAIRS; i++) { + rc = sit9531x_hiz_pair_forced(sitdev, &p[i], &forced); + if (rc) + return rc; + if (forced) + out->hiz_keep |= BIT(i); + } + } /* * Each PLL page holds a 12-bit output-enable mask: OUT_MAP_LO bits 0-7 @@ -2445,7 +2641,9 @@ sit9531x_dev_chan_states_update(struct sit9531x_dev *sitdev) /* Retry pending writes first so the reads below see their result */ if (sitdev->loops_open) - sit9531x_prg_commit(sitdev); + sit9531x_prg_relock(sitdev); + else if (sitdev->outsys_key_pending) + sit9531x_outsys_debug_close(sitdev); sit9531x_input_off_retry(sitdev); for (i = 0; i < SIT9531X_NUM_PLLS; i++) { @@ -2772,10 +2970,12 @@ static void sit9531x_dev_stop(struct sit9531x_dev *sitdev) mutex_lock(&sitdev->multiop_lock); if (sitdev->loops_open) { - sit9531x_prg_commit(sitdev); + sit9531x_prg_relock(sitdev); if (sitdev->loops_open) dev_warn(sitdev->dev, "output loops left unlocked at removal\n"); + } else if (sitdev->outsys_key_pending) { + sit9531x_outsys_debug_close(sitdev); } mutex_unlock(&sitdev->multiop_lock); } @@ -2855,7 +3055,7 @@ static void sit9531x_dpll_pin_unregister(struct sit9531x_dpll_pin *pin) * Clear before unregistering: callbacks test it under the DPLL device * lock, which dpll_pin_unregister() also takes. */ - pin->dpll_pin = NULL; + WRITE_ONCE(pin->dpll_pin, NULL); dpll_pin_unregister(sitdpll->dpll_dev, dpll_pin, ops, pin); dpll_pin_put(dpll_pin, &pin->tracker); @@ -2891,20 +3091,33 @@ static void sit9531x_dpll_pins_unregister(struct sit9531x_dpll *sitdpll) } } -/* Check if the pin class has a state callback, which the DPLL core requires */ +/* + * An output is registered when routed to this DPLL, whether or not it is + * driving. + */ static bool sit9531x_dpll_pin_is_registrable(struct sit9531x_dpll *sitdpll, enum dpll_pin_direction dir, u8 index) { struct sit9531x_dev *sitdev = sitdpll->dev; - if (dir != DPLL_PIN_DIRECTION_INPUT) + if (dir == DPLL_PIN_DIRECTION_INPUT) { + if (index == SIT9531X_MAX_INPUTS) + return true; + if (index == SIT9531X_INTSYNC_PIN_ID) + return false; + + return sit9531x_input_pin_is_registrable(sitdev, index); + } + + if (index == SIT9531X_INTSYNC_OUT_PIN_ID) return false; - if (index == SIT9531X_MAX_INPUTS) - return true; + if (index >= sitdev->info->num_outputs) + return false; - return sit9531x_input_pin_is_registrable(sitdev, index); + return sitdev->out[index].pll_idx == sitdpll->id && + sitdev->out[index].routed; } static int sit9531x_dpll_pins_register(struct sit9531x_dpll *sitdpll) diff --git a/drivers/dpll/sit9531x/core.h b/drivers/dpll/sit9531x/core.h index 669f9f9b960c..17b41c4ca692 100644 --- a/drivers/dpll/sit9531x/core.h +++ b/drivers/dpll/sit9531x/core.h @@ -101,8 +101,13 @@ struct sit9531x_ref { * @freq: output frequency in Hz * @enabled: output is driving, not forced into Hi-Z * @cmos: single-ended; the CMOS pad Hi-Z pairs apply, not the differential one + * @state_stale: cached mute state must be read back before it is reported + * @ntf_pending: pin change not yet notified; the poll notifies once the state + * is read * @part_muted: single-ended with one pad forced and the other not; reported * as driven. The driver's mute forces both pads. + * @hiz_keep: bit per Hi-Z pair the loaded configuration forces on an output + * found part muted at probe; an unmute leaves those pairs forced * @routed: mapped to @pll_idx by the initial configuration; an unrouted * output has no pin * @pll_idx: PLL driving this output (0-3) @@ -111,7 +116,10 @@ struct sit9531x_out { u64 freq; bool enabled; bool cmos; + bool state_stale; + bool ntf_pending; bool part_muted; + u8 hiz_keep; bool routed; u8 pll_idx; }; @@ -206,6 +214,7 @@ struct sit9531x_chan { * @fvco_band_warned: bit per PLL warned for Fref * DIVN outside its VCO * band; written under @multiop_lock * @loops_open: output loops not yet re-locked + * @outsys_key_pending: output-system debug key not closed */ struct sit9531x_dev { struct device *dev; @@ -237,6 +246,7 @@ struct sit9531x_dev { s8 intsync_src; bool loops_open; + bool outsys_key_pending; }; int sit9531x_read_u8(struct sit9531x_dev *sitdev, unsigned int reg, @@ -264,6 +274,11 @@ int sit9531x_input_prio_remove(struct sit9531x_dev *sitdev, u8 pll_idx, int sit9531x_input_prio_add(struct sit9531x_dev *sitdev, u8 pll_idx, u8 input_idx); +int sit9531x_output_disable(struct sit9531x_dev *sitdev, u8 index); +int sit9531x_output_enable(struct sit9531x_dev *sitdev, u8 index); +int sit9531x_output_state_refresh(struct sit9531x_dev *sitdev, + u8 out_idx); + int sit9531x_output_freq_set(struct sit9531x_dev *sitdev, u8 out_idx, u8 pll_idx, u64 frequency); int sit9531x_output_freq_get(struct sit9531x_dev *sitdev, u8 out_idx, diff --git a/drivers/dpll/sit9531x/dpll.c b/drivers/dpll/sit9531x/dpll.c index c8c4aaaf719c..e19eb123d024 100644 --- a/drivers/dpll/sit9531x/dpll.c +++ b/drivers/dpll/sit9531x/dpll.c @@ -184,8 +184,9 @@ const struct dpll_device_ops sit9531x_dpll_device_ops = { * NO_SIGNAL on loss of signal; QUAL_FAILED on frequency drift; STANDBY * otherwise. The routed reference is used because on loss of signal the device * falls back to another listed source and leaves the selection naming the lost - * one. On manual input select, the routed input is CONNECTED. The XO pin is - * always CONNECTED. + * one. On manual input select, the routed input is CONNECTED. An output is + * CONNECTED while driven and DISCONNECTED while muted; SELECTABLE is refused. + * The XO pin is always CONNECTED. */ /* Caller must hold sitdev->multiop_lock. */ @@ -638,10 +639,113 @@ sit9531x_dpll_output_pin_frequency_set(const struct dpll_pin *pin, return rc; } +/* + * DISCONNECTED while the output is forced to Hi-Z, by a mute request or by the + * loaded profile. + */ +static int +sit9531x_dpll_output_pin_state_on_dpll_get(const struct dpll_pin *pin, + void *pin_priv, + const struct dpll_device *dpll, + void *dpll_priv, + enum dpll_pin_state *state, + struct netlink_ext_ack *extack) +{ + struct sit9531x_dpll_pin *dpin = pin_priv; + struct sit9531x_dpll *sitdpll = dpll_priv; + struct sit9531x_dev *sitdev = sitdpll->dev; + const struct sit9531x_out *out; + int rc = 0; + + mutex_lock(&sitdev->multiop_lock); + out = sit9531x_out_state_get(sitdev, dpin->id); + if (out->state_stale) + rc = sit9531x_output_state_refresh(sitdev, dpin->id); + if (!rc) + *state = out->enabled ? DPLL_PIN_STATE_CONNECTED + : DPLL_PIN_STATE_DISCONNECTED; + mutex_unlock(&sitdev->multiop_lock); + if (rc) + NL_SET_ERR_MSG(extack, + "Output mute state could not be read back"); + + return rc; +} + +/* + * Force Hi-Z through the slot's Hi-Z force/state register pairs: differential, + * CMOS OutP and CMOS OutN. + */ +static int +sit9531x_dpll_output_pin_state_on_dpll_set(const struct dpll_pin *pin, + void *pin_priv, + const struct dpll_device *dpll, + void *dpll_priv, + enum dpll_pin_state state, + struct netlink_ext_ack *extack) +{ + bool enable = state == DPLL_PIN_STATE_CONNECTED; + struct sit9531x_dpll_pin *dpin = pin_priv; + struct sit9531x_dpll *sitdpll = dpll_priv; + struct sit9531x_dev *sitdev = sitdpll->dev; + bool was_enabled, changed; + int rc; + + /* An output is routed explicitly, not a selection candidate */ + if (!enable && state != DPLL_PIN_STATE_DISCONNECTED) + return -EINVAL; + + mutex_lock(&sitdev->multiop_lock); + + /* + * Skip a request for the current state. One CMOS pad forced and the + * other not is neither state. + */ + if (!sit9531x_output_state_refresh(sitdev, dpin->id) && + sitdev->out[dpin->id].enabled == enable && + !sitdev->out[dpin->id].part_muted) { + mutex_unlock(&sitdev->multiop_lock); + return 0; + } + + was_enabled = sitdev->out[dpin->id].enabled; + + if (enable) + rc = sit9531x_output_enable(sitdev, dpin->id); + else + rc = sit9531x_output_disable(sitdev, dpin->id); + + changed = sitdev->out[dpin->id].enabled != was_enabled || + sitdev->out[dpin->id].state_stale; + + mutex_unlock(&sitdev->multiop_lock); + + if (rc) { + struct dpll_pin *dpll_pin; + + NL_SET_ERR_MSG(extack, "Failed to set output pin state"); + /* + * The core notifies only a request that succeeded. Teardown + * clears dpll_pin without the core's lock, which is held here; + * read it once, as a set handle stays valid until this returns. + */ + dpll_pin = READ_ONCE(dpin->dpll_pin); + if (changed && dpll_pin && __dpll_pin_change_ntf(dpll_pin)) { + mutex_lock(&sitdev->multiop_lock); + sitdev->out[dpin->id].ntf_pending = true; + mutex_unlock(&sitdev->multiop_lock); + } + } + + return rc; +} + static const struct dpll_pin_ops sit9531x_dpll_output_pin_ops = { .direction_get = sit9531x_dpll_output_pin_direction_get, .frequency_get = sit9531x_dpll_output_pin_frequency_get, .frequency_set = sit9531x_dpll_output_pin_frequency_set, + .state_on_dpll_get = sit9531x_dpll_output_pin_state_on_dpll_get, + .state_on_dpll_set = sit9531x_dpll_output_pin_state_on_dpll_set, }; const struct dpll_pin_ops * @@ -706,8 +810,33 @@ void sit9531x_dpll_pin_baseline(struct sit9531x_dpll_pin *pin) } /* - * Notify a changed lock status, pin state or priority; called from - * sit9531x_dev_periodic_work(). + * Re-read an output with a pending change notification; return true once the + * read succeeds. Caller must hold sitdev->multiop_lock. + */ +static bool +sit9531x_dpll_output_ntf_pending(struct sit9531x_dev *sitdev, + const struct sit9531x_dpll_pin *pin) +{ + struct sit9531x_out *out; + + if (sit9531x_dpll_is_input_pin(pin) || + pin->id >= sitdev->info->num_outputs) + return false; + + out = &sitdev->out[pin->id]; + if (!out->ntf_pending) + return false; + if (out->state_stale && sit9531x_output_state_refresh(sitdev, pin->id)) + return false; + + out->ntf_pending = false; + + return true; +} + +/* + * Notify a changed lock status, pin state, operational state or priority and + * retry a notification that failed; called from sit9531x_dev_periodic_work(). */ void sit9531x_dpll_changes_check(struct sit9531x_dpll *sitdpll) { @@ -746,8 +875,11 @@ void sit9531x_dpll_changes_check(struct sit9531x_dpll *sitdpll) bool changed; u8 prio; - if (!sit9531x_dpll_is_selection_pin(pin)) + if (!sit9531x_dpll_is_selection_pin(pin)) { + pin->ntf_pending |= + sit9531x_dpll_output_ntf_pending(sitdev, pin); continue; + } sit9531x_dpll_pin_snapshot(sitdpll, pin, &state, &operstate, &prio); -- 2.39.2 (Apple Git-143)