void lvm_fs_create_vg(vg_t *vg_ptr) {
struct proc_dir_entry *pde;
if (!vg_ptr)
return;
vg_devfs_handle[vg_ptr->vg_number] =
devfs_mk_dir(0, vg_ptr->vg_name, NULL);
ch_devfs_handle[vg_ptr->vg_number] = devfs_register(
vg_devfs_handle[vg_ptr->vg_number] , "group",
DEVFS_FL_DEFAULT, LVM_CHAR_MAJOR, vg_ptr->vg_number,
S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
&lvm_chr_fops, NULL);
vg_ptr->vg_dir_pde = create_proc_entry(vg_ptr->vg_name, S_IFDIR,
lvm_proc_vg_subdir);
if((pde = create_proc_entry("group", S_IFREG, vg_ptr->vg_dir_pde))) {
pde->read_proc = _proc_read_vg;
pde->data = vg_ptr;
}
vg_ptr->lv_subdir_pde =
create_proc_entry(LVM_LV_SUBDIR, S_IFDIR, vg_ptr->vg_dir_pde);
vg_ptr->pv_subdir_pde =
create_proc_entry(LVM_PV_SUBDIR, S_IFDIR, vg_ptr->vg_dir_pde);
}
static __init int init_ipmi_devintf(void)
{
int rv;
if (ipmi_major < 0)
return -EINVAL;
rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
if (rv < 0) {
printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
return rv;
}
if (ipmi_major == 0) {
ipmi_major = rv;
}
devfs_handle = devfs_mk_dir(NULL, DEVICE_NAME, NULL);
rv = ipmi_smi_watcher_register(&smi_watcher);
if (rv) {
unregister_chrdev(ipmi_major, DEVICE_NAME);
printk(KERN_WARNING "ipmi: can't register smi watcher");
return rv;
}
printk(KERN_INFO "ipmi: device interface at char major %d\n",
ipmi_major);
return 0;
}
int init_module(void)
{
int ret;
dev_t dev = MKDEV(DVB_MAJOR, 0);
if ((ret = register_chrdev_region(dev, 64, DEVICE_NAME)) != 0) {
printk(KERN_INFO "td-dvb-fe: unable to get major %d\n", DVB_MAJOR);
goto error;
}
cdev_init(&device_cdev, &fops);
if ((ret = cdev_add(&device_cdev, dev, 64)) != 0) {
printk(KERN_INFO "td-dvb-fe: unable to get major %d\n", DVB_MAJOR);
goto error;
}
devfs_mk_dir("dvb");
my_class = class_simple_create(THIS_MODULE, DEVICE_NAME);
if (IS_ERR(my_class)) {
ret = PTR_ERR(my_class);
goto error;
}
devfs_mk_cdev(MKDEV(DVB_MAJOR, 3), S_IFCHR | S_IRUSR | S_IWUSR, "dvb/adapter0/frontend0");
class_simple_device_add(my_class, MKDEV(DVB_MAJOR, 3), NULL, "dvb0.frontend0");
printk(KERN_INFO "[td-dvb-fe] loaded\n");
return 0;
error:
cdev_del(&device_cdev);
unregister_chrdev_region(dev, 64);
return ret;
}
/* xd_init: register the block device number and set up pointer tables */
int __init xd_init(void)
{
init_timer (&xd_watchdog_int);
xd_watchdog_int.function = xd_watchdog;
if (!xd_dma_buffer)
xd_dma_buffer = (char *)xd_dma_mem_alloc(xd_maxsectors * 0x200);
if (!xd_dma_buffer)
{
printk(KERN_ERR "xd: Out of memory.\n");
return -ENOMEM;
}
if (devfs_register_blkdev(MAJOR_NR,"xd",&xd_fops)) {
printk(KERN_ERR "xd: Unable to get major number %d\n",MAJOR_NR);
return -1;
}
devfs_handle = devfs_mk_dir (NULL, xd_gendisk.major_name, NULL);
blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read ahead */
add_gendisk(&xd_gendisk);
xd_geninit();
return 0;
}
static __init int init_ipmi_devintf(void)
{
int rv;
if (ipmi_major < 0)
return -EINVAL;
printk(KERN_INFO "ipmi device interface version "
IPMI_DEVINTF_VERSION "\n");
rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
if (rv < 0) {
printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
return rv;
}
if (ipmi_major == 0) {
ipmi_major = rv;
}
devfs_mk_dir(DEVICE_NAME);
rv = ipmi_smi_watcher_register(&smi_watcher);
if (rv) {
unregister_chrdev(ipmi_major, DEVICE_NAME);
printk(KERN_WARNING "ipmi: can't register smi watcher\n");
return rv;
}
return 0;
}
int __init hiddev_init(void)
{
hiddev_devfs_handle =
devfs_mk_dir(devfs_find_handle(NULL, "usb", 0, 0, 0, 0), "hid", NULL);
usb_register(&hiddev_driver);
return 0;
}
static int __init bpp_init(void)
{
int rc;
unsigned idx;
rc = collectLptPorts();
if (rc == 0)
return -ENODEV;
rc = register_chrdev(BPP_MAJOR, dev_name, &bpp_fops);
if (rc < 0)
return rc;
for (idx = 0; idx < BPP_NO; idx++) {
instances[idx].opened = 0;
probeLptPort(idx);
}
devfs_mk_dir("bpp");
for (idx = 0; idx < BPP_NO; idx++) {
devfs_mk_cdev(MKDEV(BPP_MAJOR, idx),
S_IFCHR | S_IRUSR | S_IWUSR, "bpp/%d", idx);
}
return 0;
}
int __init s3c2410_adc_init(void)
{
int ret;
/* normal ADC */
ADCTSC = 0; //XP_PST(NOP_MODE);
ret = request_irq(IRQ_ADC_DONE, adcdone_int_handler, SA_INTERRUPT, DEVICE_NAME, NULL);
if (ret) {
return ret;
}
ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't get major number\n");
return ret;
}
adcMajor=ret;
#ifdef CONFIG_DEVFS_FS
devfs_adc_dir = devfs_mk_dir(NULL, "adc", NULL);
devfs_adcraw = devfs_register(devfs_adc_dir, "0raw", DEVFS_FL_DEFAULT,
adcMajor, ADCRAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR, &s3c2410_fops, NULL);
#endif
printk (DEVICE_NAME"\tinitialized\n");
return 0;
}
static int __init
xts_init(void)
{
int index = 0;
int retval;
if ((retval = devfs_register_chrdev(xts_major, XTS_NAME, &fops)) < 0) {
printk(KERN_ERR "%s: unable to register major %d.\n", XTS_NAME,
xts_major);
return retval;
}
if (xts_major == 0)
xts_major = retval;
devfs_dir = devfs_mk_dir(NULL, "touchscreen", NULL);
/* Try to initialize all the touchscreens. */
while (probe(index++) == 0) ;
if (index > 1) {
/* We found at least one. */
init_completion(&task_sync);
init_waitqueue_head(&irq_wait);
if ((retval = kernel_thread(xts_thread, 0, 0)) >= 0) {
wait_for_completion(&task_sync);
return 0;
}
} else
retval = -ENODEV;
/* None found or error starting thread, clean up and get out of here. */
xts_cleanup();
return retval;
}
int __init fpga_init(void)
{
int ret;
/* ret = request_irq(IRQ_ADC_DONE, adcdone_int_handler, SA_INTERRUPT, DEVICE_NAME, NULL);
if (ret) {
return ret;
}*/
s3c2410_fpga_base= (unsigned long) ioremap(FPGA_PHY_START, SZ_4K);
if(!s3c2410_fpga_base) {
printk("ioremap S3C2410 fpga failed\n");
return -EINVAL;
}
ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't get major number\n");
return ret;
}
fpgaMajor=ret;
#ifdef CONFIG_DEVFS_FS
devfs_fpga_dir = devfs_mk_dir(NULL, "fpga", NULL);
devfs_fpgaraw = devfs_register(devfs_fpga_dir, "0raw", DEVFS_FL_DEFAULT,
fpgaMajor, FPGARAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR, &s3c2410_fops, NULL);
#endif
printk (DEVICE_NAME"\tdevice initialized\n");
return 0;
}
static int __init
gpio_init(void)
{
int i;
if (!(gpio_sih = si_kattach(SI_OSH)))
return -ENODEV;
si_gpiosetcore(gpio_sih);
if ((gpio_major = devfs_register_chrdev(0, "gpio", &gpio_fops)) < 0)
return gpio_major;
gpio_dir = devfs_mk_dir(NULL, "gpio", NULL);
for (i = 0; i < ARRAYSIZE(gpio_file); i++) {
gpio_file[i].handle = devfs_register(gpio_dir,
gpio_file[i].name,
DEVFS_FL_DEFAULT, gpio_major, i,
S_IFCHR | S_IRUGO | S_IWUGO,
&gpio_fops, NULL);
}
return 0;
}
static int vfc_probe(void)
{
struct sbus_bus *sbus;
struct sbus_dev *sdev = NULL;
int ret;
int instance = 0, cards = 0;
for_all_sbusdev(sdev, sbus) {
if (strcmp(sdev->prom_name, "vfc") == 0) {
cards++;
continue;
}
}
if (!cards)
return -ENODEV;
vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) *
(cards+1),
GFP_KERNEL);
if (vfc_dev_lst == NULL)
return -ENOMEM;
memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
vfc_dev_lst[cards] = NULL;
ret = devfs_register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
if(ret) {
printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
kfree(vfc_dev_lst);
return -EIO;
}
devfs_handle = devfs_mk_dir (NULL, "vfc", NULL);
instance = 0;
for_all_sbusdev(sdev, sbus) {
if (strcmp(sdev->prom_name, "vfc") == 0) {
vfc_dev_lst[instance]=(struct vfc_dev *)
kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
if (vfc_dev_lst[instance] == NULL)
return -ENOMEM;
ret = init_vfc_device(sdev,
vfc_dev_lst[instance],
instance);
if(ret) {
printk(KERN_ERR "Unable to initialize"
" vfc%d device\n",
instance);
} else {
}
instance++;
continue;
}
}
return 0;
}
static int __init mbd_init(void)
{
int err = -ENOMEM;
int i;
for (i = 0; i < MAX_MBD; i++) {
struct gendisk *disk = alloc_disk(1);
if (!disk)
goto out;
mbd_dev[i].disk = disk;
/*
* The new linux 2.5 block layer implementation requires
* every gendisk to have its very own request_queue struct.
* These structs are big so we dynamically allocate them.
*/
disk->queue = blk_init_queue(do_mbd_request, &mbd_lock);
if (!disk->queue) {
put_disk(disk);
goto out;
}
}
if (register_blkdev(MAJOR_NR, "mbd")) {
err = -EIO;
goto out;
}
#ifdef MODULE
printk("mambo bogus disk: registered device at major %d\n", MAJOR_NR);
#else
printk("mambo bogus disk: compiled in with kernel\n");
#endif
devfs_mk_dir("mambobd");
for (i = 0; i < MAX_MBD; i++) { /* load defaults */
struct gendisk *disk = mbd_dev[i].disk;
mbd_dev[i].initialized = 0;
mbd_dev[i].refcnt = 0;
mbd_dev[i].flags = 0;
disk->major = MAJOR_NR;
disk->first_minor = i;
disk->fops = &mbd_fops;
disk->private_data = &mbd_dev[i];
sprintf(disk->disk_name, "mambobd%d", i);
sprintf(disk->devfs_name, "mambobd%d", i);
set_capacity(disk, 0x7ffffc00ULL << 1); /* 2 TB */
add_disk(disk);
}
return 0;
out:
while (i--) {
if (mbd_dev[i].disk->queue)
blk_cleanup_queue(mbd_dev[i].disk->queue);
put_disk(mbd_dev[i].disk);
}
return -EIO;
}
/*
* hwgraph_mk_dir - Creates a directory entry with devfs.
* Note that a directory entry in devfs can have children
* but it cannot be a char|block special file.
*/
vertex_hdl_t
hwgraph_mk_dir(vertex_hdl_t de, const char *name,
unsigned int namelen, void *info)
{
int rv;
labelcl_info_t *labelcl_info = NULL;
vertex_hdl_t new_devfs_handle = NULL;
vertex_hdl_t parent = NULL;
/*
* Create the device info structure for hwgraph compatiblity support.
*/
labelcl_info = labelcl_info_create();
if (!labelcl_info)
return(NULL);
/*
* Create a devfs entry.
*/
new_devfs_handle = devfs_mk_dir(de, name, (void *)labelcl_info);
if (!new_devfs_handle) {
labelcl_info_destroy(labelcl_info);
return(NULL);
}
/*
* Get the parent handle.
*/
parent = devfs_get_parent (new_devfs_handle);
/*
* To provide the same semantics as the hwgraph, set the connect point.
*/
rv = hwgraph_connectpt_set(new_devfs_handle, parent);
if (!rv) {
/*
* We need to clean up!
*/
}
/*
* If the caller provides a private data pointer, save it in the
* labelcl info structure(fastinfo). This can be retrieved via
* hwgraph_fastinfo_get()
*/
if (info)
hwgraph_fastinfo_set(new_devfs_handle, (arbitrary_info_t)info);
return(new_devfs_handle);
}
/* This is the registration and initialization section of the RAM disk driver */
int __init rd_init (void)
{
int i;
if (rd_blocksize > PAGE_SIZE || rd_blocksize < 512 ||
(rd_blocksize & (rd_blocksize-1)))
{
printk("RAMDISK: wrong blocksize %d, reverting to defaults\n",
rd_blocksize);
rd_blocksize = BLOCK_SIZE;
}
if (register_blkdev(MAJOR_NR, "ramdisk", &rd_bd_op)) {
printk("RAMDISK: Could not get major %d", MAJOR_NR);
return -EIO;
}
blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), &rd_make_request);
for (i = 0; i < NUM_RAMDISKS; i++) {
/* rd_size is given in kB */
rd_length[i] = rd_size << 10;
rd_hardsec[i] = rd_blocksize;
rd_blocksizes[i] = rd_blocksize;
rd_kbsize[i] = rd_size;
}
devfs_handle = devfs_mk_dir (NULL, "rd", NULL);
devfs_register_series (devfs_handle, "%u", NUM_RAMDISKS,
DEVFS_FL_DEFAULT, MAJOR_NR, 0,
S_IFBLK | S_IRUSR | S_IWUSR,
&rd_bd_op, NULL);
for (i = 0; i < NUM_RAMDISKS; i++)
register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &rd_bd_op, rd_size<<1);
#ifdef CONFIG_BLK_DEV_INITRD
/* We ought to separate initrd operations here */
register_disk(NULL, MKDEV(MAJOR_NR,INITRD_MINOR), 1, &rd_bd_op, rd_size<<1);
#endif
hardsect_size[MAJOR_NR] = rd_hardsec; /* Size of the RAM disk blocks */
blksize_size[MAJOR_NR] = rd_blocksizes; /* Avoid set_blocksize() check */
blk_size[MAJOR_NR] = rd_kbsize; /* Size of the RAM disk in kB */
/* rd_size is given in kB */
printk("RAMDISK driver initialized: "
"%d RAM disks of %dK size %d blocksize\n",
NUM_RAMDISKS, rd_size, rd_blocksize);
return 0;
}
static void __init unix98_pty_init(void)
{
devfs_mk_dir("pts");
ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
if (!ptm_driver)
panic("Couldn't allocate Unix98 ptm driver");
pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
if (!pts_driver)
panic("Couldn't allocate Unix98 pts driver");
ptm_driver->owner = THIS_MODULE;
ptm_driver->driver_name = "pty_master";
ptm_driver->name = "ptm";
ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
ptm_driver->minor_start = 0;
ptm_driver->type = TTY_DRIVER_TYPE_PTY;
ptm_driver->subtype = PTY_TYPE_MASTER;
ptm_driver->init_termios = tty_std_termios;
ptm_driver->init_termios.c_iflag = 0;
ptm_driver->init_termios.c_oflag = 0;
ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
ptm_driver->init_termios.c_lflag = 0;
ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
TTY_DRIVER_NO_DEVFS | TTY_DRIVER_DEVPTS_MEM;
ptm_driver->other = pts_driver;
tty_set_operations(ptm_driver, &pty_ops);
ptm_driver->ioctl = pty_unix98_ioctl;
pts_driver->owner = THIS_MODULE;
pts_driver->driver_name = "pty_slave";
pts_driver->name = "pts";
pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
pts_driver->minor_start = 0;
pts_driver->type = TTY_DRIVER_TYPE_PTY;
pts_driver->subtype = PTY_TYPE_SLAVE;
pts_driver->init_termios = tty_std_termios;
pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
TTY_DRIVER_NO_DEVFS | TTY_DRIVER_DEVPTS_MEM;
pts_driver->other = ptm_driver;
tty_set_operations(pts_driver, &pty_ops);
if (tty_register_driver(ptm_driver))
panic("Couldn't register Unix98 ptm driver");
if (tty_register_driver(pts_driver))
panic("Couldn't register Unix98 pts driver");
pty_table[1].data = &ptm_driver->refcount;
}
static int __init s3c2410_kbd_init(void)
{
int ret;
int oldiiccon;
int flags;
ret = set_external_irq(IRQ_KBD, EXT_FALLING_EDGE, GPIO_PULLUP_EN);
local_irq_save(flags);
IIC_init();
Set_IIC_mode(ZLG7289_IICCON, &oldiiccon);
ret=IIC_Read(ZLG7290_ADDR, 0);
//restore IICCON
Set_IIC_mode(oldiiccon, NULL);
local_irq_save(flags);
DPRINTK("zlg7290 system register=0x%x\n", ret);
KBD_CLOSE_INT();
ret = register_chrdev(0, DEVICE_NAME, &s3c2410_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't get major number\n");
return ret;
}
kbdMajor = ret;
/* Enable touch interrupt */
ret = request_irq(IRQ_KBD, s3c2410_isr_kbd,SA_INTERRUPT,
DEVICE_NAME, s3c2410_isr_kbd);
if (ret) {
return ret;
}
kbddev.head = kbddev.tail = 0;
kbddev.kbdmode= KEY_NULL;
init_waitqueue_head(&(kbddev.wq));
#ifdef CONFIG_DEVFS_FS
devfs_kbd_dir = devfs_mk_dir(NULL, "keyboard", NULL);
devfs_kbdraw = devfs_register(devfs_kbd_dir, "0raw", DEVFS_FL_DEFAULT,
kbdMajor, KBDRAW_MINOR, S_IFCHR | S_IRUSR | S_IWUSR, &s3c2410_fops, NULL);
#endif
printk (DEVICE_NAME"\tinitialized\n");
return 0;
}
void devfs_add_partitioned(struct gendisk *disk)
{
char dirname[64], symlink[16];
devfs_mk_dir(disk->devfs_name);
devfs_mk_bdev(MKDEV(disk->major, disk->first_minor),
S_IFBLK|S_IRUSR|S_IWUSR,
"%s/disc", disk->devfs_name);
disk->number = alloc_unique_number(&disc_numspace);
sprintf(symlink, "discs/disc%d", disk->number);
sprintf(dirname, "../%s", disk->devfs_name);
devfs_mk_symlink(symlink, dirname);
}
static int __init
gpio_init(void)
{
int i;
if (!(gpio_sbh = sb_kattach(SB_OSH)))
return -ENODEV;
sb_gpiosetcore(gpio_sbh);
if ((gpio_major = devfs_register_chrdev(0, "gpio", &gpio_fops)) < 0)
return gpio_major;
gpio_dir = devfs_mk_dir(NULL, "gpio", NULL);
for (i = 0; i < ARRAYSIZE(gpio_file); i++) {
gpio_file[i].handle = devfs_register(gpio_dir,
gpio_file[i].name,
DEVFS_FL_DEFAULT, gpio_major, i,
S_IFCHR | S_IRUGO | S_IWUGO,
&gpio_fops, NULL);
}
gpio_init_flag = 1;
if (iswrt350n)
{
// printk(KERN_EMERG "WRT350N GPIO Init\n");
/* For WRT350N USB LED control */
sb_gpioreserve(gpio_sbh, 0x400, GPIO_HI_PRIORITY);
sb_gpioouten(gpio_sbh, 0x400, 0x400, GPIO_HI_PRIORITY);
sb_gpioreserve(gpio_sbh, 0x800, GPIO_HI_PRIORITY);
sb_gpioouten(gpio_sbh, 0x800, 0x800, GPIO_HI_PRIORITY);
//if (nvram_match("disabled_5397", "1")) {
// printk("5397 switch GPIO-Reset \n");
sb_gpioreserve(gpio_sbh, 0x4, GPIO_HI_PRIORITY);
sb_gpioouten(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
sb_gpioout(gpio_sbh, 0x4, 0x4, GPIO_HI_PRIORITY);
//}
USB_SET_LED(USB_DISCONNECT); //2005-02-24 by kanki for USB LED
}
return 0;
}
static int __init module_lpc_init(void)
{
int i, val, ret;
char c;
// if (!DbgInit()) return -ENOMEM;
info(DRIVER_DESC " " DRIVER_VERSION);
ret = register_chrdev(major, DRIVER_DEV_NAME, &lpc_fops);
if (ret < 0)
{
err("register_chrdev(major=%d, \"" DRIVER_DEV_NAME "\")=%d -> failed", major, ret);
// DbgExit();
return ret;
}
if (major == 0) major = ret; // dynamic major
#ifdef CONFIG_DEVFS_FS
#warning CONFIG_DEVFS_FS not tested
ret = devfs_mk_dir("lpc");
dbg1("major=%d devfs_mk_dir()=%08X", major, ret);
#else
#warning Info: CONFIG_DEVFS_FS not used
#endif
ret = pci_module_init(&lpp_driver);
if( isa )
{
i = 0;
while( *isa && (i < MAX_LPCS*4) )
{
c = *isa++;
val = -1;
if((c >= '0') && (c <= '9')) val = c - '0';
if((c >= 'A') && (c <= 'F')) val = c + 10 - 'A';
if((c >= 'a') && (c <= 'f')) val = c + 10 - 'a';
if(val >= 0)
{
lpcs[i >> 2] = (lpcs[i >> 2] << 4) | val;
i++;
}
}
}
static int __init mmc_blk_init(void)
{
int res = -ENOMEM;
res = register_blkdev(major, "mmc");
if (res < 0) {
printk(KERN_WARNING "Unable to get major %d for MMC media: %d\n",
major, res);
goto out;
}
if (major == 0)
major = res;
devfs_mk_dir("mmc");
return mmc_register_driver(&mmc_driver);
out:
return res;
}
int slm_init( void )
{
if (devfs_register_chrdev( MAJOR_NR, "slm", &slm_fops )) {
printk( KERN_ERR "Unable to get major %d for ACSI SLM\n", MAJOR_NR );
return -EBUSY;
}
if (!(SLMBuffer = atari_stram_alloc( SLM_BUFFER_SIZE, "SLM" ))) {
printk( KERN_ERR "Unable to get SLM ST-Ram buffer.\n" );
devfs_unregister_chrdev( MAJOR_NR, "slm" );
return -ENOMEM;
}
BufferP = SLMBuffer;
SLMState = IDLE;
devfs_handle = devfs_mk_dir (NULL, "slm", NULL);
devfs_register_series (devfs_handle, "%u", MAX_SLM, DEVFS_FL_DEFAULT,
MAJOR_NR, 0, S_IFCHR | S_IRUSR | S_IWUSR,
&slm_fops, NULL);
return 0;
}
int usb_major_init(void)
{
int error;
error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
if (error) {
err("unable to get major %d for usb devices", USB_MAJOR);
goto out;
}
usb_class = class_simple_create(THIS_MODULE, "usb");
if (IS_ERR(usb_class)) {
err("class_simple_create failed for usb devices");
unregister_chrdev(USB_MAJOR, "usb");
goto out;
}
devfs_mk_dir("usb");
out:
return error;
}
static int __init adc_init(void)
{
int ret;
ret = register_chrdev(0,DEVICE_NAME,&adc_fops);
if(ret < 0) {
printk("adc: can't get major number\n");
return ret;
}
adc_major = ret;
peter_base_addr= ioremap(S3C2410_PA_ADC,0x20);
#ifdef CONFIG_DEVFS_FS
devfs_mk_dir("adc");
devfs_mk_cdev(MKDEV(adc_major, 0), S_IFCHR|S_IRUGO|S_IWUSR, "adc/%d", 0);
#endif
printk("s3c2410_adc driver initial\n");
return 0;
}
static int __init init_mtdchar(void)
{
#ifdef CONFIG_DEVFS_FS
if (devfs_register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))
{
printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
MTD_CHAR_MAJOR);
return -EAGAIN;
}
devfs_dir_handle = devfs_mk_dir(NULL, "mtd", NULL);
register_mtd_user(¬ifier);
#else
if (register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))
{
printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
MTD_CHAR_MAJOR);
return -EAGAIN;
}
#endif
return 0;
}
int __init pty_init(void)
{
int i;
/* Traditional BSD devices */
memset(&pty_state, 0, sizeof(pty_state));
for (i = 0; i < NR_PTYS; i++)
init_waitqueue_head(&pty_state[i].open_wait);
memset(&pty_driver, 0, sizeof(struct tty_driver));
pty_driver.magic = TTY_DRIVER_MAGIC;
pty_driver.driver_name = "pty_master";
#ifdef CONFIG_DEVFS_FS
pty_driver.name = "pty/m%d";
#else
pty_driver.name = "pty";
#endif
pty_driver.major = PTY_MASTER_MAJOR;
pty_driver.minor_start = 0;
pty_driver.num = NR_PTYS;
pty_driver.type = TTY_DRIVER_TYPE_PTY;
pty_driver.subtype = PTY_TYPE_MASTER;
pty_driver.init_termios = tty_std_termios;
pty_driver.init_termios.c_iflag = 0;
pty_driver.init_termios.c_oflag = 0;
pty_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
pty_driver.init_termios.c_lflag = 0;
pty_driver.flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
pty_driver.refcount = &pty_refcount;
pty_driver.table = pty_table;
pty_driver.termios = pty_termios;
pty_driver.termios_locked = pty_termios_locked;
pty_driver.driver_state = pty_state;
pty_driver.other = &pty_slave_driver;
pty_driver.open = pty_open;
pty_driver.close = pty_close;
pty_driver.write = pty_write;
pty_driver.write_room = pty_write_room;
pty_driver.flush_buffer = pty_flush_buffer;
pty_driver.chars_in_buffer = pty_chars_in_buffer;
pty_driver.unthrottle = pty_unthrottle;
pty_driver.set_termios = pty_set_termios;
pty_slave_driver = pty_driver;
pty_slave_driver.driver_name = "pty_slave";
pty_slave_driver.proc_entry = 0;
#ifdef CONFIG_DEVFS_FS
pty_slave_driver.name = "pty/s%d";
#else
pty_slave_driver.name = "ttyp";
#endif
pty_slave_driver.subtype = PTY_TYPE_SLAVE;
pty_slave_driver.major = PTY_SLAVE_MAJOR;
pty_slave_driver.minor_start = 0;
pty_slave_driver.init_termios = tty_std_termios;
pty_slave_driver.init_termios.c_cflag = B38400 | CS8 | CREAD;
/* Slave ptys are registered when their corresponding master pty
* is opened, and unregistered when the pair is closed.
*/
pty_slave_driver.flags |= TTY_DRIVER_NO_DEVFS;
pty_slave_driver.table = ttyp_table;
pty_slave_driver.termios = ttyp_termios;
pty_slave_driver.termios_locked = ttyp_termios_locked;
pty_slave_driver.driver_state = pty_state;
pty_slave_driver.other = &pty_driver;
if (tty_register_driver(&pty_driver))
panic("Couldn't register pty driver");
if (tty_register_driver(&pty_slave_driver))
panic("Couldn't register pty slave driver");
/*
* only the master pty gets this ioctl (which is why we
* assign it here, instead of up with the rest of the
* pty_driver initialization. <*****@*****.**>
*/
pty_driver.ioctl = pty_bsd_ioctl;
/* Unix98 devices */
#ifdef CONFIG_UNIX98_PTYS
devfs_mk_dir (NULL, "pts", NULL);
printk("pty: %d Unix98 ptys configured\n", UNIX98_NR_MAJORS*NR_PTYS);
for ( i = 0 ; i < UNIX98_NR_MAJORS ; i++ ) {
int j;
ptm_driver[i] = pty_driver;
ptm_driver[i].name = "ptm";
ptm_driver[i].proc_entry = 0;
ptm_driver[i].major = UNIX98_PTY_MASTER_MAJOR+i;
ptm_driver[i].minor_start = 0;
ptm_driver[i].name_base = i*NR_PTYS;
ptm_driver[i].num = NR_PTYS;
ptm_driver[i].other = &pts_driver[i];
ptm_driver[i].flags |= TTY_DRIVER_NO_DEVFS;
ptm_driver[i].table = ptm_table[i];
ptm_driver[i].termios = ptm_termios[i];
ptm_driver[i].termios_locked = ptm_termios_locked[i];
ptm_driver[i].driver_state = ptm_state[i];
for (j = 0; j < NR_PTYS; j++)
init_waitqueue_head(&ptm_state[i][j].open_wait);
pts_driver[i] = pty_slave_driver;
#ifdef CONFIG_DEVFS_FS
pts_driver[i].name = "pts/%d";
#else
pts_driver[i].name = "pts";
#endif
pts_driver[i].proc_entry = 0;
pts_driver[i].major = UNIX98_PTY_SLAVE_MAJOR+i;
pts_driver[i].minor_start = 0;
pts_driver[i].name_base = i*NR_PTYS;
pts_driver[i].num = ptm_driver[i].num;
pts_driver[i].other = &ptm_driver[i];
pts_driver[i].table = pts_table[i];
pts_driver[i].termios = pts_termios[i];
pts_driver[i].termios_locked = pts_termios_locked[i];
pts_driver[i].driver_state = ptm_state[i];
ptm_driver[i].ioctl = pty_unix98_ioctl;
if (tty_register_driver(&ptm_driver[i]))
panic("Couldn't register Unix98 ptm driver major %d",
ptm_driver[i].major);
if (tty_register_driver(&pts_driver[i]))
panic("Couldn't register Unix98 pts driver major %d",
pts_driver[i].major);
}
#endif
return 0;
}
static inline void mtdchar_devfs_init(void)
{
devfs_mk_dir("mtd");
register_mtd_user(¬ifier);
}
int init_module() {
printk(KERN_DEBUG "HIP: init_module\n");
SET_MODULE_OWNER(&file_ops);
devfs_hip_root = devfs_mk_dir(NULL, "hip", NULL);
if (!devfs_hip_root) {
printk(KERN_DEBUG "HIP: devfs_mk_dir failed\n");
return(-EBUSY);
}
printk(KERN_DEBUG "HIP: devfs_mk_dir ok\n");
/**
*devfs_register - Register a device entry.
*@dir: The handle to the parent devfs directory entry. If this is %NULL the
*new name is relative to the root of the devfs.
*@name: The name of the entry.
*@flags: A set of bitwise-ORed flags (DEVFS_FL_*).
*@major: The major number. Not needed for regular files.
*@minor: The minor number. Not needed for regular files.
*@mode: The default file mode.
*@ops: The &file_operations or &block_device_operations structure.
*This must not be externally deallocated.
*@info: An arbitrary pointer which will be written to the @private_data
*field of the &file structure passed to the device driver. You can set
*this to whatever you like, and change it once the file is opened (the next
*file opened will not see this change).
*
*Returns a handle which may later be used in a call to devfs_unregister().
*On failure %NULL is returned.
*/
/*
devfs_handle_t devfs_register (devfs_handle_t dir, const char *name,
unsigned int flags,
unsigned int major, unsigned int minor,
umode_t mode, void *ops, void *info)
*/
devfs_hip_dev = devfs_register(devfs_hip_root, "hipsocket",
DEVFS_FL_NONE,
HIP_CHAR_MAJOR,
0,
S_IFCHR | S_IRUSR | S_IWUSR,
&file_ops,
NULL);
if (!devfs_hip_dev) {
devfs_unregister(devfs_hip_root);
printk(KERN_DEBUG "HIP: devfs_register failed\n");
return(-EBUSY);
}
printk(KERN_DEBUG "HIP: devfs_register ok\n");
return 0;
}
int __init i2c_dev_init(void)
{
int res;
printk(KERN_INFO "i2c-dev.o: i2c /dev entries driver module version %s (%s)\n", I2C_VERSION, I2C_DATE);
i2cdev_initialized = 0;
#ifdef CONFIG_DEVFS_FS
if (devfs_register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops)) {
#else
if (register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops)) {
#endif
printk(KERN_ERR "i2c-dev.o: unable to get major %d for i2c bus\n",
I2C_MAJOR);
return -EIO;
}
#ifdef CONFIG_DEVFS_FS
devfs_handle = devfs_mk_dir(NULL, "i2c", NULL);
#endif
i2cdev_initialized ++;
if ((res = i2c_add_driver(&i2cdev_driver))) {
printk(KERN_ERR "i2c-dev.o: Driver registration failed, module not inserted.\n");
i2cdev_cleanup();
return res;
}
i2cdev_initialized ++;
return 0;
}
int i2cdev_cleanup(void)
{
int res;
if (i2cdev_initialized >= 2) {
if ((res = i2c_del_driver(&i2cdev_driver))) {
printk("i2c-dev.o: Driver deregistration failed, "
"module not removed.\n");
return res;
}
i2cdev_initialized --;
}
if (i2cdev_initialized >= 1) {
#ifdef CONFIG_DEVFS_FS
devfs_unregister(devfs_handle);
if ((res = devfs_unregister_chrdev(I2C_MAJOR, "i2c"))) {
#else
if ((res = unregister_chrdev(I2C_MAJOR,"i2c"))) {
#endif
printk("i2c-dev.o: unable to release major %d for i2c bus\n",
I2C_MAJOR);
return res;
}
i2cdev_initialized --;
}
return 0;
}
EXPORT_NO_SYMBOLS;
#ifdef MODULE
MODULE_AUTHOR("Frodo Looijaard <*****@*****.**> and Simon G. Vogl <*****@*****.**>");
MODULE_DESCRIPTION("I2C /dev entries driver");
MODULE_LICENSE("GPL");
int init_module(void)
{
return i2c_dev_init();
}
int cleanup_module(void)
{
return i2cdev_cleanup();
}
/*!
- ajout de sa structure de données dans smdstate
- création et connexion des segments + IT SCI
- création du rep DEVFS pour ce noeud
*/
int smd_add_snode(char *nom_node,
long no_sci) {
servernode_t *sn;
u32 no_snode;
PDEBUG("entering. Param : nom_node =%s no_sci=%ld\n",
nom_node,
no_sci);
no_snode = unused_elt_indice((void *)smd.snodes, NBMAX_SNODES);
if (no_snode == NBMAX_SNODES) {
PERROR("can't add the new server node because max number "
"( = %d) reached\n",
NBMAX_SNODES);
return ERROR;
}
PDEBUG("free elt indice %d of smd.snodes[] chosen\n", no_snode);
sn = vmalloc(sizeof(struct servernode));
if (sn == NULL) {
PERROR("can't allocate memory for new snode '%s'\n", nom_node);
goto error_vmalloc;
}
smd.snodes[no_snode] = sn;
sn->status = INSANE;
sscanf(nom_node, "%s", sn->name);
sn->dev_rep = devfs_mk_dir(smd.dev_rep, sn->name, NULL);
PDEBUG("sn->dev_rep = devfs_mk_dir(smd.dev_rep, sn->name, NULL) == %p\n",
sn->dev_rep);
if (sn->dev_rep == NULL) {
PERROR("can't create devfs rep for ze node %s\n",sn->name);
goto error_devfs;
}
sn->no_sci = no_sci;
sn->busy = IDLE;
sn->creq.kreq = NULL;
//for (i=0; i<NBMAX_DEVS; i++) sn->wreqs.nd = NULL
nullify_table((void *)sn->ndevs, NBMAX_NDEVS);
PDEBUG("devfs rep '%s' created\n", sn->name);
// init sci pour ce nouveau server node
if (smd_add_snode_sci(sn,no_sci)) {
printk(KERN_ERR "smd_add_snode_sci failed\n");
goto error_sci;
}
PDEBUG("sci structures for snode '%s' created\n", sn->name);
sn->maxsize_req = smd.dataseg_size / SMD_HARDSECT;
reset_sn_stats(sn);
//sn->status = UP;
smd.snodes[no_snode] = sn;
smd.nb_snodes++;
PDEBUG("server node '%s' added\n", sn->name);
return SUCCESS;
error_sci:
PDEBUG("devfs_unregister(sn->dev_rep = %p)\n", sn->dev_rep);
devfs_unregister(sn->dev_rep);
error_devfs:
vfree(sn);
smd.snodes[no_snode] = NULL;
error_vmalloc:
return ERROR;
}
