void machine_at_wd76c10_init(const machine_t *model) { machine_at_common_ide_init(model); device_add(&keyboard_ps2_quadtel_device); wd76c10_fdc = device_add(&fdc_at_device); wd76c10_uart[0] = device_add_inst(&i8250_device, 1); wd76c10_uart[1] = device_add_inst(&i8250_device, 2); wd76c10_init(); device_add(¶dise_wd90c11_megapc_device); }
void tandy1ksl2_init() { // TANDY = 1; common_init(); mem_add_bios(); keyboard_tandy_init(); mouse_serial_init(); device_add(&pssj_device); xtide_init(); nmi_init(); device_add(&tandy_rom_device); device_add(&tandy_eeprom_device); device_add(&gameport_device); }
void tandy1k_init() { TANDY = 1; common_init(); keyboard_tandy_init(); mouse_serial_init(); if (romset == ROM_TANDY) device_add(&sn76489_device); else device_add(&ncr8496_device); xtide_init(); nmi_init(); if (romset != ROM_TANDY) device_add(&tandy_eeprom_device); }
struct ssd *ssdmodel_ssd_loadparams(struct lp_block *b, int *num) { /* temp vars for parameters */ int n; struct ssd *result; if(!disksim->ssdinfo) ssd_initialize_diskinfo(); result = malloc(sizeof(struct ssd)); if(!result) return 0; bzero(result, sizeof(struct ssd)); n = ssd_add(result); result->hdr = ssd_hdr_initializer; if(b->name) result->hdr.device_name = _strdup(b->name); lp_loadparams(result, b, &ssdmodel_ssd_mod); device_add((struct device_header *)result, n); if (num != NULL) *num = n; return result; }
/* * Internal function. Register a new MMC card with the driver model. */ int mmc_register_card(struct mmc_card *card) { snprintf(card->dev.bus_id, sizeof(card->dev.bus_id), "%s:%04x", card->host->host_name, card->rca); return device_add(&card->dev); }
/* * Init/exit code for the module. Basically, creates/removes /sys/class/rc */ int __init edac_mc_sysfs_init(void) { int err; mci_pdev = kzalloc(sizeof(*mci_pdev), GFP_KERNEL); if (!mci_pdev) { err = -ENOMEM; goto out; } mci_pdev->bus = edac_get_sysfs_subsys(); mci_pdev->type = &mc_attr_type; device_initialize(mci_pdev); dev_set_name(mci_pdev, "mc"); err = device_add(mci_pdev); if (err < 0) goto out_dev_free; edac_dbg(0, "device %s created\n", dev_name(mci_pdev)); return 0; out_dev_free: kfree(mci_pdev); out: return err; }
/* * Register a new MMC card with the driver model. */ int mmc_add_card(struct mmc_card *card) { int ret; const char *type; dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca); switch (card->type) { case MMC_TYPE_MMC: type = "MMC"; break; case MMC_TYPE_SD: type = "SD"; if (mmc_card_blockaddr(card)) { if (mmc_card_ext_capacity(card)) type = "SDXC"; else type = "SDHC"; } break; case MMC_TYPE_SDIO: type = "SDIO"; break; case MMC_TYPE_SD_COMBO: type = "SD-combo"; if (mmc_card_blockaddr(card)) type = "SDHC-combo"; break; default: type = "?"; break; } if (mmc_host_is_spi(card->host)) { printk(KERN_INFO "%s: new %s%s%s card on SPI\n", mmc_hostname(card->host), mmc_card_highspeed(card) ? "high speed " : "", mmc_card_ddr_mode(card) ? "DDR " : "", type); } else { printk(KERN_INFO "%s: new %s%s%s card at address %04x\n", mmc_hostname(card->host), mmc_sd_card_uhs(card) ? "ultra high speed " : (mmc_card_highspeed(card) ? "high speed " : ""), mmc_card_ddr_mode(card) ? "DDR " : "", type, card->rca); } #ifdef CONFIG_DEBUG_FS mmc_add_card_debugfs(card); #endif ret = device_add(&card->dev); if (ret) return ret; mmc_card_set_present(card); return 0; }
static void * sio_detect_init(const device_t *info) { sio_detect_t *dev = (sio_detect_t *) malloc(sizeof(sio_detect_t)); memset(dev, 0, sizeof(sio_detect_t)); device_add(&fdc_at_smc_device); io_sethandler(0x0024, 0x0004, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x002e, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x0044, 0x0004, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x004e, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x0108, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x0250, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x0370, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); io_sethandler(0x03f0, 0x0002, sio_detect_read, NULL, NULL, sio_detect_write, NULL, NULL, dev); return dev; }
void midi_device_init() { if (devices[midi_device_current].device) device_add(devices[midi_device_current].device); midi_device_last = midi_device_current; }
int iio_trigger_register(struct iio_trigger *trig_info) { int ret; trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL); if (trig_info->id < 0) return trig_info->id; /* Set the name used for the sysfs directory etc */ dev_set_name(&trig_info->dev, "trigger%ld", (unsigned long) trig_info->id); ret = device_add(&trig_info->dev); if (ret) goto error_unregister_id; /* Add to list of available triggers held by the IIO core */ mutex_lock(&iio_trigger_list_lock); list_add_tail(&trig_info->list, &iio_trigger_list); mutex_unlock(&iio_trigger_list_lock); return 0; error_unregister_id: ida_simple_remove(&iio_trigger_ida, trig_info->id); return ret; }
/** * spmi_add_device: Add a new device without register board info. * @spmi_dev: spmi_device to be added (registered). * * Called when device doesn't have an explicit client-driver to be probed, or * the client-driver is a module installed dynamically. */ int spmi_add_device(struct spmi_device *spmidev) { int rc; struct device *dev = get_valid_device(spmidev); if (!dev) { pr_err("invalid SPMI device\n"); return -EINVAL; } //#ifdef CONFIG_ZTEMT_HW_VERSION if(strncmp(spmidev->name,"qpnp-ztemt_hw_version",strlen("qpnp-ztemt_hw_version"))==0) { dev_set_name(dev, "%s", spmidev->name); }else{ /* Set the device name */ dev_set_name(dev, "%s-%p", spmidev->name, spmidev); } //#else // /* Set the device name */ // dev_set_name(dev, "%s-%p", spmidev->name, spmidev); //#endif /* Device may be bound to an active driver when this returns */ rc = device_add(dev); if (rc < 0) dev_err(dev, "Can't add %s, status %d\n", dev_name(dev), rc); else dev_dbg(dev, "device %s registered\n", dev_name(dev)); return rc; }
/* Create a DIMM object under specifed memory controller device */ static int edac_create_dimm_object(struct mem_ctl_info *mci, struct dimm_info *dimm, int index) { int err; dimm->mci = mci; dimm->dev.type = &dimm_attr_type; dimm->dev.bus = mci->bus; device_initialize(&dimm->dev); dimm->dev.parent = &mci->dev; if (mci->csbased) dev_set_name(&dimm->dev, "rank%d", index); else dev_set_name(&dimm->dev, "dimm%d", index); dev_set_drvdata(&dimm->dev, dimm); pm_runtime_forbid(&mci->dev); err = device_add(&dimm->dev); edac_dbg(0, "creating rank/dimm device %s\n", dev_name(&dimm->dev)); return err; }
/* * Init/exit code for the module. Basically, creates/removes /sys/class/rc */ int __init edac_mc_sysfs_init(void) { struct bus_type *edac_subsys; int err; /* get the /sys/devices/system/edac subsys reference */ edac_subsys = edac_get_sysfs_subsys(); if (edac_subsys == NULL) { edac_dbg(1, "no edac_subsys\n"); return -EINVAL; } mci_pdev = kzalloc(sizeof(*mci_pdev), GFP_KERNEL); mci_pdev->bus = edac_subsys; mci_pdev->type = &mc_attr_type; device_initialize(mci_pdev); dev_set_name(mci_pdev, "mc"); err = device_add(mci_pdev); if (err < 0) return err; edac_dbg(0, "device %s created\n", dev_name(mci_pdev)); return 0; }
void register_disk(struct gendisk *disk) { struct device *ddev = disk_to_dev(disk); struct block_device *bdev; struct disk_part_iter piter; struct hd_struct *part; int err; #ifdef MY_ABC_HERE int error; #endif ddev->parent = disk->driverfs_dev; dev_set_name(ddev, disk->disk_name); /* delay uevents, until we scanned partition table */ dev_set_uevent_suppress(ddev, 1); if (device_add(ddev)) return; #ifdef MY_ABC_HERE if (ddev->parent) { char *class_name; class_name = make_class_name(ddev->class->name, &ddev->kobj); if (class_name) { error = sysfs_create_link(&ddev->parent->kobj, &ddev->kobj, class_name); } kfree(class_name); }
int rmi_register_function(struct rmi_function *fn) { struct rmi_device *rmi_dev = fn->rmi_dev; int error; device_initialize(&fn->dev); dev_set_name(&fn->dev, "%s.fn%02x", dev_name(&rmi_dev->dev), fn->fd.function_number); fn->dev.parent = &rmi_dev->dev; fn->dev.type = &rmi_function_type; fn->dev.bus = &rmi_bus_type; error = device_add(&fn->dev); if (error) { dev_err(&rmi_dev->dev, "Failed device_register function device %s\n", dev_name(&fn->dev)); goto err_put_device; } rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n", fn->fd.function_number); return 0; err_put_device: put_device(&fn->dev); return error; }
zx_status_t PlatformBus::Create(zx_device_t* parent, const char* name, zx::vmo zbi) { // This creates the "sys" device. sys_device_proto.version = DEVICE_OPS_VERSION; device_add_args_t args = {}; args.version = DEVICE_ADD_ARGS_VERSION; args.name = "sys"; args.ops = &sys_device_proto; args.flags = DEVICE_ADD_NON_BINDABLE; // Add child of sys for the board driver to bind to. auto status = device_add(parent, &args, &parent); if (status != ZX_OK) { return status; } fbl::AllocChecker ac; fbl::unique_ptr<platform_bus::PlatformBus> bus(new (&ac) platform_bus::PlatformBus(parent)); if (!ac.check()) { return ZX_ERR_NO_MEMORY; } status = bus->Init(std::move(zbi)); if (status != ZX_OK) { return status; } // devmgr is now in charge of the device. __UNUSED auto* dummy = bus.release(); return ZX_OK; }
/** * ufs_bsg_probe - Add ufs bsg device node * @hba: per adapter object * * Called during initial loading of the driver, and before scsi_scan_host. */ int ufs_bsg_probe(struct ufs_hba *hba) { struct device *bsg_dev = &hba->bsg_dev; struct Scsi_Host *shost = hba->host; struct device *parent = &shost->shost_gendev; struct request_queue *q; int ret; device_initialize(bsg_dev); bsg_dev->parent = get_device(parent); bsg_dev->release = ufs_bsg_node_release; dev_set_name(bsg_dev, "ufs-bsg"); ret = device_add(bsg_dev); if (ret) goto out; q = bsg_setup_queue(bsg_dev, dev_name(bsg_dev), ufs_bsg_request, NULL, 0); if (IS_ERR(q)) { ret = PTR_ERR(q); goto out; } hba->bsg_queue = q; return 0; out: dev_err(bsg_dev, "fail to initialize a bsg dev %d\n", shost->host_no); put_device(bsg_dev); return ret; }
void at_sis496_init() { at_init(); mouse_serial_init(); pci_init(PCI_CONFIG_TYPE_1, 0, 31); device_add(&sis496_device); }
struct simpledisk *disksim_simpledisk_loadparams(struct lp_block *b) { /* temp vars for parameters */ struct simpledisk *result; int num; if(!disksim->simplediskinfo) simpledisk_initialize_diskinfo(); result = malloc(sizeof(struct simpledisk)); if(!result) return 0; bzero(result, sizeof(struct simpledisk)); num = simpledisk_add(result); result->hdr = simpledisk_hdr_initializer; if(b->name) result->hdr.device_name = strdup(b->name); #include "modules/disksim_simpledisk_param.c" device_add((struct device_header *)result, num); return result; }
int iio_trigger_register(struct iio_trigger *trig_info) { int ret; ret = iio_trigger_register_id(trig_info); if (ret) goto error_ret; /* Set the name used for the sysfs directory etc */ dev_set_name(&trig_info->dev, "trigger%ld", (unsigned long) trig_info->id); ret = device_add(&trig_info->dev); if (ret) goto error_unregister_id; ret = iio_trigger_register_sysfs(trig_info); if (ret) goto error_device_del; /* Add to list of available triggers held by the IIO core */ mutex_lock(&iio_trigger_list_lock); list_add_tail(&trig_info->list, &iio_trigger_list); mutex_unlock(&iio_trigger_list_lock); return 0; error_device_del: device_del(&trig_info->dev); error_unregister_id: iio_trigger_unregister_id(trig_info); error_ret: return ret; }
/** * mcb_device_register() - Register a mcb_device * @bus: The @mcb_bus of the device * @dev: The @mcb_device * * Register a specific @mcb_device at a @mcb_bus and the system itself. */ int mcb_device_register(struct mcb_bus *bus, struct mcb_device *dev) { int ret; int device_id; device_initialize(&dev->dev); dev->dev.bus = &mcb_bus_type; dev->dev.parent = bus->dev.parent; dev->dev.release = mcb_release_dev; device_id = dev->id; dev_set_name(&dev->dev, "mcb%d-16z%03d-%d:%d:%d", bus->bus_nr, device_id, dev->inst, dev->group, dev->var); ret = device_add(&dev->dev); if (ret < 0) { pr_err("Failed registering device 16z%03d on bus mcb%d (%d)\n", device_id, bus->bus_nr, ret); goto out; } return 0; out: return ret; }
static int drm_minor_register(struct drm_device *dev, unsigned int type) { struct drm_minor *minor; unsigned long flags; int ret; DRM_DEBUG("\n"); minor = *drm_minor_get_slot(dev, type); if (!minor) return 0; ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); if (ret) { DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); return ret; } ret = device_add(minor->kdev); if (ret) goto err_debugfs; /* replace NULL with @minor so lookups will succeed from now on */ spin_lock_irqsave(&drm_minor_lock, flags); idr_replace(&drm_minors_idr, minor, minor->index); spin_unlock_irqrestore(&drm_minor_lock, flags); DRM_DEBUG("new minor registered %d\n", minor->index); return 0; err_debugfs: drm_debugfs_cleanup(minor); return ret; }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero), m_watchdog_vblank_count(0), m_watchdog_time(attotime::zero), m_nvram_handler(NULL), m_memcard_handler(NULL), m_default_layout(NULL), m_gamedrv(gamedrv), m_options(options) { // construct the config (*gamedrv.machine_config)(*this, NULL, NULL); bool is_selected_driver = mame_stricmp(gamedrv.name,options.system_name())==0; // intialize slot devices - make sure that any required devices have been allocated slot_interface_iterator slotiter(root_device()); for (device_slot_interface *slot = slotiter.first(); slot != NULL; slot = slotiter.next()) { device_t &owner = slot->device(); astring temp; const char *selval = options.main_value(temp, owner.tag()+1); bool isdefault = (options.priority(owner.tag()+1)==OPTION_PRIORITY_DEFAULT); if (!is_selected_driver || !options.exists(owner.tag()+1)) selval = slot->default_option(); if (selval != NULL && *selval != 0) { const device_slot_option *option = slot->option(selval); if (option && (isdefault || option->selectable())) { device_t *new_dev = device_add(&owner, option->name(), option->devtype(), option->clock()); const char *default_bios = option->default_bios(); if (default_bios != NULL) device_t::static_set_default_bios_tag(*new_dev, default_bios); machine_config_constructor additions = option->machine_config(); if (additions != NULL) (*additions)(const_cast<machine_config &>(*this), new_dev, new_dev); const input_device_default *input_device_defaults = option->input_device_defaults(); if (input_device_defaults) device_t::static_set_input_default(*new_dev, input_device_defaults); } else throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval, owner.tag()+1); } } // when finished, set the game driver driver_device::static_set_game(*m_root_device, gamedrv); // then notify all devices that their configuration is complete device_iterator iter(root_device()); for (device_t *device = iter.first(); device != NULL; device = iter.next()) if (!device->configured()) device->config_complete(); }
/* * Register a new MMC card with the driver model. */ int mmc_add_card(struct mmc_card *card) { int ret; const char *type; snprintf(card->dev.bus_id, sizeof(card->dev.bus_id), "%s:%04x", mmc_hostname(card->host), card->rca); switch (card->type) { case MMC_TYPE_MMC: type = "MMC"; break; case MMC_TYPE_SD: type = "SD"; if (mmc_card_blockaddr(card)) type = "SDHC"; break; case MMC_TYPE_SDIO: type = "SDIO"; break; default: type = "?"; break; } if (mmc_host_is_spi(card->host)) { printk(KERN_INFO "%s: new %s%s card on SPI\n", mmc_hostname(card->host), mmc_card_highspeed(card) ? "high speed " : "", type); } else { printk(KERN_INFO "%s: new %s%s card at address %04x\n", mmc_hostname(card->host), mmc_card_highspeed(card) ? "high speed " : "", type, card->rca); } card->dev.uevent_suppress = 1; ret = device_add(&card->dev); if (ret) return ret; if (card->host->bus_ops->sysfs_add) { ret = card->host->bus_ops->sysfs_add(card->host, card); if (ret) { device_del(&card->dev); return ret; } } card->dev.uevent_suppress = 0; kobject_uevent(&card->dev.kobj, KOBJ_ADD); mmc_card_set_present(card); return 0; }
/** * tb_domain_add() - Add domain to the system * @tb: Domain to add * * Starts the domain and adds it to the system. Hotplugging devices will * work after this has been returned successfully. In order to remove * and release the domain after this function has been called, call * tb_domain_remove(). * * Return: %0 in case of success and negative errno in case of error */ int tb_domain_add(struct tb *tb) { int ret; if (WARN_ON(!tb->cm_ops)) return -EINVAL; mutex_lock(&tb->lock); tb->ctl = tb_ctl_alloc(tb->nhi, tb_domain_event_cb, tb); if (!tb->ctl) { ret = -ENOMEM; goto err_unlock; } /* * tb_schedule_hotplug_handler may be called as soon as the config * channel is started. Thats why we have to hold the lock here. */ tb_ctl_start(tb->ctl); if (tb->cm_ops->driver_ready) { ret = tb->cm_ops->driver_ready(tb); if (ret) goto err_ctl_stop; } ret = device_add(&tb->dev); if (ret) goto err_ctl_stop; /* Start the domain */ if (tb->cm_ops->start) { ret = tb->cm_ops->start(tb); if (ret) goto err_domain_del; } /* This starts event processing */ mutex_unlock(&tb->lock); pm_runtime_no_callbacks(&tb->dev); pm_runtime_set_active(&tb->dev); pm_runtime_enable(&tb->dev); pm_runtime_set_autosuspend_delay(&tb->dev, TB_AUTOSUSPEND_DELAY); pm_runtime_mark_last_busy(&tb->dev); pm_runtime_use_autosuspend(&tb->dev); return 0; err_domain_del: device_del(&tb->dev); err_ctl_stop: tb_ctl_stop(tb->ctl); err_unlock: mutex_unlock(&tb->lock); return ret; }
void ps1_common_init() { AT = 1; common_init(); mem_add_bios(); pit_set_out_func(1, pit_refresh_timer_at); dma16_init(); ide_init(); keyboard_at_init(); mouse_ps2_init(); nvr_init(); pic2_init(); fdc_set_dskchg_activelow(); device_add(&ps1_audio_device); /*PS/1 audio uses ports 200h and 202-207h, so only initialise gameport on 201h*/ device_add(&gameport_201_device); }
/* * Reset the network card(s). * * This function is called each time the system is reset, * either a hard reset (including power-up) or a soft reset * including C-A-D reset.) It is responsible for connecting * everything together. */ void network_reset(void) { int i = -1; #ifdef ENABLE_NIC_LOG network_log("NETWORK: reset (type=%d, card=%d) debug=%d\n", network_type, network_card, nic_do_log); #else network_log("NETWORK: reset (type=%d, card=%d)\n", network_type, network_card); #endif ui_sb_update_icon(SB_NETWORK, 0); /* Just in case.. */ network_close(); /* If no active card, we're done. */ if ((network_type==NET_TYPE_NONE) || (network_card==0)) return; network_mutex = thread_create_mutex(L"VARCem.NetMutex"); /* Initialize the platform module. */ switch(network_type) { case NET_TYPE_PCAP: i = net_pcap_init(); break; case NET_TYPE_SLIRP: i = net_slirp_init(); break; } if (i < 0) { /* Tell user we can't do this (at the moment.) */ ui_msgbox(MBX_ERROR, (wchar_t *)IDS_2102); // FIXME: we should ask in the dialog if they want to // reconfigure or quit, and throw them into the // Settings dialog if yes. /* Disable network. */ network_type = NET_TYPE_NONE; return; } network_log("NETWORK: set up for %s, card='%s'\n", (network_type==NET_TYPE_SLIRP)?"SLiRP":"Pcap", net_cards[network_card].name); /* Add the (new?) card to the I/O system. */ if (net_cards[network_card].device) { network_log("NETWORK: adding device '%s'\n", net_cards[network_card].name); device_add(net_cards[network_card].device); } }
/* * Register a new MMC card with the driver model. */ int mmc_add_card(struct mmc_card *card) { int ret; const char *type; #ifdef CONFIG_HUAWEI_KERNEL mdelay(100); #endif dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca); switch (card->type) { case MMC_TYPE_MMC: type = "MMC"; break; case MMC_TYPE_SD: type = "SD"; if (mmc_card_blockaddr(card)) type = "SDHC"; break; case MMC_TYPE_SDIO: type = "SDIO"; break; default: type = "?"; break; } if (mmc_host_is_spi(card->host)) { printk(KERN_INFO "%s: new %s%s card on SPI\n", mmc_hostname(card->host), mmc_card_highspeed(card) ? "high speed " : "", type); } else { printk(KERN_INFO "%s: new %s%s card at address %04x\n", mmc_hostname(card->host), mmc_card_highspeed(card) ? "high speed " : "", type, card->rca); } #ifdef CONFIG_HUAWEI_KERNEL if(MMC_TYPE_SD == card->type) { hw_extern_sdcard_insert(); } #endif ret = device_add(&card->dev); if (ret) return ret; #ifdef CONFIG_DEBUG_FS mmc_add_card_debugfs(card); #endif mmc_card_set_present(card); return 0; }
/* * * linux usb function * */ static int usbhsg_gadget_start(struct usb_gadget_driver *driver, int (*bind)(struct usb_gadget *)) { struct usbhsg_gpriv *gpriv; struct usbhs_priv *priv; struct device *dev; int ret; if (!bind || !driver || !driver->setup || driver->speed != USB_SPEED_HIGH) return -EINVAL; /* * find unused controller */ usbhsg_for_each_controller(gpriv) { if (!gpriv->driver) goto find_unused_controller; } return -ENODEV; find_unused_controller: dev = usbhsg_gpriv_to_dev(gpriv); priv = usbhsg_gpriv_to_priv(gpriv); /* first hook up the driver ... */ gpriv->driver = driver; gpriv->gadget.dev.driver = &driver->driver; ret = device_add(&gpriv->gadget.dev); if (ret) { dev_err(dev, "device_add error %d\n", ret); goto add_fail; } ret = bind(&gpriv->gadget); if (ret) { dev_err(dev, "bind to driver %s error %d\n", driver->driver.name, ret); goto bind_fail; } dev_dbg(dev, "bind %s\n", driver->driver.name); return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD); bind_fail: device_del(&gpriv->gadget.dev); add_fail: gpriv->driver = NULL; gpriv->gadget.dev.driver = NULL; return ret; }
int nvhost_device_register(struct nvhost_device *dev) { int i, ret = 0; if (!dev) return -EINVAL; device_initialize(&dev->dev); /* If the dev does not have a parent, assign host1x as parent */ if (!dev->dev.parent && nvhost && nvhost->dev != dev) dev->dev.parent = &nvhost->dev->dev; dev->dev.bus = &nvhost_bus_type; if (dev->id != -1) dev_set_name(&dev->dev, "%s.%d", dev->name, dev->id); else dev_set_name(&dev->dev, "%s", dev->name); for (i = 0; i < dev->num_resources; i++) { struct resource *p, *r = &dev->resource[i]; if (r->name == NULL) r->name = dev_name(&dev->dev); p = r->parent; if (!p) { if (resource_type(r) == IORESOURCE_MEM) p = &iomem_resource; else if (resource_type(r) == IORESOURCE_IO) p = &ioport_resource; } if (p && insert_resource(p, r)) { pr_err("%s: failed to claim resource %d\n", dev_name(&dev->dev), i); ret = -EBUSY; goto failed; } } ret = device_add(&dev->dev); if (ret == 0) return ret; failed: while (--i >= 0) { struct resource *r = &dev->resource[i]; unsigned long type = resource_type(r); if (type == IORESOURCE_MEM || type == IORESOURCE_IO) release_resource(r); } return ret; }