static int __init snd_tscm_init(void)
{
return driver_register(&tscm_driver.driver);
}
static int __init ide_gd_init(void)
{
printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
return driver_register(&ide_gd_driver.gen_driver);
}
int s3c24xx_serial_init(struct device_driver *drv,
struct s3c24xx_uart_info *info)
{
dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
return driver_register(drv);
}
/**
* register_rpmsg_driver() - register an rpmsg driver with the rpmsg bus
* @rpdrv: pointer to a struct rpmsg_driver
*
* Returns 0 on success, and an appropriate error value on failure.
*/
int register_rpmsg_driver(struct rpmsg_driver *rpdrv)
{
rpdrv->drv.bus = &rpmsg_bus;
return driver_register(&rpdrv->drv);
}
static int __init fsl_i2c_init(void)
{
return driver_register(&fsl_i2c_driver);
}
/**
* sunxi_rsb_driver_register() - Register device driver with RSB core
* @rdrv: device driver to be associated with slave-device.
*
* This API will register the client driver with the RSB framework.
* It is typically called from the driver's module-init function.
*/
int sunxi_rsb_driver_register(struct sunxi_rsb_driver *rdrv)
{
rdrv->driver.bus = &sunxi_rsb_bus;
return driver_register(&rdrv->driver);
}
static int __init pxa2xx_ac97_init(void)
{
return driver_register(&pxa2xx_ac97_driver);
}
int mcp_driver_register(struct mcp_driver *mcpdrv)
{
mcpdrv->drv.bus = &mcp_bus_type;
return driver_register(&mcpdrv->drv);
}
int nvec_register_driver(struct nvec_driver *drv)
{
drv->driver.name = drv->name;
drv->driver.bus = &nvec_bus_type;
return driver_register(&drv->driver);
}
int htif_register_driver(struct htif_driver *drv)
{
drv->driver.bus = &htif_bus_type;
return driver_register(&drv->driver);
}
static int __init init_tcic(void)
{
int i, sock, ret = 0;
u_int mask, scan;
if (driver_register(&tcic_driver))
return -1;
printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
sock = 0;
if (!request_region(tcic_base, 16, "tcic-2")) {
printk("could not allocate ports,\n ");
driver_unregister(&tcic_driver);
return -ENODEV;
}
else {
tcic_setw(TCIC_ADDR, 0);
if (tcic_getw(TCIC_ADDR) == 0) {
tcic_setw(TCIC_ADDR, 0xc3a5);
if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
}
if (sock == 0) {
/* See if resetting the controller does any good */
tcic_setb(TCIC_SCTRL, TCIC_SCTRL_RESET);
tcic_setb(TCIC_SCTRL, 0);
tcic_setw(TCIC_ADDR, 0);
if (tcic_getw(TCIC_ADDR) == 0) {
tcic_setw(TCIC_ADDR, 0xc3a5);
if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
}
}
}
if (sock == 0) {
printk("not found.\n");
release_region(tcic_base, 16);
driver_unregister(&tcic_driver);
return -ENODEV;
}
sockets = 0;
for (i = 0; i < sock; i++) {
if ((i == ignore) || is_active(i)) continue;
socket_table[sockets].psock = i;
socket_table[sockets].id = get_tcic_id();
socket_table[sockets].socket.owner = THIS_MODULE;
/* only 16-bit cards, memory windows must be size-aligned */
/* No PCI or CardBus support */
socket_table[sockets].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN;
/* irq 14, 11, 10, 7, 6, 5, 4, 3 */
socket_table[sockets].socket.irq_mask = 0x4cf8;
/* 4K minimum window size */
socket_table[sockets].socket.map_size = 0x1000;
sockets++;
}
switch (socket_table[0].id) {
case TCIC_ID_DB86082:
printk("DB86082"); break;
case TCIC_ID_DB86082A:
printk("DB86082A"); break;
case TCIC_ID_DB86084:
printk("DB86084"); break;
case TCIC_ID_DB86084A:
printk("DB86084A"); break;
case TCIC_ID_DB86072:
printk("DB86072"); break;
case TCIC_ID_DB86184:
printk("DB86184"); break;
case TCIC_ID_DB86082B:
printk("DB86082B"); break;
default:
printk("Unknown ID 0x%02x", socket_table[0].id);
}
/* Set up polling */
poll_timer.function = &tcic_timer;
poll_timer.data = 0;
init_timer(&poll_timer);
/* Build interrupt mask */
printk(", %d sockets\n" KERN_INFO " irq list (", sockets);
if (irq_list_count == 0)
mask = irq_mask;
else
for (i = mask = 0; i < irq_list_count; i++)
mask |= (1<<irq_list[i]);
/* irq 14, 11, 10, 7, 6, 5, 4, 3 */
mask &= 0x4cf8;
/* Scan interrupts */
mask = irq_scan(mask);
for (i=0;i<sockets;i++)
socket_table[i].socket.irq_mask = mask;
/* Check for only two interrupts available */
scan = (mask & (mask-1));
if (((scan & (scan-1)) == 0) && (poll_interval == 0))
poll_interval = HZ;
if (poll_interval == 0) {
/* Avoid irq 12 unless it is explicitly requested */
u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
for (i = 15; i > 0; i--)
if ((cs_mask & (1 << i)) &&
(request_irq(i, tcic_interrupt, 0, "tcic",
tcic_interrupt) == 0))
break;
cs_irq = i;
if (cs_irq == 0) poll_interval = HZ;
}
if (socket_table[0].socket.irq_mask & (1 << 11))
printk("sktirq is irq 11, ");
if (cs_irq != 0)
printk("status change on irq %d\n", cs_irq);
else
printk("polled status, interval = %d ms\n",
poll_interval * 1000 / HZ);
for (i = 0; i < sockets; i++) {
tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT);
socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT);
}
/* jump start interrupt handler, if needed */
tcic_interrupt(0, NULL, NULL);
platform_device_register(&tcic_device);
for (i = 0; i < sockets; i++) {
socket_table[i].socket.ops = &tcic_operations;
socket_table[i].socket.resource_ops = &pccard_nonstatic_ops;
socket_table[i].socket.dev.dev = &tcic_device.dev;
ret = pcmcia_register_socket(&socket_table[i].socket);
if (ret && i)
pcmcia_unregister_socket(&socket_table[0].socket);
}
return ret;
return 0;
} /* init_tcic */
static int __init snd_oxfw_init(void)
{
return driver_register(&oxfw_driver.driver);
}
static int __init
h5400_ohci_init (void)
{
return driver_register (&h5400_usb_device_driver);
}
static int __init ucb1400_ts_init(void)
{
return driver_register(&ucb1400_ts_driver);
}
static int __init cpustate_init(void)
{
int rc;
rc = driver_register(&hdpu_cpustate_driver);
return rc;
}
int lm_driver_register(struct lm_driver *drv)
{
drv->drv.bus = &lm_bustype;
return driver_register(&drv->drv);
}
/*
=====================rsz_init===========================
function to register resizer character driver
*/
static __init int rsz_init(void)
{
int result;
/* Register the driver in the kernel */
result = alloc_chrdev_region(&dev, 0, 1, DRIVER_NAME);
if (result < 0) {
printk(KERN_ERR
"DaVinciresizer: could not register character device");
return -ENODEV;
}
/* Initialize of character device */
cdev_init(&c_dev, &rsz_fops);
c_dev.owner = THIS_MODULE;
c_dev.ops = &rsz_fops;
/* addding character device */
result = cdev_add(&c_dev, dev, 1);
if (result) {
printk(KERN_ERR
"DaVinciresizer:Error %d adding"
" Davinciresizer ..error no:",
result);
unregister_chrdev_region(dev, 1);
return result;
}
/* registeration of character device */
register_chrdev(MAJOR(dev), DRIVER_NAME, &rsz_fops);
/* register driver as a platform driver */
if (driver_register(&resizer_driver) != 0) {
unregister_chrdev_region(dev, 1);
cdev_del(&c_dev);
return -EINVAL;
}
/* Register the drive as a platform device */
if (platform_device_register(&resizer_device) != 0) {
driver_unregister(&resizer_driver);
unregister_chrdev_region(dev, 1);
unregister_chrdev(MAJOR(dev), DRIVER_NAME);
cdev_del(&c_dev);
return -EINVAL;
}
rsz_class = class_create(THIS_MODULE, "davinci_resizer");
if (!rsz_class) {
platform_device_unregister(&resizer_device);
cdev_del(&c_dev);
unregister_chrdev(MAJOR(dev), DRIVER_NAME);
return -EIO;
}
device_create(rsz_class, NULL, dev, NULL, "davinci_resizer");
rsz_dev.users = 0;
mutex_init(&rsz_dev.lock);
/* Initialize the serializer */
imp_init_serializer();
imp_hw_if = imp_get_hw_if();
printk(KERN_NOTICE "davinci_resizer initialized\n");
return 0;
} /* End of function resizer_init */
static int __init ide_gd_init(void)
{
;
return driver_register(&ide_gd_driver.gen_driver);
}
void test_driver_register(void)
{
driver_register(test_driver_ops.name, &test_driver_ops);
}
static int __init ixp4xx_flash_init(void)
{
return driver_register(&ixp4xx_flash_driver);
}
int __vlynq_register_driver(struct vlynq_driver *driver, struct module *owner)
{
driver->driver.name = driver->name;
driver->driver.bus = &vlynq_bus_type;
return driver_register(&driver->driver);
}
static int __init brf6150_init(void)
{
struct brf6150_info *info;
int irq, err;
info = kmalloc(sizeof(struct brf6150_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
memset(info, 0, sizeof(struct brf6150_info));
brf6150_device.dev.driver_data = info;
init_completion(&info->init_completion);
init_completion(&info->fw_completion);
info->pm_enabled = 0;
info->rx_pm_enabled = 0;
info->tx_pm_enabled = 0;
info->garbage_bytes = 0;
tasklet_init(&info->tx_task, brf6150_tx_tasklet, (unsigned long)info);
spin_lock_init(&info->lock);
skb_queue_head_init(&info->txq);
init_timer(&info->pm_timer);
info->pm_timer.function = brf6150_pm_timer;
info->pm_timer.data = (unsigned long)info;
exit_info = NULL;
info->btinfo = omap_get_config(OMAP_TAG_NOKIA_BT, struct omap_bluetooth_config);
if (info->btinfo == NULL)
return -1;
NBT_DBG("RESET gpio: %d\n", info->btinfo->reset_gpio);
NBT_DBG("BTWU gpio: %d\n", info->btinfo->bt_wakeup_gpio);
NBT_DBG("HOSTWU gpio: %d\n", info->btinfo->host_wakeup_gpio);
NBT_DBG("Uart: %d\n", info->btinfo->bt_uart);
NBT_DBG("sysclk: %d\n", info->btinfo->bt_sysclk);
err = omap_request_gpio(info->btinfo->reset_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line %d",
info->btinfo->reset_gpio);
kfree(info);
return err;
}
err = omap_request_gpio(info->btinfo->bt_wakeup_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line 0x%d",
info->btinfo->bt_wakeup_gpio);
omap_free_gpio(info->btinfo->reset_gpio);
kfree(info);
return err;
}
err = omap_request_gpio(info->btinfo->host_wakeup_gpio);
if (err < 0)
{
printk(KERN_WARNING "Cannot get GPIO line %d",
info->btinfo->host_wakeup_gpio);
omap_free_gpio(info->btinfo->reset_gpio);
omap_free_gpio(info->btinfo->bt_wakeup_gpio);
kfree(info);
return err;
}
omap_set_gpio_direction(info->btinfo->reset_gpio, 0);
omap_set_gpio_direction(info->btinfo->bt_wakeup_gpio, 0);
omap_set_gpio_direction(info->btinfo->host_wakeup_gpio, 1);
set_irq_type(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio), IRQ_TYPE_NONE);
switch (info->btinfo->bt_uart) {
case 1:
irq = INT_UART1;
info->uart_ck = clk_get(NULL, "uart1_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART1_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
case 2:
irq = INT_UART2;
info->uart_ck = clk_get(NULL, "uart2_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART2_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
case 3:
irq = INT_UART3;
info->uart_ck = clk_get(NULL, "uart3_ck");
/* FIXME: Use platform_get_resource for the port */
info->uart_base = ioremap(OMAP_UART3_BASE, 0x16);
if (!info->uart_base)
goto cleanup;
break;
default:
printk(KERN_ERR "No uart defined\n");
goto cleanup;
}
info->irq = irq;
err = request_irq(irq, brf6150_interrupt, 0, "brf6150", (void *)info);
if (err < 0) {
printk(KERN_ERR "brf6150: unable to get IRQ %d\n", irq);
goto cleanup;
}
err = request_irq(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio),
brf6150_wakeup_interrupt, 0, "brf6150_wkup", (void *)info);
if (err < 0) {
printk(KERN_ERR "brf6150: unable to get wakeup IRQ %d\n",
OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio));
free_irq(irq, (void *)info);
goto cleanup;
}
/* Register with LDM */
if (platform_device_register(&brf6150_device)) {
printk(KERN_ERR "failed to register brf6150 device\n");
err = -ENODEV;
goto cleanup_irq;
}
/* Register the driver with LDM */
if (driver_register(&brf6150_driver)) {
printk(KERN_WARNING "failed to register brf6150 driver\n");
platform_device_unregister(&brf6150_device);
err = -ENODEV;
goto cleanup_irq;
}
if (brf6150_register_hdev(info) < 0) {
printk(KERN_WARNING "failed to register brf6150 hci device\n");
platform_device_unregister(&brf6150_device);
driver_unregister(&brf6150_driver);
goto cleanup_irq;
}
exit_info = info;
return 0;
cleanup_irq:
free_irq(irq, (void *)info);
free_irq(OMAP_GPIO_IRQ(info->btinfo->host_wakeup_gpio), (void *)info);
cleanup:
omap_free_gpio(info->btinfo->reset_gpio);
omap_free_gpio(info->btinfo->bt_wakeup_gpio);
omap_free_gpio(info->btinfo->host_wakeup_gpio);
kfree(info);
return err;
}
static int __init
snd_bebob_init(void)
{
return driver_register(&bebob_driver.driver);
}
/* sa11x0_pcmcia_init()
* ^^^^^^^^^^^^^^^^^^^^
*
* This routine performs low-level PCMCIA initialization and then
* registers this socket driver with Card Services.
*
* Returns: 0 on success, -ve error code on failure
*/
static int __init sa11x0_pcmcia_init(void)
{
return driver_register(&sa11x0_pcmcia_driver);
}
static int __init init_nsc(void)
{
int rc = 0;
int lo, hi, err;
int nscAddrBase = TPM_ADDR;
struct tpm_chip *chip;
unsigned long base;
/* verify that it is a National part (SID) */
if (tpm_read_index(TPM_ADDR, NSC_SID_INDEX) != 0xEF) {
nscAddrBase = (tpm_read_index(TPM_SUPERIO_ADDR, 0x2C)<<8)|
(tpm_read_index(TPM_SUPERIO_ADDR, 0x2B)&0xFE);
if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6)
return -ENODEV;
}
err = driver_register(&nsc_drv);
if (err)
return err;
hi = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_HI);
lo = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_LO);
base = (hi<<8) | lo;
/* enable the DPM module */
tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
if (!pdev) {
rc = -ENOMEM;
goto err_unreg_drv;
}
pdev->name = "tpm_nscl0";
pdev->id = -1;
pdev->num_resources = 0;
pdev->dev.release = tpm_nsc_remove;
pdev->dev.driver = &nsc_drv;
if ((rc = platform_device_register(pdev)) < 0)
goto err_free_dev;
if (request_region(base, 2, "tpm_nsc0") == NULL ) {
rc = -EBUSY;
goto err_unreg_dev;
}
if (!(chip = tpm_register_hardware(&pdev->dev, &tpm_nsc))) {
rc = -ENODEV;
goto err_rel_reg;
}
dev_dbg(&pdev->dev, "NSC TPM detected\n");
dev_dbg(&pdev->dev,
"NSC LDN 0x%x, SID 0x%x, SRID 0x%x\n",
tpm_read_index(nscAddrBase,0x07), tpm_read_index(nscAddrBase,0x20),
tpm_read_index(nscAddrBase,0x27));
dev_dbg(&pdev->dev,
"NSC SIOCF1 0x%x SIOCF5 0x%x SIOCF6 0x%x SIOCF8 0x%x\n",
tpm_read_index(nscAddrBase,0x21), tpm_read_index(nscAddrBase,0x25),
tpm_read_index(nscAddrBase,0x26), tpm_read_index(nscAddrBase,0x28));
dev_dbg(&pdev->dev, "NSC IO Base0 0x%x\n",
(tpm_read_index(nscAddrBase,0x60) << 8) | tpm_read_index(nscAddrBase,0x61));
dev_dbg(&pdev->dev, "NSC IO Base1 0x%x\n",
(tpm_read_index(nscAddrBase,0x62) << 8) | tpm_read_index(nscAddrBase,0x63));
dev_dbg(&pdev->dev, "NSC Interrupt number and wakeup 0x%x\n",
tpm_read_index(nscAddrBase,0x70));
dev_dbg(&pdev->dev, "NSC IRQ type select 0x%x\n",
tpm_read_index(nscAddrBase,0x71));
dev_dbg(&pdev->dev,
"NSC DMA channel select0 0x%x, select1 0x%x\n",
tpm_read_index(nscAddrBase,0x74), tpm_read_index(nscAddrBase,0x75));
dev_dbg(&pdev->dev,
"NSC Config "
"0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
tpm_read_index(nscAddrBase,0xF0), tpm_read_index(nscAddrBase,0xF1),
tpm_read_index(nscAddrBase,0xF2), tpm_read_index(nscAddrBase,0xF3),
tpm_read_index(nscAddrBase,0xF4), tpm_read_index(nscAddrBase,0xF5),
tpm_read_index(nscAddrBase,0xF6), tpm_read_index(nscAddrBase,0xF7),
tpm_read_index(nscAddrBase,0xF8), tpm_read_index(nscAddrBase,0xF9));
dev_info(&pdev->dev,
"NSC TPM revision %d\n",
tpm_read_index(nscAddrBase, 0x27) & 0x1F);
chip->vendor.base = base;
return 0;
err_rel_reg:
release_region(base, 2);
err_unreg_dev:
platform_device_unregister(pdev);
err_free_dev:
kfree(pdev);
err_unreg_drv:
driver_unregister(&nsc_drv);
return rc;
}
static int __init ltc3577_init(void)
{
return driver_register( <c3577_driver.plat_driver );
}
int __init gfar_mdio_init(void)
{
return driver_register(&gianfar_mdio_driver);
}
static int __init generic_onenand_init(void)
{
return driver_register(&generic_onenand_driver);
}
/**
* mmc_register_driver - register a media driver
* @drv: MMC media driver
*/
int mmc_register_driver(struct mmc_driver *drv)
{
drv->drv.bus = &mmc_bus_type;
return driver_register(&drv->drv);
}
/**
* mmc_register_driver - register a media driver
* @drv: MMC media driver
*/
int mmc_register_driver(struct device_driver *drv)
{
drv->bus = &mmc_bus_type;
return driver_register(drv);
}
