tree e6334627f11526c27e3e1d77da367e7e2caf5e69
parent f48ede4eb133f9cd44b3a2a4a98ea821611d74ae
author Anastasia Klimchuk <aklm@chromium.org> 1625440686 +1000
committer Nico Huber <nico.h@gmx.de> 1674995342 +0000

spi_master: Add shutdown function in spi_master struct

With this, register_spi_master can take care of register_shutdown
as well, and every spi master only needs to call register_spi_master
instead of calling both register_spi_master and register_shutdown.

Testing:
In dummyflasher, comment out free(data) in shutdown. Test fails with error:
../dummyflasher.c:949: note: block 0x55e0727a6e40 allocated here
ERROR: dummy_init_and_shutdown_test_success leaked 1 block(s)
Means, shutdown function is invoked for drivers with "old" API
(so, transitioning from old to new API is not breaking anything).

Next patches in the chain converts spi masters to use new API.

Tested: builds and ninja test

Change-Id: I2dc80dceca2f8204bcd0dad1f51753d7e79f1af5
Signed-off-by: Anastasia Klimchuk <aklm@chromium.org>
Original-Reviewed-on: https://review.coreboot.org/c/flashrom/+/55932
Original-Reviewed-by: Nico Huber <nico.h@gmx.de>
Reviewed-on: https://review.coreboot.org/c/flashrom-stable/+/72226
Reviewed-by: Nico Huber <nico.h@gmx.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
