Interfaz SPI en Xilinx FPGA, dominios de reloj y restricciones de tiempo

Estoy conectando una placa Raspberry Pi a una placa de desarrollo con un Spartan 6. Quiero hacer esto usando SPI. Debido a la forma en que está diseñada la placa de desarrollo, necesito conectar SPI CLK y DATA a los pines IO estándar.

Soy consciente de la necesidad de cruzar dominios de reloj con doble búfer para protegerse contra la metaestabilidad. El RPi y el SPI CLK están obviamente en un dominio separado del tejido FPGA interno. No veo demasiado problema: solo un registro de 8 bits y la señal que dice cuando un byte está listo deben sincronizarse con el reloj de estructura interno. No estoy tratando de obtener altas tasas de datos. Solo se escribirá un byte cada 25 us (esto se debe a que el RPi es lento para leer un GPIO, pero no hay problema para este proyecto). Estoy pensando en sincronizar el SPI a 15 MHz, e incluso podría reducirlo si fuera necesario.

Este es mi verilog. Simula y prueba bien en banco.

module my_spi_in (
  // RPI clock domain
  input i_RPI_spi_data,
  input i_RPI_spi_clk,
  input i_RPI_reset,
  // internal 64MHz domain
  input i_sys_clk,
  output [7:0] o_data,
  output o_fifo_write
);

  // registers in RPI clock domain
  reg [7:0] r_RPI_shift_in = 8'b0;
  reg [2:0] r_RPI_ctr = 3'b0;
  reg r_RPI_word_done = 1'b0;

  // synchronisation registers
  reg [7:0]r_data_sync_1 = 8'b0;
  reg [7:0]r_data_sync_2 = 8'b0;
  reg [2:0] r_word_done_sync = 3'b0;

  // RPI clock domain : input shift register logic
  always @ (posedge i_RPI_spi_clk, posedge i_RPI_reset) begin
    if (i_RPI_reset == 1'b1) begin
      r_RPI_shift_in <= 8'b0;
      r_RPI_ctr <= 3'b0;
    end else begin
      r_RPI_ctr <= r_RPI_ctr + 1'b1;
      r_RPI_shift_in <= {i_RPI_spi_data, r_RPI_shift_in[7:1]};
    end
  end

  // RPI clock domain : word done
  always @ (negedge i_RPI_spi_clk) begin
    if (~i_RPI_reset && r_RPI_ctr == 3'b000) r_RPI_word_done <= 1'b1;
    else r_RPI_word_done <= 1'b0;
  end

  // sync registers
  always @ (posedge i_sys_clk) begin
    r_data_sync_1 <= r_RPI_shift_in;
    r_data_sync_2 <= r_data_sync_1;
    r_word_done_sync[0] <= r_RPI_word_done;
    r_word_done_sync[1] <= r_word_done_sync[0];
    r_word_done_sync[2] <= r_word_done_sync[1];
  end

  assign o_data = r_data_sync_2;
  assign o_fifo_write = r_word_done_sync[1] && ~r_word_done_sync[2];
endmodule

En mi archivo .ucf solo tengo lo siguiente, para decirle a ISE que este no es un reloj "real" (no se construirá sin esto):

NET "i_RPI_spi_clk" CLOCK_DEDICATED_ROUTE = FALSE;
NET "i_RPI_reset" CLOCK_DEDICATED_ROUTE = FALSE;

Mi pregunta: ¿es este el mejor enfoque? ¿Necesito hacer algo más? (Idealmente, sería bueno establecer también algunas restricciones de tiempo para el reloj y los datos SPI, para que las herramientas sean conscientes de la velocidad de la interfaz SPI).

Gracias de antemano por tu consejo.

EDITAR: Debo dejar en claro que el RPi solo está transfiriendo un solo byte antes de verificar un pin GPIO. Esto resulta ser lento (toma alrededor de 25 us), por lo que nunca hay dos bytes consecutivos en el bus SPI. Hay actividad SPI durante unos 0,5 us (un byte a 15 MHz), luego no pasa nada durante unos 24 us hasta que el RPi ha leído el GPIO. Obviamente, esto es mucho más lento de lo que SPI es capaz de hacer: el tiempo de lectura de RPi está ralentizando bastante la transferencia, pero esto es bastante aceptable para este sistema.