static int __init cmos_init(void)
{
int retval = 0;
#ifdef CONFIG_PNP
retval = pnp_register_driver(&cmos_pnp_driver);
if (retval == 0)
pnp_driver_registered = true;
#endif
if (!cmos_rtc.dev) {
retval = platform_driver_probe(&cmos_platform_driver,
cmos_platform_probe);
if (retval == 0)
platform_driver_registered = true;
}
dmi_check_system(rtc_quirks);
if (retval == 0)
return 0;
#ifdef CONFIG_PNP
if (pnp_driver_registered)
pnp_unregister_driver(&cmos_pnp_driver);
#endif
return retval;
}
static int __init generic_NCR5380_init(void)
{
int ret = 0;
/* compatibility with old-style parameters */
if (irq[0] == -1 && base[0] == 0 && card[0] == -1) {
irq[0] = ncr_irq;
base[0] = ncr_addr;
if (ncr_5380)
card[0] = BOARD_NCR5380;
if (ncr_53c400)
card[0] = BOARD_NCR53C400;
if (ncr_53c400a)
card[0] = BOARD_NCR53C400A;
if (dtc_3181e)
card[0] = BOARD_DTC3181E;
if (hp_c2502)
card[0] = BOARD_HP_C2502;
}
#ifdef CONFIG_PNP
if (!pnp_register_driver(&generic_NCR5380_pnp_driver))
pnp_registered = 1;
#endif
ret = isa_register_driver(&generic_NCR5380_isa_driver, MAX_CARDS);
if (!ret)
isa_registered = 1;
return (pnp_registered || isa_registered) ? 0 : ret;
}
/** Init module */
static int __init rtcan_peak_dng_init(void)
{
int i, ret = -EINVAL, done = 0;
if (pnp_register_driver(&rtcan_peak_dng_pnp_driver) == 0)
pnp_registered = 1;
for (i = 0;
i < RTCAN_PEAK_DNG_MAX_DEV && type[i] != 0;
i++) {
if ((ret = rtcan_peak_dng_init_one(i)) != 0) {
printk(KERN_ERR "%s: Init failed with %d\n", RTCAN_DRV_NAME, ret);
goto cleanup;
}
done++;
}
if (done)
return 0;
printk(KERN_ERR "%s: Please specify type=epp or type=sp\n",
RTCAN_DRV_NAME);
cleanup:
rtcan_peak_dng_exit();
return ret;
}
void pnpide_init(int enable)
{
if(enable)
pnp_register_driver(&idepnp_driver);
else
pnp_unregister_driver(&idepnp_driver);
}
/* Initialization */
int c2_init(void)
{
/* Register the character device (at least try) */
Major = register_chrdev(major,
DEVICE_NAME,
&Fops);
/* Negative values signify an error */
if (Major < 0) {
printk (KERN_ERR
"cygnal_c2: Failed to register character device with major %d\n",
Major);
return Major;
}
#ifdef USE_PNP
if (pnp_register_driver(&c2_pnp_driver) < 0) {
unregister_chrdev(Major, DEVICE_NAME);
return -ENODEV;
}
#else
request_region(io_base,0x10,DEVICE_NAME);
if (request_irq(irq, c2_interrupt, SA_INTERRUPT, DEVICE_NAME, NULL)) {
printf("<1>Requesting IRQ %d failed\n", irq);
unregister_chrdev(Major, DEVICE_NAME);
return -ENODEV;
}
#endif
if(major) Major=major; /* The register_chrdev returns "0" if
major number was given, and registration
is successfull */
printk(KERN_INFO
"cygnal_c2: Successfully registered major device number %d\n",
Major);
return 0;
}
static int c6xdigio_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
int ret;
ret = comedi_request_region(dev, it->options[0], C6XDIGIO_SIZE);
if (ret)
return ret;
ret = comedi_alloc_subdevices(dev, 2);
if (ret)
return ret;
/* Make sure that PnP ports get activated */
pnp_register_driver(&c6xdigio_pnp_driver);
s = &dev->subdevices[0];
/* pwm output subdevice */
s->type = COMEDI_SUBD_AO; /* Not sure what to put here */
s->subdev_flags = SDF_WRITEABLE;
s->n_chan = 2;
/* s->trig[0] = c6xdigio_pwmo; */
s->insn_read = c6xdigio_pwmo_insn_read;
s->insn_write = c6xdigio_pwmo_insn_write;
s->maxdata = 500;
s->range_table = &range_bipolar10; /* A suitable lie */
s = &dev->subdevices[1];
/* encoder (counter) subdevice */
s->type = COMEDI_SUBD_COUNTER;
s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
s->n_chan = 2;
/* s->trig[0] = c6xdigio_ei; */
s->insn_read = c6xdigio_ei_insn_read;
s->maxdata = 0xffffff;
s->range_table = &range_unknown;
/* s = &dev->subdevices[2]; */
/* pwm output subdevice */
/* s->type = COMEDI_SUBD_COUNTER; // Not sure what to put here */
/* s->subdev_flags = SDF_WRITEABLE; */
/* s->n_chan = 1; */
/* s->trig[0] = c6xdigio_ei_init; */
/* s->insn_read = c6xdigio_ei_init_insn_read; */
/* s->insn_write = c6xdigio_ei_init_insn_write; */
/* s->maxdata = 0xFFFF; // Really just a don't care */
/* s->range_table = &range_unknown; // Not sure what to put here */
/* I will call this init anyway but more than likely the DSP board */
/* will not be connected when device driver is loaded. */
board_init(dev);
return 0;
}
static int __init cmos_init(void)
{
#ifdef CONFIG_PNP
if (pnp_platform_devices)
return pnp_register_driver(&cmos_pnp_driver);
else
return platform_driver_probe(&cmos_platform_driver,
cmos_platform_probe);
#else
return platform_driver_probe(&cmos_platform_driver,
cmos_platform_probe);
#endif /* CONFIG_PNP */
}
static int __init fmr2_init(void)
{
int ret;
ret = pnp_register_driver(&fmr2_pnp_driver);
if (!ret)
pnp_registered = true;
ret = isa_register_driver(&fmr2_isa_driver, 1);
if (!ret)
isa_registered = true;
return (pnp_registered || isa_registered) ? 0 : ret;
}
static int __init hisax_fcpcipnp_init(void)
{
int retval;
printk(KERN_INFO "hisax_fcpcipnp: Fritz!Card PCI/PCIv2/PnP ISDN driver v0.0.1\n");
retval = pci_register_driver(&fcpci_driver);
if (retval)
return retval;
#ifdef CONFIG_PNP
retval = pnp_register_driver(&fcpnp_driver);
if (retval < 0) {
pci_unregister_driver(&fcpci_driver);
return retval;
}
#endif
return 0;
}
static int __init cmos_init(void)
{
int retval = 0;
#ifdef CONFIG_PNP
pnp_register_driver(&cmos_pnp_driver);
#endif
if (!cmos_rtc.dev)
retval = platform_driver_register(&cmos_platform_driver);
if (retval == 0)
return 0;
#ifdef CONFIG_PNP
pnp_unregister_driver(&cmos_pnp_driver);
#endif
return retval;
}
int rtapi_app_main(void) {
int r;
comp_id = hal_init("probe_parport");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "PROBE_PARPORT: ERROR: hal_init() failed\n");
return -1;
}
r = pnp_register_driver (&parport_pc_pnp_driver);
if (r >= 0) {
pnp_registered_parport = 1;
} else {
rtapi_print_msg(RTAPI_MSG_WARN, "PROBE_PARPORT: no PnPBIOS parports were detected (%d)\n", r);
}
hal_ready(comp_id);
return 0;
}
static int __init alsa_card_mpu401_init(void)
{
int i, err;
if ((err = platform_driver_register(&snd_mpu401_driver)) < 0)
return err;
for (i = 0; i < SNDRV_CARDS; i++) {
struct platform_device *device;
if (! enable[i])
continue;
#ifdef CONFIG_PNP
if (pnp[i])
continue;
#endif
device = platform_device_register_simple(SND_MPU401_DRIVER,
i, NULL, 0);
if (IS_ERR(device))
continue;
if (!platform_get_drvdata(device)) {
platform_device_unregister(device);
continue;
}
platform_devices[i] = device;
snd_mpu401_devices++;
}
err = pnp_register_driver(&snd_mpu401_pnp_driver);
if (!err)
pnp_registered = 1;
if (!snd_mpu401_devices) {
#ifdef MODULE
printk(KERN_ERR "MPU-401 device not found or device busy\n");
#endif
snd_mpu401_unregister_all();
return -ENODEV;
}
return 0;
}
static int __init isapnp_init(void)
{
return pnp_register_driver(&isapnp_driver);
}
static int __init serial8250_pnp_init(void)
{
return pnp_register_driver(&serial_pnp_driver);
}
static int __init sc1200wdt_init(void)
{
int ret;
printk(KERN_INFO "%s\n", banner);
#if defined CONFIG_PNP
if (isapnp) {
ret = pnp_register_driver(&scl200wdt_pnp_driver);
if (ret)
goto out_clean;
}
#endif
if (io == -1) {
printk(KERN_ERR PFX "io parameter must be specified\n");
ret = -EINVAL;
goto out_pnp;
}
#if defined CONFIG_PNP
/* now that the user has specified an IO port and we haven't detected
* any devices, disable pnp support */
isapnp = 0;
pnp_unregister_driver(&scl200wdt_pnp_driver);
#endif
if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
printk(KERN_ERR PFX "Unable to register IO port %#x\n", io);
ret = -EBUSY;
goto out_pnp;
}
ret = sc1200wdt_probe();
if (ret)
goto out_io;
ret = register_reboot_notifier(&sc1200wdt_notifier);
if (ret) {
printk(KERN_ERR PFX
"Unable to register reboot notifier err = %d\n", ret);
goto out_io;
}
ret = misc_register(&sc1200wdt_miscdev);
if (ret) {
printk(KERN_ERR PFX
"Unable to register miscdev on minor %d\n",
WATCHDOG_MINOR);
goto out_rbt;
}
/* ret = 0 */
out_clean:
return ret;
out_rbt:
unregister_reboot_notifier(&sc1200wdt_notifier);
out_io:
release_region(io, io_len);
out_pnp:
#if defined CONFIG_PNP
if (isapnp)
pnp_unregister_driver(&scl200wdt_pnp_driver);
#endif
goto out_clean;
}
static int __init pnpide_init(void)
{
return pnp_register_driver(&idepnp_driver);
}
static int __init
sb1000_init(void)
{
return pnp_register_driver(&sb1000_driver);
}
static int ite_init(void)
{
return pnp_register_driver(&ite_driver);
}
static int __init fintek_init(void)
{
return pnp_register_driver(&fintek_driver);
}
static int __init apple_gmux_init(void)
{
return pnp_register_driver(&gmux_pnp_driver);
}
static int __init cmos_init(void)
{
return pnp_register_driver(&cmos_pnp_driver);
}
static int __init soc_button_init(void)
{
return pnp_register_driver(&soc_button_pnp_driver);
}
void __init pnpide_init(void)
{
pnp_register_driver(&idepnp_driver);
}
static int __init pnp_system_init(void)
{
return pnp_register_driver(&system_pnp_driver);
}
static int __init nsc_ircc_init(void)
{
chipio_t info;
nsc_chip_t *chip;
int ret;
int cfg_base;
int cfg, id;
int reg;
int i = 0;
ret = platform_driver_register(&nsc_ircc_driver);
if (ret) {
IRDA_ERROR("%s, Can't register driver!\n", driver_name);
return ret;
}
ret = pnp_register_driver(&nsc_ircc_pnp_driver);
if (!ret)
pnp_registered = 1;
ret = -ENODEV;
for (chip = chips; chip->name ; chip++) {
IRDA_DEBUG(2, "%s(), Probing for %s ...\n", __func__,
chip->name);
for (cfg = 0; cfg < ARRAY_SIZE(chip->cfg); cfg++) {
cfg_base = chip->cfg[cfg];
if (!cfg_base)
continue;
reg = inb(cfg_base);
if (reg == 0xff) {
IRDA_DEBUG(2, "%s() no chip at 0x%03x\n", __func__, cfg_base);
continue;
}
outb(chip->cid_index, cfg_base);
id = inb(cfg_base+1);
if ((id & chip->cid_mask) == chip->cid_value) {
IRDA_DEBUG(2, "%s() Found %s chip, revision=%d\n",
__func__, chip->name, id & ~chip->cid_mask);
if (pnp_succeeded) {
memset(&info, 0, sizeof(chipio_t));
info.cfg_base = cfg_base;
info.fir_base = pnp_info.fir_base;
info.dma = pnp_info.dma;
info.irq = pnp_info.irq;
if (info.fir_base < 0x2000) {
IRDA_MESSAGE("%s, chip->init\n", driver_name);
chip->init(chip, &info);
} else
chip->probe(chip, &info);
if (nsc_ircc_open(&info) >= 0)
ret = 0;
}
if (ret) {
IRDA_DEBUG(2, "%s, PnP init failed\n", driver_name);
memset(&info, 0, sizeof(chipio_t));
info.cfg_base = cfg_base;
info.fir_base = io[i];
info.dma = dma[i];
info.irq = irq[i];
if (io[i] < 0x2000) {
chip->init(chip, &info);
} else
chip->probe(chip, &info);
if (nsc_ircc_open(&info) >= 0)
ret = 0;
}
i++;
} else {
IRDA_DEBUG(2, "%s(), Wrong chip id=0x%02x\n", __func__, id);
}
}
}
if (ret) {
platform_driver_unregister(&nsc_ircc_driver);
pnp_unregister_driver(&nsc_ircc_pnp_driver);
pnp_registered = 0;
}
return ret;
}
