I have an 8-bit microcontroller with 100 pins. Each pin belongs to a port with a unique address and each pin has a number from 0 to 7. I want to create a scheme where in the code each pin is a struct that carries the pin's port address and number with it. I have defined a pin_t struct in gpio.h.

/*gpio.h */
typedef enum {INPUT = 0, INPUT_PULLUP = 1, OUTPUT = 2} gpio_mode_t;
typedef enum {LOW = 0, HIGH = 1} gpio_value_t;

typedef struct
{
    volatile uint8_t *const port_addr; //const pointer that points to volatile register
    const uint8_t pin_number;
} pin_t;

void pin_mode(const pin_t* pin, gpio_mode_t mode);
void digital_write(const pin_t* pin, gpio_value_t value);

Then, I have pins.c in which all the pin definitions are made. The port address and pin number should not be changed anywhere else in the program.

/* pins.c */
#include "gpio.h"
pin_t D1  = {.port_addr = &PORTG, .pin_number = 5};
pin_t D2  = {.port_addr = &PORTE, .pin_number = 0};
/* more definitions below ...*/

Then I have pins.h that declares each pin extern.

/*pins.h */
extern pin_t D1;
extern pin_t D2;
/* more below ...*/

Such that I in main.c can do things like this

/* main.c */
#include "pins.h"
int main(void)
{
    pin_mode(&D1, OUTPUT);
    for(;;) {}
}

Question 1: As far as I understand it, declaring variables as extern in pins.h makes them visible to source files that include pins.h, and I need not define them again. But to be honest, I'm not sure why I need extern in the first place. I get a compiler error if I remove it, saying there are multiple definitions of the pins in main.o. And with the same logic, shouldn't the function prototypes in gpio.h also be extern for my source files to see them?

Question 2: Is this the appropriate way to share variables across multiple files for an embedded system?