int __init tas_dev_init(void)
{
int result;
spin_lock(&lock);
if (tas_dev_presence != not_initialized) {
spin_unlock(&lock);
return 0;
}
tas_dev_presence = now_initalizing;
spin_unlock(&lock);
result = register_chrdev(tas_major, TAS_DEVICE_NAME , &tas_fops);
if (result < 0) {
printk(KERN_WARNING
TAS_DEVICE_NAME ": can't get major %d\n",tas_major);
return result;
}
if (tas_major == 0) tas_major = result; /* dynamic */
/* register /proc entry */
if (!create_proc_info_entry(TAS_DEVICE_NAME, 0, NULL, &get_tas_info)) {
printk(KERN_WARNING
TAS_DEVICE_NAME ": can't get proc entry\n");
unregister_chrdev(tas_major, TAS_DEVICE_NAME);
return result;
}
(void) try_init_code_buffer();
tas_dev_presence = available;
return 0;
}
/*
* Just start the APM thread. We do NOT want to do APM BIOS
* calls from anything but the APM thread, if for no other reason
* than the fact that we don't trust the APM BIOS. This way,
* most common APM BIOS problems that lead to protection errors
* etc will have at least some level of being contained...
*
* In short, if something bad happens, at least we have a choice
* of just killing the apm thread..
*/
static int __init apm_init(void)
{
if (apm_bios_info.version == 0) {
printk(KERN_INFO "apm: BIOS not found.\n");
APM_INIT_ERROR_RETURN;
}
printk(KERN_INFO
"apm: BIOS version %d.%d Flags 0x%02x (Driver version %s)\n",
((apm_bios_info.version >> 8) & 0xff),
(apm_bios_info.version & 0xff),
apm_bios_info.flags,
driver_version);
if (apm_disabled) {
printk(KERN_NOTICE "apm: disabled on user request.\n");
APM_INIT_ERROR_RETURN;
}
if (PM_IS_ACTIVE()) {
printk(KERN_NOTICE "apm: overridden by ACPI.\n");
APM_INIT_ERROR_RETURN;
}
pm_active = 1;
create_proc_info_entry("apm", 0, NULL, apm_get_info);
misc_register(&apm_device);
pm_power_off = pm_do_poweroff;
clear_dpcsr();
return 0;
}
void __init iop_init(void)
{
int i;
if (iop_scc_present) {
printk("IOP: detected SCC IOP at %p\n", iop_base[IOP_NUM_SCC]);
}
if (iop_ism_present) {
printk("IOP: detected ISM IOP at %p\n", iop_base[IOP_NUM_ISM]);
iop_start(iop_base[IOP_NUM_ISM]);
iop_alive(iop_base[IOP_NUM_ISM]); /* clears the alive flag */
}
/* Make the whole pool available and empty the queues */
for (i = 0 ; i < NUM_IOP_MSGS ; i++) {
iop_msg_pool[i].status = IOP_MSGSTATUS_UNUSED;
}
for (i = 0 ; i < NUM_IOP_CHAN ; i++) {
iop_send_queue[IOP_NUM_SCC][i] = 0;
iop_send_queue[IOP_NUM_ISM][i] = 0;
iop_listeners[IOP_NUM_SCC][i].devname = NULL;
iop_listeners[IOP_NUM_SCC][i].handler = NULL;
iop_listeners[IOP_NUM_ISM][i].devname = NULL;
iop_listeners[IOP_NUM_ISM][i].handler = NULL;
}
#if 0 /* Crashing in 2.4 now, not yet sure why. --jmt */
#ifdef CONFIG_PROC_FS
create_proc_info_entry("mac_iop", 0, &proc_root, iop_get_proc_info);
#endif
#endif
}
void __init nubus_proc_init(void)
{
if (!MACH_IS_MAC)
return;
proc_bus_nubus_dir = proc_mkdir("nubus", proc_bus);
create_proc_info_entry("devices", 0, proc_bus_nubus_dir,
get_nubus_dev_info);
proc_bus_nubus_add_devices();
}
/*
* Function irda_proc_register (void)
*
* Register irda entry in /proc file system
*
*/
void irda_proc_register(void)
{
int i;
proc_irda = proc_mkdir("net/irda", NULL);
if (proc_irda == NULL)
return;
proc_irda->owner = THIS_MODULE;
for (i=0;i<IRDA_ENTRIES_NUM;i++)
create_proc_info_entry(dir[i].name,0,proc_irda,dir[i].fn);
}
static int __init my_init( void )
{
int i;
printk( "<1>\nInstalling \'%s\' module\n", modname );
// initialize our 8-KB 'mod_buf[]' array with ascii data
for (i = 0; i < 8; i++)
memset( &mod_buf[ i * 1024 ], i + '0', 1024 );
create_proc_info_entry( modname, 0, NULL, my_get_info );
return 0; //SUCCESS
}
register_proc_files()
{
test_dir = proc_mkdir("test_dir", &proc_root);
if(!create_proc_info_entry("test", 0444, test_dir, test_proc_get_info))
printk(KERN_DEBUG "TEST: Error creating /proc/test.");
entry = create_proc_entry("test_rw", 0644, test_dir);
entry->nlink = 1;
entry->data = (void*) &varable1;
entry->read_proc = test_proc_read;
entry->write_proc = test_proc_write;
}
static int hello_version_init(void)
{
int error;
error = 0;
printk(KERN_ALERT "Hello %s. You are currently using Linux %s.\n",
qui, init_uts_ns.name.release);
do_gettimeofday(&start);
if (create_proc_info_entry("hello_version_elapsed", 0, NULL,
read_proc_elapsed) == NULL) {
error=ENOMEM;
}
return error;
}
/*
* Initialize driver.
*/
int __init BuffaloCpuInterrupts_init(void)
{
struct proc_dir_entry *buffalo_cpu_int_proc;
TRACE(printk(">%s\n", __FUNCTION__));
if (use_slide_power != 1) {
buffalo_cpu_int_proc =
create_proc_info_entry("buffalo/PowerSWInt_en",
0,
0,
CpuIntActivate_read_proc);
if (buffalo_cpu_int_proc == NULL) {
proc_mkdir("buffalo", 0);
buffalo_cpu_int_proc =
create_proc_info_entry("buffalo/PowerSWInt_en",
0,
0,
CpuIntActivate_read_proc);
}
BuffaloGpio_CPUInterruptsSetup();
request_irq(PSW_IRQ, PowSwInterrupts, 0, "PowSw", NULL);
}
if (BIT_INIT >= 0) {
BuffaloGpio_CPUInterruptsSetupInit();
request_irq(INIT_IRQ, InitSwInterrupts, 0, "InitSw", NULL);
}
if (BIT_FUNC >= 0) {
BuffaloGpio_CPUInterruptsSetupFunc();
request_irq(FUNC_IRQ, FuncSwInterrupts, 0, "FuncSw", NULL);
}
printk("%s %s Ver.%s installed.\n", DRIVER_NAME, AUTHOR, BUFFALO_DRIVER_VER);
return 0;
}
int __init ircomm_init(void)
{
ircomm = hashbin_new(HB_LOCAL);
if (ircomm == NULL) {
ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);
return -ENOMEM;
}
#ifdef CONFIG_PROC_FS
create_proc_info_entry("ircomm", 0, proc_irda, ircomm_proc_read);
#endif /* CONFIG_PROC_FS */
MESSAGE("IrCOMM protocol (Dag Brattli)\n");
return 0;
}
static int __init h8_init(void)
{
if(request_irq(h8_irq, h8_intr, SA_INTERRUPT, "h8", NULL))
{
printk(KERN_ERR "H8: error: IRQ %d is not free\n", h8_irq);
return -EIO;
}
printk(KERN_INFO "H8 at 0x%x IRQ %d\n", h8_base, h8_irq);
create_proc_info_entry("driver/h8", 0, NULL, h8_get_info);
request_region(h8_base, 8, "h8");
h8_alloc_queues();
h8_hw_init();
kernel_thread(h8_monitor_thread, NULL, 0);
return 0;
}
static int __init apm_emu_init(void)
{
struct proc_dir_entry *apm_proc;
if (sys_ctrler != SYS_CTRLER_PMU) {
printk(KERN_INFO "apm_emu: Requires a machine with a PMU.\n");
return -ENODEV;
}
apm_proc = create_proc_info_entry("apm", 0, NULL, apm_emu_get_info);
if (apm_proc)
SET_MODULE_OWNER(apm_proc);
misc_register(&apm_device);
pmu_register_sleep_notifier(&apm_sleep_notifier);
printk(KERN_INFO "apm_emu: APM Emulation %s initialized.\n", driver_version);
return 0;
}
static
int __init bigphysarea_init(void)
{
if (bigphysarea_pages == 0 || bigphysarea == 0)
return -EINVAL;
/* create to /proc entry for it */
if (!create_proc_info_entry("bigphysarea",0444,&proc_root,get_info)) {
// ohoh, no way to free the allocated memory!
// continue without proc support, it not fatal in itself
// free_bootmem((unsigned long)bigphysarea>>PAGE_SHIFT,bigphysarea_pages<<PAGE_SHIFT);
// bigphysarea = 0;
// return -ENOMEM;
}
init_level = 1;
printk(KERN_INFO "bigphysarea: Allocated %d pages at 0x%p.\n",
bigphysarea_pages, bigphysarea);
return 0;
}
int ppc405ez_dac_create_proc_entry(void)
{
proc_driver = proc_mkdir("driver/ppc405ez_dac", NULL);
if (proc_driver == NULL) {
printk(KERN_ERR "%s: Error creating proc directory!\n",
__func__);
return -ENOMEM;
}
proc_regs = create_proc_info_entry("registers", 0, proc_driver,
ppc405ez_dac_proc_regs);
if (proc_regs == NULL) {
printk(KERN_ERR "%s: Error while creating proc reg file!\n",
__func__);
return -ENOMEM;
}
proc_driver->owner = THIS_MODULE;
proc_regs->owner = THIS_MODULE;
return 0;
}
/* allocate the tables for the presto devices. We need
* sizeof(proto_channel_table)/sizeof(proto_channel_table[0])
* entries for each dev
*/
int /* __init */ init_intermezzo_sysctl(void)
{
int i;
int total_dev = MAX_CHANNEL;
int entries_per_dev = sizeof(proto_psdev_table) /
sizeof(proto_psdev_table[0]);
int total_entries = entries_per_dev * total_dev;
ctl_table *dev_ctl_table;
PRESTO_ALLOC(dev_ctl_table, sizeof(ctl_table) * total_entries);
if (! dev_ctl_table) {
CERROR("WARNING: presto couldn't allocate dev_ctl_table\n");
EXIT;
return -ENOMEM;
}
/* now fill in the entries ... we put the individual presto<x>
* entries at the end of the table, and the per-presto stuff
* starting at the front. We assume that the compiler makes
* this code more efficient, but really, who cares ... it
* happens once per reboot.
*/
for(i = 0; i < total_dev; i++) {
void *p;
/* entry for this /proc/sys/intermezzo/intermezzo"i" */
ctl_table *psdev = &presto_table[i + PRESTO_PRIMARY_CTLCNT];
/* entries for the individual "files" in this "directory" */
ctl_table *psdev_entries = &dev_ctl_table[i * entries_per_dev];
/* init the psdev and psdev_entries with the prototypes */
*psdev = proto_channel_entry;
memcpy(psdev_entries, proto_psdev_table,
sizeof(proto_psdev_table));
/* now specialize them ... */
/* the psdev has to point to psdev_entries, and fix the number */
psdev->ctl_name = psdev->ctl_name + i + 1; /* sorry */
PRESTO_ALLOC(p, PROCNAME_SIZE);
psdev->procname = p;
if (!psdev->procname) {
PRESTO_FREE(dev_ctl_table,
sizeof(ctl_table) * total_entries);
return -ENOMEM;
}
sprintf((char *) psdev->procname, "intermezzo%d", i);
/* hook presto into */
psdev->child = psdev_entries;
/* now for each psdev entry ... */
psdev_entries[0].data = &(izo_channels[i].uc_hard);
psdev_entries[1].data = &(izo_channels[i].uc_no_filter);
psdev_entries[2].data = &(izo_channels[i].uc_no_journal);
psdev_entries[3].data = &(izo_channels[i].uc_no_upcall);
psdev_entries[4].data = &(izo_channels[i].uc_timeout);
#ifdef PRESTO_DEBUG
psdev_entries[5].data = &(izo_channels[i].uc_errorval);
#endif
}
#ifdef CONFIG_SYSCTL
if ( !intermezzo_table_header )
intermezzo_table_header =
register_sysctl_table(intermezzo_table, 0);
#endif
#ifdef CONFIG_PROC_FS
proc_fs_intermezzo = proc_mkdir("intermezzo", proc_root_fs);
proc_fs_intermezzo->owner = THIS_MODULE;
create_proc_info_entry("mounts", 0, proc_fs_intermezzo,
intermezzo_mount_get_info);
#endif
return 0;
}
void ide_pci_create_host_proc(const char *name, get_info_t *get_info)
{
create_proc_info_entry(name, 0, proc_ide_root, get_info);
}
static int __init mwave_init(void)
{
int i;
int retval = 0;
int resultMiscRegister;
pMWAVE_DEVICE_DATA pDrvData = &mwave_s_mdd;
memset(&mwave_s_mdd, 0, sizeof(MWAVE_DEVICE_DATA));
PRINTK_1(TRACE_MWAVE, "mwavedd::mwave_init entry\n");
pDrvData->bBDInitialized = FALSE;
pDrvData->bResourcesClaimed = FALSE;
pDrvData->bDSPEnabled = FALSE;
pDrvData->bDSPReset = FALSE;
pDrvData->bMwaveDevRegistered = FALSE;
pDrvData->sLine = -1;
pDrvData->bProcEntryCreated = FALSE;
for (i = 0; i < 16; i++) {
pDrvData->IPCs[i].bIsEnabled = FALSE;
pDrvData->IPCs[i].bIsHere = FALSE;
pDrvData->IPCs[i].usIntCount = 0; /* no ints received yet */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
init_waitqueue_head(&pDrvData->IPCs[i].ipc_wait_queue);
#endif
}
retval = tp3780I_InitializeBoardData(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_InitializeBoardData retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize board data\n");
goto cleanup_error;
}
pDrvData->bBDInitialized = TRUE;
retval = tp3780I_CalcResources(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_CalcResources retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to calculate resources\n");
goto cleanup_error;
}
retval = tp3780I_ClaimResources(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_ClaimResources retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to claim resources\n");
goto cleanup_error;
}
pDrvData->bResourcesClaimed = TRUE;
retval = tp3780I_EnableDSP(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_EnableDSP retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to enable DSP\n");
goto cleanup_error;
}
pDrvData->bDSPEnabled = TRUE;
resultMiscRegister = misc_register(&mwave_misc_dev);
if (resultMiscRegister < 0) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register misc device\n");
goto cleanup_error;
}
pDrvData->bMwaveDevRegistered = TRUE;
pDrvData->sLine = register_serial_portandirq(
pDrvData->rBDData.rDspSettings.usUartBaseIO,
pDrvData->rBDData.rDspSettings.usUartIrq
);
if (pDrvData->sLine < 0) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register serial driver\n");
goto cleanup_error;
}
/* uart is registered */
if (
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
!create_proc_info_entry("mwave", 0, NULL, mwave_get_info)
#else
proc_register(&proc_root, &mwave_proc)
#endif
) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to register /proc/mwave\n");
goto cleanup_error;
}
pDrvData->bProcEntryCreated = TRUE;
/* SUCCESS! */
return 0;
cleanup_error:
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize\n");
mwave_exit(); /* clean up */
return -EIO;
}
static void ecard_proc_init(void)
{
proc_bus_ecard_dir = proc_mkdir("ecard", proc_bus);
create_proc_info_entry("devices", 0, proc_bus_ecard_dir,
get_ecard_dev_info);
}
//----------------------------------------------------------------------
int __init buffaloLedDriver_init (void)
{
int i;
char buf[1024];
struct proc_dir_entry *pde;
FUNCTRACE(printk("%s > Entered.\n",__FUNCTION__));
BuffaloGpio_Init();
pde = proc_mkdir("buffalo/gpio", 0);
pde = proc_mkdir("buffalo/gpio/led", 0);
pde = proc_mkdir("buffalo/gpio/switch", 0);
pde = proc_mkdir("buffalo/gpio/fan", 0);
pde = proc_mkdir("buffalo/gpio/power_control", 0);
pde = create_proc_info_entry ("buffalo/power_sw", 0, 0, gpio_power_read_proc);
pde = create_proc_entry("buffalo/gpio/led/all", 0, 0);
pde->read_proc = BuffaloAllLedReadProc;
pde->write_proc= BuffaloAllLedWriteProc;
pde = create_proc_entry("buffalo/cpu_status", 0, 0);
pde->read_proc = BuffaloCpuStatusReadProc;
pde->write_proc = BuffaloCpuStatusWriteProc;
if (BIT_LED_ALARM >= 0) {
BuffaloGpio_AlarmLedDisable();
pde = create_proc_entry("buffalo/gpio/led/alarm", 0, 0);
pde->read_proc = BuffaloLedReadProc;
pde->write_proc = BuffaloLedWriteProc;
alarmLed.mppNumber = BIT_LED_ALARM;
pde->data = &alarmLed;
pde = create_proc_entry("buffalo/gpio/led/alarm_blink", 0, 0);
pde->read_proc = BuffaloLedBlinkReadProc;
pde->write_proc = BuffaloLedBlinkWriteProc;
pde->data = &alarmLed;
}
if (BIT_LED_INFO >= 0) {
BuffaloGpio_InfoLedDisable();
pde = create_proc_entry("buffalo/gpio/led/info", 0, 0);
pde->read_proc = BuffaloLedReadProc;
pde->write_proc = BuffaloLedWriteProc;
infoLed.mppNumber = BIT_LED_INFO;
pde->data = &infoLed;
pde = create_proc_entry("buffalo/gpio/led/info_blink", 0, 0);
pde->read_proc = BuffaloLedBlinkReadProc;
pde->write_proc = BuffaloLedBlinkWriteProc;
pde->data = &infoLed;
}
if (BIT_LED_PWR >= 0) {
BuffaloGpio_PowerLedEnable();
pde = create_proc_entry("buffalo/gpio/led/power", 0, 0);
pde->read_proc = BuffaloLedReadProc;
pde->write_proc = BuffaloLedWriteProc;
powerLed.mppNumber = BIT_LED_PWR;
pde->data = &powerLed;
pde = create_proc_entry("buffalo/gpio/led/power_blink", 0, 0);
pde->read_proc = BuffaloLedBlinkReadProc;
pde->write_proc = BuffaloLedBlinkWriteProc;
pde->data = &powerLed;
}
if (BIT_LED_FUNC >= 0) {
BuffaloGpio_FuncLedDisable();
pde = create_proc_entry("buffalo/gpio/led/func", 0, 0);
pde->read_proc = BuffaloLedReadProc;
pde->write_proc = BuffaloLedWriteProc;
funcLed.mppNumber = BIT_LED_FUNC;
pde->data = &funcLed;
pde = create_proc_entry("buffalo/gpio/led/func_blink", 0, 0);
pde->read_proc = BuffaloLedBlinkReadProc;
pde->write_proc = BuffaloLedBlinkWriteProc;
pde->data = &funcLed;
}
if (BIT_LED_ETH >= 0) {
pde = create_proc_entry("buffalo/gpio/led/eth", 0, 0);
pde->read_proc = BuffaloEthLedReadProc;
pde->write_proc = BuffaloEthLedWriteProc;
}
for (i=0; i<BUF_NV_SIZE_BIT_HDD_POWER; i++) {
if (bitHddPower[i] < 0)
continue;
sprintf(buf, "buffalo/gpio/power_control/hdd%d", i);
pde = create_proc_entry(buf, 0, 0);
if (pde != NULL) {
pde->read_proc = BuffaloHddReadProc;
pde->write_proc= BuffaloHddWriteProc;
pde->owner = THIS_MODULE;
pde->data = (void *)i;
}
}
for (i=0; i<BUF_NV_SIZE_BIT_USB_POWER; i++) {
if (bitUsbPower[i] < 0)
continue;
sprintf(buf, "buffalo/gpio/power_control/usb%d", i);
pde = create_proc_entry(buf, 0, NULL);
if (pde != NULL) {
pde->read_proc = BuffaloUsbReadProc;
pde->write_proc = BuffaloUsbWriteProc;
pde->owner = THIS_MODULE;
pde->data = (void *)i;
}
}
if (use_slide_power == 1) {
pde = create_proc_entry("buffalo/gpio/switch/power", 0, 0);
pde->read_proc = BuffaloPowerReadProc;
// pde->write_proc = BuffaloPowerReadProc;
pde = create_proc_info_entry("buffalo/gpio/switch/slide_switch", 0, 0, BuffaloSlideSwitchReadProc);
}
if (BIT_AUTO_POWER >= 0) {
pde = create_proc_entry("buffalo/gpio/switch/auto_power", 0, 0);
pde->read_proc = BuffaloAutoPowerReadProc;
// pde->write_proc = BuffaloAutoPowerReadProc;
}
if (use_slide_power == 1 || BIT_AUTO_POWER >= 0) {
pde = create_proc_entry("buffalo/gpio/switch/sw_control", 0, 0);
pde->read_proc = BuffaloSwPollingReadProc;
pde->write_proc = BuffaloSwPollingWriteProc;
}
if (BIT_FUNC >= 0) {
pde = create_proc_entry("buffalo/gpio/switch/func", 0, 0);
pde->read_proc = BuffaloFuncReadProc;
// pde->write_proc= BuffaloFuncReadProc;
}
if (BIT_FAN_LOW >= 0 && BIT_FAN_HIGH) {
pde = create_proc_entry("buffalo/gpio/fan/control", 0, 0);
pde->read_proc = BuffaloFanControlReadProc;
pde->write_proc= BuffaloFanControlWriteProc;
}
if (BIT_FAN_LCK >= 0) {
pde = create_proc_entry("buffalo/gpio/fan/lock", 0, 0);
pde->read_proc = BuffaloFanStatusReadProc;
pde->write_proc= BuffaloFanStatusWriteProc;
}
pde = create_proc_entry("buffalo/gpio/data_out_register", 0, 0);
pde->read_proc = BuffaloGpioRegisterReadProc;
pde->write_proc= BuffaloGpioRegisterWriteProc;
pde->data = (void *)GPP_DATA_OUT_REG(0);
pde = create_proc_entry("buffalo/gpio/data_out_enable_register", 0, 0);
pde->read_proc = BuffaloGpioRegisterReadProc;
pde->write_proc= BuffaloGpioRegisterWriteProc;
pde->data = (void *)GPP_DATA_OUT_EN_REG(0);
pde = create_proc_entry("buffalo/gpio/blink_enable_register", 0, 0);
pde->read_proc = BuffaloGpioRegisterReadProc;
pde->write_proc= BuffaloGpioRegisterWriteProc;
pde->data = (void *)GPP_BLINK_EN_REG(0);
pde = create_proc_entry("buffalo/gpio/data_in_polarity_register", 0, 0);
pde->read_proc = BuffaloGpioRegisterReadProc;
pde->write_proc= BuffaloGpioRegisterWriteProc;
pde->data = (void *)GPP_DATA_IN_POL_REG(0);
pde = create_proc_entry("buffalo/gpio/data_in_register", 0, 0);
pde->read_proc = BuffaloGpioRegisterReadProc;
pde->write_proc= BuffaloGpioRegisterWriteProc;
pde->data = (void *)GPP_DATA_IN_REG(0);
if (Buffalo_has_PM()) {
for (i=0; i<4; i++) {
sprintf(buf, "buffalo/gpio/power_control/hdd%d", i);
pde = create_proc_entry(buf, 0, 0);
if (pde != NULL) {
pde->read_proc = BuffaloPMHddPowerReadProc;
pde->write_proc= BuffaloPMHddPowerWriteProc;
pde->owner = THIS_MODULE;
pde->data = (void *)i;
}
sprintf(buf, "buffalo/gpio/led/pm_diag_led%d", i);
pde = create_proc_entry(buf, 0, 0);
if (pde != NULL) {
pde->read_proc = BuffaloPMHddDiagLedReadProc;
pde->write_proc= BuffaloPMHddDiagLedWriteProc;
pde->owner = THIS_MODULE;
pde->data = (void *)i;
}
}
}
printk("%s %s Ver.%s installed.\n", DRIVER_NAME, AUTHOR, BUFFALO_DRIVER_VER);
return 0;
}
