tree b0a8678fc9c49f0fed451dc47f77276f8c6e8a59
parent a39e65e9cc935b84f35d080e934c3fdd9ff86654
author Lars-Peter Clausen <lars@metafoo.de> 1404984389 +0200
committer Mark Brown <broonie@linaro.org> 1405085966 +0100

spi: cadence: Configure SPI clock in the prepare_message() callback

Currently the cadence SPI driver does the SPI clock configuration (setup CPOL
and CPHA) in the prepare_transfer_hardware() callback. The
prepare_transfer_hardware() callback is only called though when the controller
transitions from a idle state to a non-idle state. Such a transitions happens
when the message queue goes from empty to non-empty. If multiple messages from
different SPI slaves with different clock settings are in the message queue the
clock settings will not be properly updated when switching from one slave device
to another. Instead do the updating of the clock configuration in the
prepare_message() callback which will be called for each individual message.

Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@linaro.org>
