Using a preprocessor macro to wrap functions?

Does this work? Yes, probably. By using variadic macros, the usual errors about commas in the arguments will not occur. However, this approach might not be very good for debuggability – this will depend a lot on your particular tools though.

The best and most maintainable solution to do resource management is to write that part of the code in C++, so that you can use the RAII idiom, or at least use templates and lambdas. C++ has features that avoid common pitfalls with macros.

But let's say we have to stick with C. The most C-ish solution would likely be to not write that macro at all. If cleanup is needed after a section, it would be called explicitly. C culture is somewhat opposed to such abstractions.

But we can use the macro system to write a better abstraction that doesn't rely on passing the contents as macro arguments. For example, we might enable usage such as:

WITH_CHIP_SELECTED {
  BeginTheBeguine();
  GetOutOfTown();
  BrushUpYourShakespeare();
  DontFencMeIn();
}

This can be achieved by writing a for-loop that executes once. Roughly:

ChipSelect(true);
for (bool _with_chip_selected_once = true
    ; _with_chip_selected_once
    ; _with_chip_selected_once = false, ChipSelect(false)
    ) {
  ...
}

A simpler but less ergonomic alternative would be to expect the inner section to be defined as a separate function, then:

WITH_CHIP_SELECTED(do_stuff(context));

Which I'd implement with the idiomatic do-while-false wrapper:

#define WITH_CHIP_SELECTED(call) \
  do { \
    ChipSelect(true); call; ChipSelect(false); \
  } while (0)

Yes, this would happen to allow multiple statements, but it is intended for a different usage style.