How to implement recursion in this minesweeper program?

#include <stdio.h>
#include <stdbool.h>
#define ROW 16 //max number of rows 
#define COL 30 //max number of columns

void readBoard(int board[][COL], int m, int n);
void printBoard(int board[][COL], int m, int n);
int countNeighbour(int board[][COL], int r, int c, int m, int n);
bool isValid(int r, int c, int m, int n);
bool allCleared(int board[][COL], int m, int n);
void clearNeighbours(int board[][COL], int r, int c, int m, int n); 

int main(void) {
   int r, c, m, n, board[ROW][COL]={{0}}; //initializes all values to 0

   scanf("%d%d", &m, &n);
   readBoard(board, m, n); // reads the board.
   do {
      scanf("%d%d", &r, &c);     
      if(board[r][c] < 9  && isValid(r,c,m,n) == true) { // checks for mines presence and location validity
         if(countNeighbour(board, r, c, m, n) == 0) {
            clearNeighbours(board, r, c, m, n);
         }
      } else break; // escape the loop if the conditions are not fulfilled
   } while (allCleared(board,m,n) == false); // checks if all safe locations are cleared

   printBoard(board, m, n);
   return 0;
}

/* 
  allCleared checks the board and returns true if all safe locations
  have been cleared, false otherwise.
*/
bool allCleared(int board[][COL], int m, int n) {
   int i,j;
   for(i=0; i<m; i++) {
      for(j=0; j<n; j++) {
         if(board[i][j] == -1) {
            return false;
         }
      }
   }
   return true;
}

/* 
  isValid checks if the input location is valid or not.
*/
bool isValid(int r, int c, int m, int n) {
   if(r>=0 && r<=m && c>=0 && c<=n) {
      return true;
   }
   return false;
}   

/* 
 readBoard reads the input of the location of the mines and safe locations
 and stores the values inside an array.
 Precondition: the input values must be either -1 or 9.
*/
void readBoard(int board[][COL], int m, int n) {
   int i,j;
   for(i=0; i<m; i++) {
      for(j=0; j<n; j++) {
         scanf("%d", &board[i][j]);
      }
   }
}

/* 
 printBoard prints the minesweeper board. "*" represents mines 
 and "." represents safe locations. Numbers from 0 to 8 represents
 the number of mines present in the neighbouring cells.
*/
void printBoard(int board[][COL], int m, int n) {
   int i, j;
   for(i=0; i<m; i++) {
      for(j=0; j<n; j++) {
         if(board[i][j] == -1) {
            printf(".");
         }
         else if( board[i][j] >= 9) {
            printf("*");
         } else {
            printf("%d", board[i][j]);
         }
      }
      printf("\n");
   }
}

/* 
  countNeighbour checks the specified location for neighbouring mines,
  returns the number of mines present. P.S: I hard coded this part during the lab
  so I had no choice but to leave it as it is.
  Precondition: the specified location is inside the board
*/
int countNeighbour(int board[][COL], int r, int c, int m, int n) {
   if(board[r][c]!=-1) return board[r][c]; //returns if the location contains a mine or it has been checked
   
   if(isValid(r-1,c,m,n) && board[r-1][c] == 9) {
      board[r][c]++;
   }  
   if(isValid(r-1,c-1,m,n) && board[r-1][c-1] == 9) {
      board[r][c]++;
   }
   if(isValid(r,c-1,m,n) && board[r][c-1] == 9) {
      board[r][c]++;
   }
   if(isValid(r+1,c+1,m,n) && board[r+1][c+1] == 9) {
      board[r][c]++;
   }
   if(isValid(r,c+1,m,n) && board[r][c+1] == 9) {
      board[r][c]++;
   }
   if(isValid(r+1,c,m,n) && board[r+1][c] == 9) {
      board[r][c]++;
   }
   if(isValid(r+1,c-1,m,n) && board[r+1][c-1] == 9) {
      board[r][c]++;
   }
   if(isValid(r-1,c+1,m,n) && board[r-1][c+1] == 9) {
      board[r][c]++;
   }

   board[r][c]++; //since safe locations are denoted by -1, increments regardless of mines' presence.
   return board[r][c];
}

/* 
 clearNeighbours clear neighbouring cells, while making sure
 that they are inside the board. Calls itself repeatedly until
 all possible neighboring cells are cleared
 Precondition: the input location must be a safe location.
*/
void clearNeighbours(int board[][COL], int r, int c, int m, int n) {
   int row[] = {1,0,-1,0,1,1,-1,-1}; //temp array to check all 8 neighbouring cells row
   int col[] = {0,1,0,-1,1,-1,1,-1}; //temp array to check the column
   int i;

   countNeighbour(board,r,c,m,n);
   if(board[r][c] != 8) return;  
   for(i = 0;i<8;i++) { //loop terminates if all neighboring safe cells are cleared 
      int nextRow =  r + row[i], nextCol = c + col[i];
      if(isValid(nextRow,nextCol,m,n) && board[r][c] == -1) {
         clearNeighbours(board,nextRow,nextCol,m,n); //clears the safe cells repeatedly
      }
   }
}