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;
}
