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; }
static int imx_ocotp_probe(struct device_d *dev) { struct resource *iores; void __iomem *base; struct ocotp_priv *priv; int ret = 0; struct imx_ocotp_data *data; ret = dev_get_drvdata(dev, (const void **)&data); if (ret) return ret; iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) return PTR_ERR(iores); base = IOMEM(iores->start); imx_ocotp_init_dt(dev, base); priv = xzalloc(sizeof(*priv)); priv->base = base; priv->clk = clk_get(dev, NULL); if (IS_ERR(priv->clk)) return PTR_ERR(priv->clk); strcpy(priv->dev.name, "ocotp"); priv->dev.parent = dev; register_device(&priv->dev); priv->map_config.reg_bits = 32; priv->map_config.val_bits = 32; priv->map_config.reg_stride = 4; priv->map_config.max_register = data->num_regs - 1; priv->map = regmap_init(dev, &imx_ocotp_regmap_bus, priv, &priv->map_config); if (IS_ERR(priv->map)) return PTR_ERR(priv->map); ret = regmap_register_cdev(priv->map, "imx-ocotp"); if (ret) return ret; if (IS_ENABLED(CONFIG_IMX_OCOTP_WRITE)) { dev_add_param_bool(&(priv->dev), "permanent_write_enable", NULL, NULL, &priv->permanent_write_enable, NULL); } if (IS_ENABLED(CONFIG_NET)) dev_add_param_mac(&(priv->dev), "mac_addr", imx_ocotp_set_mac, imx_ocotp_get_mac, priv->ethaddr, priv); dev_add_param_bool(&(priv->dev), "sense_enable", NULL, NULL, &priv->sense_enable, priv); return 0; }
static int mxs_ocotp_probe(struct device_d *dev) { int err; struct ocotp_priv *priv = xzalloc(sizeof (*priv)); priv->base = dev_request_mem_region(dev, 0); if (IS_ERR(priv->base)) return PTR_ERR(priv->base); priv->clk = clk_get(dev, NULL); if (IS_ERR(priv->clk)) return PTR_ERR(priv->clk); priv->cdev.dev = dev; priv->cdev.ops = &mxs_ocotp_ops; priv->cdev.priv = priv; priv->cdev.size = cpu_is_mx23() ? 128 : 160; priv->cdev.name = DRIVERNAME; err = devfs_create(&priv->cdev); if (err < 0) return err; if (IS_ENABLED(CONFIG_MXS_OCOTP_WRITABLE)) { mxs_ocotp_ops.write = mxs_ocotp_cdev_write; dev_add_param_bool(dev, "permanent_write_enable", NULL, NULL, &priv->write_enable, NULL); } return 0; }
/** * Register an ATA drive behind an IDE like interface * @param dev The interface device * @param io ATA register file description * @return 0 on success */ int ata_port_register(struct ata_port *port) { int ret; if (port->devname) { strcpy(port->class_dev.name, port->devname); port->class_dev.id = DEVICE_ID_SINGLE; } else { strcpy(port->class_dev.name, "ata"); port->class_dev.id = DEVICE_ID_DYNAMIC; } port->class_dev.parent = port->dev; port->class_dev.detect = ata_detect; ret = register_device(&port->class_dev); if (ret) return ret; dev_add_param_bool(&port->class_dev, "probe", ata_set_probe, NULL, &port->probe, port); return ret; }
int register_framebuffer(struct fb_info *info) { int id = get_free_deviceid("fb"); struct device_d *dev; int ret, num_modes, i; const char **names; dev = &info->dev; /* * If info->mode is set at this point it's the only mode * the fb supports. move it over to the modes list. */ if (info->mode) { info->modes.modes = info->mode; info->modes.num_modes = 1; } if (!info->line_length) info->line_length = info->xres * (info->bits_per_pixel >> 3); info->cdev.ops = &fb_ops; info->cdev.name = basprintf("fb%d", id); info->cdev.size = info->line_length * info->yres; info->cdev.dev = dev; info->cdev.priv = info; dev->resource = xzalloc(sizeof(struct resource)); dev->resource[0].start = (resource_size_t)info->screen_base; dev->resource[0].end = dev->resource[0].start + info->cdev.size - 1; dev->resource[0].flags = IORESOURCE_MEM; dev->num_resources = 1; dev->priv = info; dev->id = id; dev->info = fb_info; dev_set_name(dev, "fb"); ret = register_device(&info->dev); if (ret) goto err_free; dev_add_param_bool(dev, "enable", fb_enable_set, NULL, &info->p_enable, info); if (IS_ENABLED(CONFIG_DRIVER_VIDEO_EDID)) fb_edid_add_modes(info); num_modes = info->modes.num_modes + info->edid_modes.num_modes; names = xzalloc(sizeof(char *) * num_modes); for (i = 0; i < info->modes.num_modes; i++) names[i] = info->modes.modes[i].name; for (i = 0; i < info->edid_modes.num_modes; i++) names[i + info->modes.num_modes] = info->edid_modes.modes[i].name; dev_add_param_enum(dev, "mode_name", fb_set_modename, NULL, &info->current_mode, names, num_modes, info); info->shadowfb = 1; dev_add_param_bool(dev, "shadowfb", fb_set_shadowfb, NULL, &info->shadowfb, info); info->mode = fb_num_to_mode(info, 0); fb_setup_mode(info); ret = devfs_create(&info->cdev); if (ret) goto err_unregister; if (IS_ENABLED(CONFIG_DRIVER_VIDEO_SIMPLEFB)) { ret = fb_register_simplefb(info); if (ret) dev_err(&info->dev, "failed to register simplefb: %s\n", strerror(-ret)); } if (IS_ENABLED(CONFIG_FRAMEBUFFER_CONSOLE)) register_fbconsole(info); return 0; err_unregister: unregister_device(&info->dev); err_free: free(dev->resource); return ret; }
static int imx_ocotp_probe(struct device_d *dev) { struct resource *iores; struct ocotp_priv *priv; int ret = 0; const struct imx_ocotp_data *data; struct nvmem_device *nvmem; ret = dev_get_drvdata(dev, (const void **)&data); if (ret) return ret; iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) return PTR_ERR(iores); priv = xzalloc(sizeof(*priv)); priv->data = data; priv->base = IOMEM(iores->start); priv->clk = clk_get(dev, NULL); if (IS_ERR(priv->clk)) return PTR_ERR(priv->clk); strcpy(priv->dev.name, "ocotp"); priv->dev.parent = dev; register_device(&priv->dev); priv->map_config.reg_bits = 32; priv->map_config.val_bits = 32; priv->map_config.reg_stride = 4; priv->map_config.max_register = data->num_regs - 1; priv->map = regmap_init(dev, &imx_ocotp_regmap_bus, priv, &priv->map_config); if (IS_ERR(priv->map)) return PTR_ERR(priv->map); priv->config.name = "imx-ocotp"; priv->config.dev = dev; priv->config.stride = 4; priv->config.word_size = 4; priv->config.size = data->num_regs; priv->config.bus = &imx_ocotp_nvmem_bus; dev->priv = priv; nvmem = nvmem_register(&priv->config); if (IS_ERR(nvmem)) return PTR_ERR(nvmem); imx_ocotp = priv; if (IS_ENABLED(CONFIG_IMX_OCOTP_WRITE)) { dev_add_param_bool(&(priv->dev), "permanent_write_enable", NULL, NULL, &priv->permanent_write_enable, NULL); } if (IS_ENABLED(CONFIG_NET)) { int i; struct ocotp_priv_ethaddr *ethaddr; for (i = 0; i < priv->data->mac_offsets_num; i++) { ethaddr = &priv->ethaddr[i]; ethaddr->map = priv->map; ethaddr->offset = priv->data->mac_offsets[i]; ethaddr->data = data; dev_add_param_mac(&priv->dev, xasprintf("mac_addr%d", i), imx_ocotp_set_mac, imx_ocotp_get_mac, ethaddr->value, ethaddr); } /* * Alias to mac_addr0 for backwards compatibility */ ethaddr = &priv->ethaddr[0]; dev_add_param_mac(&priv->dev, "mac_addr", imx_ocotp_set_mac, imx_ocotp_get_mac, ethaddr->value, ethaddr); } imx_ocotp_init_dt(priv); dev_add_param_bool(&(priv->dev), "sense_enable", NULL, NULL, &priv->sense_enable, priv); return 0; }