static void fpgaZebulonDeviceRelease( struct device *pdev ) {}


//
// Zebulon I2C device
//
static struct resource i2cZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_I2C_OFF,
        .end    = FPGA_ZEBULON_I2C_OFF + FPGA_ZEBULON_I2C_SIZE,
        .flags  = IORESOURCE_MEM,
    },
    [1] = {
        .start  = 0,
        .end    = 0,
        .flags  = IORESOURCE_IRQ,
    },
};


static struct platform_device i2cZebulonDevice = {
    .name       	= FPGA_ZEBULON_I2C_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( i2cZebulonResources ),
    .resource   	= i2cZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon Expander device
//
static struct resource expZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_EXP_OFF,
        .end    = FPGA_ZEBULON_EXP_OFF + FPGA_ZEBULON_EXP_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device expZebulonDevice = {
    .name       	= FPGA_ZEBULON_EXP_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( expZebulonResources ),
    .resource   	= expZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon Psoc device
//
static struct resource psocZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_PSOC_OFF,
        .end    = FPGA_ZEBULON_PSOC_OFF + FPGA_ZEBULON_PSOC_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device psocZebulonDevice = {
    .name       	= FPGA_ZEBULON_PSOC_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( psocZebulonResources ),
    .resource   	= psocZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon Nvsram device
//
static struct resource nvsramZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_NVSRAM_OFF,
        .end    = FPGA_ZEBULON_NVSRAM_OFF + FPGA_ZEBULON_NVSRAM_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device nvsramZebulonDevice = {
    .name       	= FPGA_ZEBULON_NVSRAM_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( nvsramZebulonResources ),
    .resource   	= nvsramZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon UART MUX device
//
static struct resource uartmuxZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_UARTMUX_OFF,
        .end    = FPGA_ZEBULON_UARTMUX_OFF + FPGA_ZEBULON_UARTMUX_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device uartmuxZebulonDevice = {
    .name       	= FPGA_ZEBULON_UARTMUX_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( uartmuxZebulonResources ),
    .resource   	= uartmuxZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon Reset device
//
static struct resource resetZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_RESET_OFF,
        .end    = FPGA_ZEBULON_RESET_OFF + FPGA_ZEBULON_RESET_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device resetZebulonDevice = {
    .name       	= FPGA_ZEBULON_RESET_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( resetZebulonResources ),
    .resource   	= resetZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon LED device
//
static struct resource ledZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_LED_OFF,
        .end    = FPGA_ZEBULON_LED_OFF + FPGA_ZEBULON_LED_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device ledZebulonDevice = {
    .name       	= FPGA_ZEBULON_LED_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( ledZebulonResources ),
    .resource   	= ledZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon EPP device
//
static struct resource eppZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_EPP_OFF,
        .end    = FPGA_ZEBULON_EPP_OFF + FPGA_ZEBULON_EPP_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device eppZebulonDevice = {
    .name       	= FPGA_ZEBULON_EPP_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( eppZebulonResources ),
    .resource   	= eppZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon ID device
//
static struct resource idZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_ID_OFF,
        .end    = FPGA_ZEBULON_ID_OFF + FPGA_ZEBULON_ID_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device idZebulonDevice = {
    .name       	= FPGA_ZEBULON_ID_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( idZebulonResources ),
    .resource   	= idZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon CWT device
//
static struct resource cwtZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_CWT_OFF,
        .end    = FPGA_ZEBULON_CWT_OFF + FPGA_ZEBULON_CWT_SIZE,
        .flags  = IORESOURCE_MEM,
    },
    [1] = {
        .start  = 0,
        .end    = 0,
        .flags  = IORESOURCE_IRQ,
    },
};


static struct platform_device cwtZebulonDevice = {
    .name       	= FPGA_ZEBULON_CWT_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( cwtZebulonResources ),
    .resource   	= cwtZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon BBU device
//
static struct resource bbuZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_BBU_OFF,
        .end    = FPGA_ZEBULON_BBU_OFF + FPGA_ZEBULON_BBU_SIZE,
        .flags  = IORESOURCE_MEM,
    },
};


static struct platform_device bbuZebulonDevice = {
    .name       	= FPGA_ZEBULON_BBU_NAME,
    .id				= 0,
    .num_resources  = ARRAY_SIZE( bbuZebulonResources ),
    .resource   	= bbuZebulonResources,
	.dev.release    = fpgaZebulonDeviceRelease,
};


//
// Zebulon UART device
//
static struct resource uartZebulonResources[] = {
    [0] = {
        .start  = FPGA_ZEBULON_UART_OFF,
        .end    = FPGA_ZEBULON_UART_OFF + FPGA_ZEBULON_UART_SIZE,
        .flags  = IORESOURCE_MEM,
    },
    [1] = {
        .start  = 0,
        .end    = 0,
        .flags  = IORESOURCE_IRQ,
    },
};


static struct platform_device uartZebulonDevice = {
    .name           = FPGA_ZEBULON_UART_NAME,
    .id             = 0,
    .num_resources  = ARRAY_SIZE( uartZebulonResources ),
    .resource       = uartZebulonResources,
    .dev.release    = fpgaZebulonDeviceRelease,
};

static struct platform_device *fpgaSubdevices[] __initdata = {

    &i2cZebulonDevice,
	&expZebulonDevice,
	&psocZebulonDevice,
	&uartmuxZebulonDevice,
	&resetZebulonDevice,
	&ledZebulonDevice,
	&eppZebulonDevice,
	&idZebulonDevice,
	&cwtZebulonDevice,
	&bbuZebulonDevice,
	&uartZebulonDevice,
};


static struct platform_device *fpgaNvsram[] __initdata = {

	&nvsramZebulonDevice,
};