static int eukrea_cpuimx25_devices_init(void)
{
eukrea_cpuimx25_mmu_init();
mxc_iomux_v3_setup_multiple_pads(eukrea_cpuimx25_pads,
ARRAY_SIZE(eukrea_cpuimx25_pads));
register_device(&fec_dev);
nand_info.width = 1;
register_device(&nand_dev);
devfs_add_partition("nand0", 0x00000, 0x40000,
PARTITION_FIXED, "self_raw");
dev_add_bb_dev("self_raw", "self0");
devfs_add_partition("nand0", 0x40000, 0x20000,
PARTITION_FIXED, "env_raw");
dev_add_bb_dev("env_raw", "env0");
register_device(&sdram0_dev);
/* enable LCD */
gpio_direction_output(26, 1);
gpio_set_value(26, 1);
register_device(&imxfb_dev);
armlinux_add_dram(&sdram0_dev);
armlinux_set_bootparams((void *)0x80000100);
armlinux_set_architecture(MACH_TYPE_EUKREA_CPUIMX25);
return 0;
}
void init_qsdk_module(void)
{
dev_init_t uart;
dev_init_t pmc;
dev_init_t uotghs;
dev_init_t arduino;
uart.name = "arduinodue_uart";
uart.dev_init = uart_init;
uart.dev_inst = uart_inst;
uart.dev_delete = NULL;
register_device(&uart);
pmc.name = "arduinodue_pmc";
pmc.dev_init = pmc_init;
pmc.dev_inst = pmc_inst;
pmc.dev_delete = NULL;
register_device(&pmc);
uotghs.name = "arduinodue_uotghs";
uotghs.dev_init = uotghs_init;
uotghs.dev_inst = uotghs_inst;
uotghs.dev_delete = NULL;
register_device(&uotghs);
arduino.name = "arduino_board";
arduino.dev_init = arduino_board_init;
arduino.dev_inst = arduino_board_inst;
arduino.dev_delete = NULL;
register_board(&arduino);
}
static int nhk8815_devices_init(void)
{
st8815_add_device_sdram(64 * 1024 *1024);
writel(0xC37800F0, NOMADIK_GPIO1_BASE + 0x20);
writel(0x00000000, NOMADIK_GPIO1_BASE + 0x24);
writel(0x00000000, NOMADIK_GPIO1_BASE + 0x28);
writel(readl(NOMADIK_SRC_BASE) | 0x8000, NOMADIK_SRC_BASE);
/* Set up SMCS1 for Ethernet: sram-like, enabled, timing values */
writel(0x0000305b, FSMC_BCR(1));
writel(0x00033f33, FSMC_BTR(1));
register_device(&nhk8815_network_dev);
register_device(&nhk8815_nand_device);
armlinux_set_architecture(MACH_TYPE_NOMADIK);
armlinux_set_bootparams((void *)(0x00000100));
devfs_add_partition("nand0", 0x0000000, 0x040000, PARTITION_FIXED, "xloader_raw");
devfs_add_partition("nand0", 0x0040000, 0x080000, PARTITION_FIXED, "meminit_raw");
devfs_add_partition("nand0", 0x0080000, 0x200000, PARTITION_FIXED, "self_raw");
dev_add_bb_dev("self_raw", "self0");
devfs_add_partition("nand0", 0x7FE0000, 0x020000, PARTITION_FIXED, "env_raw");
dev_add_bb_dev("env_raw", "env0");
return 0;
}
static int scb9328_devices_init(void) {
imx_gpio_mode(PA23_PF_CS5);
/* CS3 becomes CS3 by clearing reset default bit 1 in FMCR */
FMCR = 0x1;
CS0U = 0x000F2000;
CS0L = 0x11110d01;
CS1U = 0x000F0a00;
CS1L = 0x11110601;
CS2U = 0x0;
CS2L = 0x0;
CS3U = 0x000FFFFF;
CS3L = 0x00000303;
CS4U = 0x000F0a00;
CS4L = 0x11110301;
CS5U = 0x00008400;
CS5L = 0x00000D03;
register_device(&cfi_dev);
register_device(&sdram_dev);
register_device(&dm9000_dev);
devfs_add_partition("nor0", 0x00000, 0x20000, PARTITION_FIXED, "self0");
devfs_add_partition("nor0", 0x40000, 0x20000, PARTITION_FIXED, "env0");
protect_file("/dev/env0", 1);
armlinux_add_dram(&sdram_dev);
armlinux_set_bootparams((void *)0x08000100);
armlinux_set_architecture(MACH_TYPE_SCB9328);
return 0;
}
static int devices_init (void)
{
register_device(&cfi_dev);
register_device(&sdram_dev);
register_device(ð_dev);
devfs_add_partition("nor0", 0x00f00000, 0x40000, PARTITION_FIXED, "self0");
devfs_add_partition("nor0", 0x00f60000, 0x20000, PARTITION_FIXED, "env0");
return 0;
}
void st8815_register_uart(unsigned id)
{
switch (id) {
case 0:
nmdk_clk_create(&st8815_clk_48, dev_name(&uart0_serial_device));
register_device(&uart0_serial_device);
break;
case 1:
nmdk_clk_create(&st8815_clk_48, dev_name(&uart1_serial_device));
register_device(&uart1_serial_device);
break;
}
}
static int eukrea_cpuimx27_console_init(void)
{
#ifdef CONFIG_DRIVER_SERIAL_IMX
register_device(&eukrea_cpuimx27_serial_device);
#endif
/* configure 8 bit UART on cs3 */
FMCR &= ~0x2;
CS3U = 0x0000D603;
CS3L = 0x0D1D0D01;
CS3A = 0x00D20000;
#ifdef CONFIG_DRIVER_SERIAL_NS16550
register_device(&quad_uart_serial_device);
#endif
return 0;
}
/****************************************************************************
NAME
connectionAuthSetTrustLevel
FUNCTION
This function is called to set the trust level of a device stored in the
trusted device list. The Blustack Security Manager is updated with the
change.
RETURNS
TRUE is record updated, otherwise FALSE
*/
uint16 connectionAuthSetTrustLevel(cl_dm_bt_version version, const bdaddr* peer_bd_addr, uint16 trusted)
{
/* Holds the position of a device in the trusted device list (TDL) */
uint16 rec = 0;
TrustedDeviceRecordType record;
/* Search for the device in the TDL */
rec = find_trusted_device(peer_bd_addr);
/* If the device is in the TDL */
if(rec)
{
rec--;
/* Read the record */
(void)PsRetrieve(TRUSTED_DEVICE_LIST_BASE + rec, &record, sizeof(TrustedDeviceRecordType));
/* Update the trust level */
record.trusted = trusted;
/* Store the record */
(void)PsStore(TRUSTED_DEVICE_LIST_BASE + rec, &record, sizeof(TrustedDeviceRecordType));
/* Update Bluestack Security Manager Database */
register_device(version, &record);
/* Record updated */
return TRUE;
}
/* Record for this device does not exist */
return FALSE;
}
int main() {
ARMDevice uart;
UARTInterface *inter;
uart.base_addr = 0xFFFB0000;
uart.size = sizeof(UARTInterface);
strcpy(uart.name, "uart");
if(register_device(&uart, &valueWritten, &uart) == -1) {
perror("register_device");
exit(1);
}
inter = (UARTInterface *)uart.memory;
inter->US_IMR = 0x0;
inter->US_RHR = 0x0;
inter->US_BRGR = 0x0;
inter->US_RTOR = 0x0;
inter->US_TTGR = 0x0;
inter->US_FIDI = 0x174;
inter->US_IF = 0x0;
while(1) {}
return 0;
}
static struct state *state_new(const char *name)
{
struct state *state;
int ret;
state = xzalloc(sizeof(*state));
safe_strncpy(state->dev.name, name, MAX_DRIVER_NAME);
state->name = state->dev.name;
state->dev.id = DEVICE_ID_SINGLE;
INIT_LIST_HEAD(&state->variables);
ret = register_device(&state->dev);
if (ret) {
pr_err("Failed to register state device %s, %d\n", name, ret);
free(state);
return ERR_PTR(ret);
}
state->dirty = 1;
dev_add_param_bool(&state->dev, "dirty", NULL, NULL, &state->dirty,
NULL);
state->save_on_shutdown = 1;
dev_add_param_bool(&state->dev, "save_on_shutdown", NULL, NULL,
&state->save_on_shutdown, NULL);
list_add_tail(&state->list, &state_list);
return state;
}
bool_t register_i2c(struct device_t ** device, struct i2c_t * i2c)
{
struct device_t * dev;
if(!i2c || !i2c->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(i2c->name);
dev->type = DEVICE_TYPE_I2C;
dev->priv = i2c;
dev->kobj = kobj_alloc_directory(dev->name);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
static int load_config(const char *config,PLISTINFO pDevList)
{
FILE *fp = NULL;
int cnt = 0;
PLIST link = NULL;
char so_name[256];
fp = fopen(config,"r");
if(!fp) return -DEV_FAIL;
while(1)
{
if(fgets(so_name,256,fp))
{
strip_illegal_char(so_name);
if(so_name[0] == '#')
{
continue;
}
if(register_device(so_name) >= 0 && ++ cnt);
}
else
break;
}
fclose(fp);
return cnt;
}
/**
* ubi_add_volume - add volume.
* @ubi: UBI device description object
* @vol: volume description object
*
* This function adds an existing volume and initializes all its data
* structures. Returns zero in case of success and a negative error code in
* case of failure.
*/
int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
{
int err = 0;
dbg_gen("add volume");
sprintf(vol->dev.name, "%s.%s", dev_name(&ubi->dev), vol->name);
vol->dev.id = DEVICE_ID_SINGLE;
vol->dev.parent = &ubi->dev;
err = register_device(&vol->dev);
if (err)
return err;
/* Register character device for the volume */
err = ubi_volume_cdev_add(ubi, vol);
if (err) {
ubi_err(ubi, "cannot add character device for volume, error %d",
err);
return err;
}
self_check_volumes(ubi);
return err;
return err;
}
status_t device_init( int nDeviceID )
{
int nError;
int nHandle;
printk( "Keyboard device: device_init() called\n" );
g_sVolume.hWaitThread = -1;
atomic_set( &g_sVolume.nInPos, 0 );
atomic_set( &g_sVolume.nOutPos, 0 );
atomic_set( &g_sVolume.nBytesReceived, 0 );
atomic_set( &g_sVolume.nOpenCount, 0 );
g_sVolume.nIrqHandle = request_irq( 1, kbd_irq, NULL, 0, "keyboard_device", NULL );
g_nKbdLedStatus = 0;
if ( g_sVolume.nIrqHandle < 0 ) {
printk( "ERROR : Failed to initiate keyboard interrupt handler\n" );
return( g_sVolume.nIrqHandle );
}
nHandle = register_device( "", "system" );
claim_device( nDeviceID, nHandle , "Keyboard", DEVICE_INPUT );
nError = create_device_node( nDeviceID, nHandle, "keybd", &g_sOperations, NULL );
return( nError );
}
bool_t register_block(struct device_t ** device, struct block_t * blk)
{
struct device_t * dev;
if(!blk || !blk->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(blk->name);
dev->type = DEVICE_TYPE_BLOCK;
dev->priv = blk;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "size", block_read_size, NULL, blk);
kobj_add_regular(dev->kobj, "count", block_read_count, NULL, blk);
kobj_add_regular(dev->kobj, "capacity", block_read_capacity, NULL, blk);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
/**
* mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
* @bus: target mii_bus
*
* Description: Called by a bus driver to bring up all the PHYs
* on a given bus, and attach them to the bus.
*
* Returns 0 on success or < 0 on error.
*/
int mdiobus_register(struct mii_bus *bus)
{
int err;
if (NULL == bus ||
NULL == bus->read ||
NULL == bus->write)
return -EINVAL;
bus->dev.priv = bus;
bus->dev.id = DEVICE_ID_DYNAMIC;
strcpy(bus->dev.name, "miibus");
bus->dev.parent = bus->parent;
err = register_device(&bus->dev);
if (err) {
pr_err("mii_bus %s failed to register\n", bus->dev.name);
return -EINVAL;
}
if (bus->reset)
bus->reset(bus);
pr_info("%s: probed\n", dev_name(&bus->dev));
return 0;
}
void
diskflat_device_register(void)
{
const char *device_prefix_list[] = { "diskflat", NULL };
register_device(diskflat_device_factory, device_prefix_list);
}
bool_t register_buzzer(struct device_t ** device, struct buzzer_t * buzzer)
{
struct device_t * dev;
if(!buzzer || !buzzer->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(buzzer->name);
dev->type = DEVICE_TYPE_BUZZER;
dev->priv = buzzer;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "frequency", buzzer_read_frequency, buzzer_write_frequency, buzzer);
kobj_add_regular(dev->kobj, "play", NULL, buzzer_write_play, buzzer);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
bool_t register_watchdog(struct watchdog_t * watchdog)
{
struct device_t * dev;
if(!watchdog || !watchdog->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(watchdog->name);
dev->type = DEVICE_TYPE_WATCHDOG;
dev->suspend = watchdog_suspend;
dev->resume = watchdog_resume;
dev->driver = watchdog;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "timeout", watchdog_read_timeout, watchdog_write_timeout, watchdog);
if(watchdog->init)
(watchdog->init)(watchdog);
if(watchdog->set)
(watchdog->set)(watchdog, 0);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
return TRUE;
}
bool_t register_stepper(struct device_t ** device, struct stepper_t * m)
{
struct device_t * dev;
if(!m || !m->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(m->name);
dev->type = DEVICE_TYPE_STEPPER;
dev->driver = NULL;
dev->priv = m;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "enable", NULL, stepper_write_enable, m);
kobj_add_regular(dev->kobj, "disable", NULL, stepper_write_disable, m);
kobj_add_regular(dev->kobj, "move", NULL, stepper_write_move, m);
kobj_add_regular(dev->kobj, "busying", stepper_read_busying, NULL, m);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
bool_t register_input(struct device_t ** device, struct input_t * input)
{
struct device_t * dev;
if(!input || !input->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(input->name);
dev->type = DEVICE_TYPE_INPUT;
dev->driver = NULL;
dev->priv = input;
dev->kobj = kobj_alloc_directory(dev->name);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
static int nhk8815_devices_init(void)
{
writel(0xC37800F0, NOMADIK_GPIO1_BASE + 0x20);
writel(0x00000000, NOMADIK_GPIO1_BASE + 0x24);
writel(0x00000000, NOMADIK_GPIO1_BASE + 0x28);
writel(readl(NOMADIK_SRC_BASE) | 0x8000, NOMADIK_SRC_BASE);
/* Set up SMCS1 for Ethernet: sram-like, enabled, timing values */
writel(0x0000305b, FSMC_BCR(1));
writel(0x00033f33, FSMC_BTR(1));
add_generic_device("smc91c111", DEVICE_ID_DYNAMIC, NULL, 0x34000300, 16,
IORESOURCE_MEM, NULL);
register_device(&nhk8815_nand_device);
armlinux_set_architecture(MACH_TYPE_NOMADIK);
armlinux_set_bootparams((void *)(0x00000100));
devfs_add_partition("nand0", 0x0000000, 0x040000, DEVFS_PARTITION_FIXED, "xloader_raw");
devfs_add_partition("nand0", 0x0040000, 0x080000, DEVFS_PARTITION_FIXED, "meminit_raw");
devfs_add_partition("nand0", 0x0080000, 0x200000, DEVFS_PARTITION_FIXED, "self_raw");
dev_add_bb_dev("self_raw", "self0");
devfs_add_partition("nand0", 0x7FE0000, 0x020000, DEVFS_PARTITION_FIXED, "env_raw");
dev_add_bb_dev("env_raw", "env0");
return 0;
}
bool_t register_ledtrig(struct device_t ** device, struct ledtrig_t * ledtrig)
{
struct device_t * dev;
if(!ledtrig || !ledtrig->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(ledtrig->name);
dev->type = DEVICE_TYPE_LEDTRIG;
dev->priv = ledtrig;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "activity", NULL, ledtrig_write_activity, ledtrig);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
bool_t register_light(struct device_t ** device,struct light_t * light)
{
struct device_t * dev;
if(!light || !light->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(light->name);
dev->type = DEVICE_TYPE_LIGHT;
dev->driver = NULL;
dev->priv = light;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "illuminance", light_read_illuminance, NULL, light);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
bool_t register_ledtrig(struct ledtrig_t * trigger)
{
struct device_t * dev;
if(!trigger || !trigger->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(trigger->name);
dev->type = DEVICE_TYPE_LEDTRIG;
dev->suspend = ledtrig_suspend;
dev->resume = ledtrig_resume;
dev->driver = trigger;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "led", ledtrig_read_bind_led_name, NULL, trigger);
kobj_add_regular(dev->kobj, "activity", NULL, ledtrig_write_activity, trigger);
if(trigger->init)
(trigger->init)(trigger);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
return TRUE;
}
bool_t register_rtc(struct device_t ** device, struct rtc_t * rtc)
{
struct device_t * dev;
if(!rtc || !rtc->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(rtc->name);
dev->type = DEVICE_TYPE_RTC;
dev->priv = rtc;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "time", rtc_time_read, rtc_time_write, rtc);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
int miiphy_register(struct miiphy_device *mdev)
{
mdev->dev.priv = mdev;
strcpy(mdev->dev.name, "miiphy");
return register_device(&mdev->dev);
}
bool_t register_led(struct device_t ** device, struct led_t * led)
{
struct device_t * dev;
if(!led || !led->name)
return FALSE;
dev = malloc(sizeof(struct device_t));
if(!dev)
return FALSE;
dev->name = strdup(led->name);
dev->type = DEVICE_TYPE_LED;
dev->priv = led;
dev->kobj = kobj_alloc_directory(dev->name);
kobj_add_regular(dev->kobj, "brightness", led_read_brightness, led_write_brightness, led);
kobj_add_regular(dev->kobj, "max_brightness", led_read_max_brightness, NULL, led);
if(!register_device(dev))
{
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return FALSE;
}
if(device)
*device = dev;
return TRUE;
}
static int parse_cmdline(char *devname, char *szstart, char *szlength)
{
char *buffer;
unsigned long devstart;
unsigned long devlength;
if ((!devname) || (!szstart) || (!szlength)) {
unregister_devices();
return(-EINVAL);
}
devstart = simple_strtoul(szstart, &buffer, 0);
devstart = handle_unit(devstart, buffer);
if (*(szlength) != '+') {
devlength = simple_strtoul(szlength, &buffer, 0);
devlength = handle_unit(devlength, buffer) - devstart;
} else {
devlength = simple_strtoul(szlength + 1, &buffer, 0);
devlength = handle_unit(devlength, buffer);
}
T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
devname, devstart, devlength);
if ((devstart < 0) || (devlength < 0) || (devlength % SLRAM_BLK_SZ != 0)) {
E("slram: Illegal start / length parameter.\n");
return(-EINVAL);
}
if ((devstart = register_device(devname, devstart, devlength))){
unregister_devices();
return((int)devstart);
}
return(0);
}
static int __init alsa_seq_oss_init(void)
{
int rc;
if ((rc = register_device()) < 0)
goto error;
if ((rc = register_proc()) < 0) {
unregister_device();
goto error;
}
if ((rc = snd_seq_oss_create_client()) < 0) {
unregister_proc();
unregister_device();
goto error;
}
rc = snd_seq_driver_register(&seq_oss_synth_driver);
if (rc < 0) {
snd_seq_oss_delete_client();
unregister_proc();
unregister_device();
goto error;
}
/* success */
snd_seq_oss_synth_init();
error:
return rc;
}
