-/* proc.c
- * Linux CAN-bus device driver.
- * Written by Arnaud Westenberg email:arnaud@wanadoo.nl
- * Rewritten for new CAN queues by Pavel Pisa - OCERA team member
- * email:pisa@cmp.felk.cvut.cz
- * This software is released under the GPL-License.
- * Version lincan-0.3 17 Jun 2004
- */
+/**************************************************************************/
+/* File: proc.c - proc filesystem entries for CAN driver */
+/* */
+/* LinCAN - (Not only) Linux CAN bus driver */
+/* Copyright (C) 2002-2009 DCE FEE CTU Prague <http://dce.felk.cvut.cz> */
+/* Copyright (C) 2002-2009 Pavel Pisa <pisa@cmp.felk.cvut.cz> */
+/* Funded by OCERA and FRESCOR IST projects */
+/* Based on CAN driver code by Arnaud Westenberg <arnaud@wanadoo.nl> */
+/* */
+/* LinCAN is free software; you can redistribute it and/or modify it */
+/* under terms of the GNU General Public License as published by the */
+/* Free Software Foundation; either version 2, or (at your option) any */
+/* later version. LinCAN is distributed in the hope that it will be */
+/* useful, but WITHOUT ANY WARRANTY; without even the implied warranty */
+/* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU */
+/* General Public License for more details. You should have received a */
+/* copy of the GNU General Public License along with LinCAN; see file */
+/* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, */
+/* Cambridge, MA 02139, USA. */
+/* */
+/* To allow use of LinCAN in the compact embedded systems firmware */
+/* and RT-executives (RTEMS for example), main authors agree with next */
+/* special exception: */
+/* */
+/* Including LinCAN header files in a file, instantiating LinCAN generics */
+/* or templates, or linking other files with LinCAN objects to produce */
+/* an application image/executable, does not by itself cause the */
+/* resulting application image/executable to be covered by */
+/* the GNU General Public License. */
+/* This exception does not however invalidate any other reasons */
+/* why the executable file might be covered by the GNU Public License. */
+/* Publication of enhanced or derived LinCAN files is required although. */
+/**************************************************************************/
#include "../include/can.h"
#include "../include/can_sysdep.h"
struct proc_dir_entry *new_entry = NULL;
char *namestore;
int namelen;
-
+
if(!name || !parent)
return NULL;
namelen=strlen(name);
if(!namelen)
return NULL;
- new_entry = (struct proc_dir_entry *)
+ new_entry = (struct proc_dir_entry *)
can_checked_malloc(sizeof(struct proc_dir_entry)+namelen+1);
if (new_entry == NULL)
return new_entry;
}
-static int can_remove_proc_entry(struct proc_dir_entry *del, struct proc_dir_entry *parent)
+struct proc_dir_entry *can_create_proc_read_entry(const char *name,
+ mode_t mode, struct proc_dir_entry *parent,
+ read_proc_t *read_proc, void * data)
+{
+ return create_proc_read_entry(name, mode, parent, read_proc, data);
+}
+
+struct proc_dir_entry *can_proc_mkdir_mode(const char *name, umode_t mode,
+ struct proc_dir_entry *parent)
+{
+ return can_create_proc_entry(name, S_IFDIR | mode, parent);
+}
+
+static int can_proc_remove(struct proc_dir_entry *del)
{
if (del != NULL) {
- proc_unregister(parent, del->low_ino);
+ proc_unregister(del->parent, del->low_ino);
can_checked_free(del);
return 0;
}
static int can_proc_readlink(struct proc_dir_entry *ent, char *page)
{
char *link_dest = (char*)ent->data;
-
+
strcpy(page, link_dest);
return strlen(link_dest);
}
struct proc_dir_entry *parent, const char *dest)
{
struct proc_dir_entry *entry;
-
-
+
+
entry = can_create_proc_entry(name, S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO, parent);
if (entry == NULL)
return NULL;
return entry;
}
-#else /* Functions forwarded for kernel 2.4 and above */
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
-static inline struct proc_dir_entry * can_create_proc_entry(const char *name, mode_t mode,
- struct proc_dir_entry *parent)
+struct proc_dir_entry *can_create_proc_read_entry(const char *name,
+ mode_t mode, struct proc_dir_entry *parent,
+ read_proc_t *read_proc, void * data)
{
- return create_proc_entry(name, mode, parent);
+ return create_proc_read_entry(name, mode, parent, read_proc, data);
}
+struct proc_dir_entry *can_proc_mkdir_mode(const char *name, umode_t mode,
+ struct proc_dir_entry *parent)
+{
+ return create_proc_entry(name, S_IFDIR | mode, parent);
+}
/* This does not fully follow linux 2.4 and 2.6 prototype to simplify 2.2.x compatibility */
/* The newer kernels use entry name instead of pointer to the entry */
-static int can_remove_proc_entry(struct proc_dir_entry *del, struct proc_dir_entry *parent)
+static int can_proc_remove(struct proc_dir_entry *del)
+{
+ if(!del) return -ENODEV;
+ remove_proc_entry(del->name, del->parent);
+ return 0;
+}
+
+static inline struct proc_dir_entry *can_proc_symlink(const char *name,
+ struct proc_dir_entry *parent, const char *dest)
+{
+ return proc_symlink(name, parent, dest);
+}
+
+#else /* Linux kernel 3.10+ */
+
+#include <linux/seq_file.h>
+
+static int can_status_proc_show(struct seq_file *m, void *v)
+{
+ seq_printf(m, "dummy CAN can_create_proc_read_entry implementation\n");
+ return 0;
+}
+
+static int can_status_proc_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, can_status_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations can_status_proc_fops = {
+ .owner = THIS_MODULE,
+ .open = can_status_proc_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+struct proc_dir_entry *can_create_proc_read_entry(const char *name,
+ mode_t mode, struct proc_dir_entry *parent,
+ void *read_proc, void * data)
+{
+ /*return proc_read_entry(name, mode, parent, read_proc, data);*/
+ return proc_create_data(name, mode, parent, &can_status_proc_fops, data);
+}
+
+struct proc_dir_entry *can_proc_mkdir_mode(const char *name, umode_t mode,
+ struct proc_dir_entry *parent)
+{
+ return proc_mkdir_mode(name, mode, parent);
+}
+
+static int can_proc_remove(struct proc_dir_entry *del)
{
if(!del) return -ENODEV;
- remove_proc_entry(del->name,parent);
+ proc_remove(del);
return 0;
}
{
int board;
struct candevice_t *candev;
- base->can_proc_entry = can_create_proc_entry("can", S_IFDIR | S_IRUGO |
+ base->can_proc_entry = can_proc_mkdir_mode("can", S_IFDIR | S_IRUGO |
S_IXUGO, CAN_PROC_ROOT);
if (base->can_proc_entry == NULL)
return -ENODEV;
for (board=0; board<hardware_p->nr_boards; board++) {
candev=hardware_p->candevice[board];
if(candev) add_channel_to_procdir(candev);
- }
+ }
return 0;
}
/* can_delete_procdir removes the entire CAN tree from the proc system */
int can_delete_procdir(void)
{
- if (remove_channel_from_procdir())
+ if (remove_channel_from_procdir())
return -ENODEV;
/* name: "can" */
- if (can_remove_proc_entry(base->can_proc_entry, CAN_PROC_ROOT))
+ if (can_proc_remove(base->can_proc_entry))
return -ENODEV;
return 0;
}
-static int can_chip_procinfo(char *buf, char **start, off_t offset,
+static int can_chip_procinfo(char *buf, char **start, off_t offset,
int count, int *eof, void *data)
{
struct canchip_t *chip=data;
return -ENOMEM;
sprintf(base->channel[cc]->ch_name, "channel%d",cc);
-
- base->channel[cc]->ch_entry = can_create_proc_entry(
+
+ base->channel[cc]->ch_entry = can_proc_mkdir_mode(
base->channel[cc]->ch_name,
S_IFDIR | S_IRUGO |S_IXUGO,
base->can_proc_entry);
add_object_to_procdir(cc);
- create_proc_read_entry("chip_info", /* proc entry name */
+ can_create_proc_read_entry("chip_info", /* proc entry name */
0, /* protection mask, 0->default */
base->channel[cc]->ch_entry, /* parent dir, NULL->/proc */
can_chip_procinfo,
candev->chip[i]);
cc++;
- }
+ }
return 0;
}
int remove_channel_from_procdir(void)
{
-
+
while (cc != 0) {
cc--;
-
+
if(!base->channel[cc]) continue;
remove_proc_entry("chip_info", base->channel[cc]->ch_entry);
-
+
if (remove_object_from_procdir(cc))
- return -ENODEV;
-
+ return -ENODEV;
+
/* name: base->channel[cc]->ch_name */
- if (can_remove_proc_entry(base->channel[cc]->ch_entry,
- base->can_proc_entry))
+ if (can_proc_remove(base->channel[cc]->ch_entry))
return -ENODEV;
-
+
can_checked_free(base->channel[cc]);
base->channel[cc] = NULL;
}
sprintf(base->channel[chip_nr]->object[i]->obj_name,"object%d",i);
sprintf(base->channel[chip_nr]->object[i]->lnk_name,"dev");
-
- base->channel[chip_nr]->object[i]->obj_entry = can_create_proc_entry(
+
+ base->channel[chip_nr]->object[i]->obj_entry = can_proc_mkdir_mode(
base->channel[chip_nr]->object[i]->obj_name,
S_IFDIR | S_IRUGO | S_IXUGO,
base->channel[chip_nr]->ch_entry);
}
return 0;
-}
+}
int remove_object_from_procdir(int chip_nr)
{
for (i=0; i<obj; i++) {
if(!base->channel[chip_nr]->object[i]) continue;
-
+
/* name: base->channel[chip_nr]->object[i]->lnk_name */
- if (can_remove_proc_entry( base->channel[chip_nr]->object[i]->lnk,
- base->channel[chip_nr]->object[i]->obj_entry))
+ if (can_proc_remove( base->channel[chip_nr]->object[i]->lnk))
return -ENODEV;
/* name: base->channel[chip_nr]->object[i]->obj_name */
- if (can_remove_proc_entry(
- base->channel[chip_nr]->object[i]->obj_entry,
- base->channel[chip_nr]->ch_entry))
+ if (can_proc_remove(base->channel[chip_nr]->object[i]->obj_entry))
return -ENODEV;
can_checked_free(base->channel[chip_nr]->object[i]);
projects / lincan.git / blobdiff