Module: xenomai-jki Branch: for-forge Commit: 91d3ea096da964334858561babdf29abc1154889 URL: http://git.xenomai.org/?p=xenomai-jki.git;a=commit;h=91d3ea096da964334858561babdf29abc1154889
Author: Jan Kiszka <jan.kis...@siemens.com> Date: Wed Aug 21 15:58:27 2013 +0200 rtcan: Update procfs usage to latest kernel API This both overcomes RTCAN_PROC_* macros and makes the CAN layer compatible with kernel 3.10. We simply switch all procfs nodes to seq_file. Signed-off-by: Jan Kiszka <jan.kis...@siemens.com> --- kernel/drivers/can/mscan/rtcan_mscan_proc.c | 147 ++++++------- kernel/drivers/can/rtcan_internal.h | 62 ------ kernel/drivers/can/rtcan_module.c | 266 +++++++++++------------ kernel/drivers/can/sja1000/rtcan_sja1000_proc.c | 48 ++--- 4 files changed, 220 insertions(+), 303 deletions(-) diff --git a/kernel/drivers/can/mscan/rtcan_mscan_proc.c b/kernel/drivers/can/mscan/rtcan_mscan_proc.c index 69f77a2..c5aad74 100644 --- a/kernel/drivers/can/mscan/rtcan_mscan_proc.c +++ b/kernel/drivers/can/mscan/rtcan_mscan_proc.c @@ -33,8 +33,7 @@ #ifdef CONFIG_XENO_DRIVERS_CAN_DEBUG -static int rtcan_mscan_proc_regs(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_mscan_proc_regs(struct seq_file *p, void *data) { struct rtcan_device *dev = (struct rtcan_device *)data; struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; @@ -43,98 +42,94 @@ static int rtcan_mscan_proc_regs(char *buf, char **start, off_t offset, u32 port_config; #endif u8 canctl0, canctl1; - RTCAN_PROC_PRINT_VARS(80); - if (!RTCAN_PROC_PRINT("MSCAN registers at %p\n", regs)) - goto done; + seq_printf(p, "MSCAN registers at %p\n", regs); + canctl0 = in_8(®s->canctl0); - if (!RTCAN_PROC_PRINT("canctl0 0x%02x%s%s%s%s%s%s%s%s\n", - canctl0, - (canctl0 & MSCAN_RXFRM) ? " rxfrm" :"", - (canctl0 & MSCAN_RXACT) ? " rxact" :"", - (canctl0 & MSCAN_CSWAI) ? " cswai" :"", - (canctl0 & MSCAN_SYNCH) ? " synch" :"", - (canctl0 & MSCAN_TIME) ? " time" :"", - (canctl0 & MSCAN_WUPE) ? " wupe" :"", - (canctl0 & MSCAN_SLPRQ) ? " slprq" :"", - (canctl0 & MSCAN_INITRQ)? " initrq":"" )) - goto done; + seq_printf(p, "canctl0 0x%02x%s%s%s%s%s%s%s%s\n", + canctl0, + (canctl0 & MSCAN_RXFRM) ? " rxfrm" :"", + (canctl0 & MSCAN_RXACT) ? " rxact" :"", + (canctl0 & MSCAN_CSWAI) ? " cswai" :"", + (canctl0 & MSCAN_SYNCH) ? " synch" :"", + (canctl0 & MSCAN_TIME) ? " time" :"", + (canctl0 & MSCAN_WUPE) ? " wupe" :"", + (canctl0 & MSCAN_SLPRQ) ? " slprq" :"", + (canctl0 & MSCAN_INITRQ)? " initrq":"" ); canctl1 = in_8(®s->canctl1); - if (!RTCAN_PROC_PRINT("canctl1 0x%02x%s%s%s%s%s%s%s\n", - canctl1, - (canctl1 & MSCAN_CANE) ? " cane" :"", - (canctl1 & MSCAN_CLKSRC)? " clksrc":"", - (canctl1 & MSCAN_LOOPB) ? " loopb" :"", - (canctl1 & MSCAN_LISTEN)? " listen":"", - (canctl1 & MSCAN_WUPM) ? " wump" :"", - (canctl1 & MSCAN_SLPAK) ? " slpak" :"", - (canctl1 & MSCAN_INITAK)? " initak":"")) - goto done; - if (!RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr0 )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr1 )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrflg )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrier )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantflg )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantier )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantarq )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantaak )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantbsel)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidac )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrxerr)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantxerr)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar0)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar1)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar2)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar3)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr0)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr1)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr2)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr3)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar4)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar5)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar6)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar7)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr4)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr5)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr6)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr7))) - goto done; + seq_printf(p, "canctl1 0x%02x%s%s%s%s%s%s%s\n", + canctl1, + (canctl1 & MSCAN_CANE) ? " cane" :"", + (canctl1 & MSCAN_CLKSRC)? " clksrc":"", + (canctl1 & MSCAN_LOOPB) ? " loopb" :"", + (canctl1 & MSCAN_LISTEN)? " listen":"", + (canctl1 & MSCAN_WUPM) ? " wump" :"", + (canctl1 & MSCAN_SLPAK) ? " slpak" :"", + (canctl1 & MSCAN_INITAK)? " initak":""); + seq_printf(p, MSCAN_REG_ARGS(canbtr0 )); + seq_printf(p, MSCAN_REG_ARGS(canbtr1 )); + seq_printf(p, MSCAN_REG_ARGS(canrflg )); + seq_printf(p, MSCAN_REG_ARGS(canrier )); + seq_printf(p, MSCAN_REG_ARGS(cantflg )); + seq_printf(p, MSCAN_REG_ARGS(cantier )); + seq_printf(p, MSCAN_REG_ARGS(cantarq )); + seq_printf(p, MSCAN_REG_ARGS(cantaak )); + seq_printf(p, MSCAN_REG_ARGS(cantbsel)); + seq_printf(p, MSCAN_REG_ARGS(canidac )); + seq_printf(p, MSCAN_REG_ARGS(canrxerr)); + seq_printf(p, MSCAN_REG_ARGS(cantxerr)); + seq_printf(p, MSCAN_REG_ARGS(canidar0)); + seq_printf(p, MSCAN_REG_ARGS(canidar1)); + seq_printf(p, MSCAN_REG_ARGS(canidar2)); + seq_printf(p, MSCAN_REG_ARGS(canidar3)); + seq_printf(p, MSCAN_REG_ARGS(canidmr0)); + seq_printf(p, MSCAN_REG_ARGS(canidmr1)); + seq_printf(p, MSCAN_REG_ARGS(canidmr2)); + seq_printf(p, MSCAN_REG_ARGS(canidmr3)); + seq_printf(p, MSCAN_REG_ARGS(canidar4)); + seq_printf(p, MSCAN_REG_ARGS(canidar5)); + seq_printf(p, MSCAN_REG_ARGS(canidar6)); + seq_printf(p, MSCAN_REG_ARGS(canidar7)); + seq_printf(p, MSCAN_REG_ARGS(canidmr4)); + seq_printf(p, MSCAN_REG_ARGS(canidmr5)); + seq_printf(p, MSCAN_REG_ARGS(canidmr6)); + seq_printf(p, MSCAN_REG_ARGS(canidmr7)); #ifdef MPC5xxx_GPIO - if (!RTCAN_PROC_PRINT("GPIO registers\n")) - goto done; + seq_printf(p, "GPIO registers\n"); port_config = in_be32(&gpio->port_config); - if (!RTCAN_PROC_PRINT("port_config 0x%08x %s\n", port_config, - (port_config & 0x10000000 ? - "CAN1 on I2C1, CAN2 on TMR0/1 pins": - (port_config & 0x70) == 0x10 ? - "CAN1/2 on PSC2 pins": "MSCAN1/2 not routed"))) - goto done; + seq_printf(p, "port_config 0x%08x %s\n", port_config, + (port_config & 0x10000000 ? + "CAN1 on I2C1, CAN2 on TMR0/1 pins" : + (port_config & 0x70) == 0x10 ? + "CAN1/2 on PSC2 pins" : + "MSCAN1/2 not routed")); #endif done: RTCAN_PROC_PRINT_DONE; } -int rtcan_mscan_create_proc(struct rtcan_device* dev) +static int rtcan_mscan_proc_regs_open(struct inode *inode, struct file *file) { - struct proc_dir_entry *proc_entry; + return single_open(file, rtcan_mscan_proc_regs, PDE_DATA(inode)); +} + +static const struct file_operations rtcan_mscan_proc_regs_ops = { + .open = rtcan_mscan_proc_regs_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; +int rtcan_mscan_create_proc(struct rtcan_device* dev) +{ if (!dev->proc_root) return -EINVAL; - proc_entry = create_proc_entry("registers", S_IFREG | S_IRUGO | S_IWUSR, - dev->proc_root); - if (!proc_entry) - goto error; - proc_entry->read_proc = rtcan_mscan_proc_regs; - proc_entry->data = dev; - + proc_create_data("registers", S_IFREG | S_IRUGO | S_IWUSR, + dev->proc_root, &rtcan_mscan_proc_regs_ops, dev); return 0; - -error: - printk("%s: unable to create /proc entries for MSCAN\n", dev->name); - return -1; } void rtcan_mscan_remove_proc(struct rtcan_device* dev) diff --git a/kernel/drivers/can/rtcan_internal.h b/kernel/drivers/can/rtcan_internal.h index 35b778a..5b87956 100644 --- a/kernel/drivers/can/rtcan_internal.h +++ b/kernel/drivers/can/rtcan_internal.h @@ -45,68 +45,6 @@ #define RTCAN_ASSERT(expr, func) #endif /* CONFIG_RTCAN_CHECKED */ -#ifdef CONFIG_PROC_FS -#include <linux/proc_fs.h> - -/* Derived from Erwin Rol's rtai_proc_fs.h. - Standard version assumes that output fits into the provided buffer, - extended version also deals with potential fragmentation. */ - -#define RTCAN_PROC_PRINT_VARS(MAX_BLOCK_LEN) \ - const int max_block_len = MAX_BLOCK_LEN; \ - off_t __limit = count - MAX_BLOCK_LEN; \ - int __len = 0; \ - \ - *eof = 1; \ - if (count < MAX_BLOCK_LEN) \ - return 0 - -#define RTCAN_PROC_PRINT(fmt, args...) \ - ({ \ - __len += snprintf(buf + __len, max_block_len, fmt, ##args); \ - (__len <= __limit); \ - }) - -#define RTCAN_PROC_PRINT_DONE \ - return __len - - -#define RTCAN_PROC_PRINT_VARS_EX(MAX_BLOCK_LEN) \ - const int max_block_len = MAX_BLOCK_LEN; \ - off_t __limit = offset + count - MAX_BLOCK_LEN; \ - off_t __pos = 0; \ - off_t __begin = 0; \ - int __len = 0; \ - \ - *eof = 1; \ - if (count < MAX_BLOCK_LEN) \ - return 0 - -#define RTCAN_PROC_PRINT_EX(fmt, args...) \ - ({ \ - int len = snprintf(buf + __len, max_block_len, fmt, ##args); \ - __len += len; \ - __pos += len; \ - if (__pos < offset) { \ - __len = 0; \ - __begin = __pos; \ - } \ - if (__pos > __limit) \ - *eof = 0; \ - (__pos <= __limit); \ - }) - -#define RTCAN_PROC_PRINT_DONE_EX \ - *start = buf + (offset - __begin); \ - __len -= (offset - __begin); \ - if (__len > count) \ - __len = count; \ - if (__len < 0) \ - __len = 0; \ - return __len; - -#endif /* CONFIG_PROC_FS */ - #ifdef CONFIG_XENO_DRIVERS_CAN_DEBUG # define RTCAN_DBG(fmt,args...) do { printk(fmt ,##args); } while (0) # define RTCAN_RTDM_DBG(fmt,args...) do { rtdm_printk(fmt ,##args); } while (0) diff --git a/kernel/drivers/can/rtcan_module.c b/kernel/drivers/can/rtcan_module.c index 6301f63..764df94 100644 --- a/kernel/drivers/can/rtcan_module.c +++ b/kernel/drivers/can/rtcan_module.c @@ -119,13 +119,11 @@ static void rtcan_get_timeout_name(nanosecs_rel_t timeout, snprintf(name, max_len, "%lld", (long long)timeout); } -static int rtcan_read_proc_devices(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_read_proc_devices(struct seq_file *p, void *data) { - int i, ret; + int i; struct rtcan_device *dev; char state_name[20], baudrate_name[20]; - RTCAN_PROC_PRINT_VARS(80); if (down_interruptible(&rtcan_devices_nrt_lock)) return -ERESTARTSYS; @@ -135,9 +133,8 @@ static int rtcan_read_proc_devices(char *buf, char **start, off_t offset, * rtcan1 undefined warning 1234567890 1234567890 1234567890 * rtcan2 undefined scanning 1234567890 1234567890 1234567890 */ - if (!RTCAN_PROC_PRINT("Name___________ _Baudrate State___ " - "TX_Counter RX_Counter ____Errors\n")) - goto done; + seq_printf(p, "Name___________ _Baudrate State___ TX_Counter RX_Counter " + "____Errors\n"); for (i = 1; i <= RTCAN_MAX_DEVICES; i++) { if ((dev = rtcan_dev_get_by_index(i)) != NULL) { @@ -145,23 +142,31 @@ static int rtcan_read_proc_devices(char *buf, char **start, off_t offset, state_name, sizeof(state_name)); rtcan_dev_get_baudrate_name(dev->baudrate, baudrate_name, sizeof(baudrate_name)); - ret = RTCAN_PROC_PRINT("%-15s %9s %-8s %10d %10d %10d\n", - dev->name, baudrate_name, state_name, - dev->tx_count, dev->rx_count, dev->err_count); + seq_printf(p, "%-15s %9s %-8s %10d %10d %10d\n", + dev->name, baudrate_name, state_name, dev->tx_count, + dev->rx_count, dev->err_count); rtcan_dev_dereference(dev); - if (!ret) - break; } } - done: up(&rtcan_devices_nrt_lock); - RTCAN_PROC_PRINT_DONE; + + return 0; } +static int rtcan_proc_devices_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_read_proc_devices, NULL); +} -static int rtcan_read_proc_sockets(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static const struct file_operations rtcan_proc_devices_ops = { + .open = rtcan_proc_devices_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static int rtcan_read_proc_sockets(struct seq_file *p, void *data) { struct rtcan_socket *sock; struct rtdm_dev_context *context; @@ -170,7 +175,6 @@ static int rtcan_read_proc_sockets(char *buf, char **start, off_t offset, char rx_timeout[20], tx_timeout[20]; rtdm_lockctx_t lock_ctx; int ifindex; - RTCAN_PROC_PRINT_VARS(120); if (down_interruptible(&rtcan_devices_nrt_lock)) return -ERESTARTSYS; @@ -178,9 +182,8 @@ static int rtcan_read_proc_sockets(char *buf, char **start, off_t offset, /* fd Name___________ Filter ErrMask RX_Timeout TX_Timeout RX_BufFull TX_Lo * 0 rtcan0 1 0x00010 1234567890 1234567890 1234567890 12345 */ - if (!RTCAN_PROC_PRINT("fd Name___________ Filter ErrMask RX_Timeout_ns " - "TX_Timeout_ns RX_BufFull TX_Lo\n")) - goto done; + seq_printf(p, "fd Name___________ Filter ErrMask RX_Timeout_ns " + "TX_Timeout_ns RX_BufFull TX_Lo\n"); rtdm_lock_get_irqsave(&rtcan_recv_list_lock, lock_ctx); @@ -201,29 +204,37 @@ static int rtcan_read_proc_sockets(char *buf, char **start, off_t offset, tx_timeout, sizeof(tx_timeout)); rtcan_get_timeout_name(sock->rx_timeout, rx_timeout, sizeof(rx_timeout)); - if (!RTCAN_PROC_PRINT("%2d %-15s %6d 0x%05x %13s %13s %10d %5d\n", - context->fd, name, sock->flistlen, - sock->err_mask, rx_timeout, tx_timeout, - sock->rx_buf_full, - rtcan_loopback_enabled(sock))) - break; + seq_printf(p, "%2d %-15s %6d 0x%05x %13s %13s %10d %5d\n", + context->fd, name, sock->flistlen, sock->err_mask, + rx_timeout, tx_timeout, sock->rx_buf_full, + rtcan_loopback_enabled(sock)); } rtdm_lock_put_irqrestore(&rtcan_recv_list_lock, lock_ctx); - done: up(&rtcan_devices_nrt_lock); - RTCAN_PROC_PRINT_DONE; + + return 0; +} + +static int rtcan_proc_sockets_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_read_proc_sockets, NULL); } +static const struct file_operations rtcan_proc_sockets_ops = { + .open = rtcan_proc_sockets_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + -static int rtcan_read_proc_info(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_read_proc_info(struct seq_file *p, void *data) { - struct rtcan_device *dev = (struct rtcan_device *)data; + struct rtcan_device *dev = p->private; char state_name[20], baudrate_name[20]; char ctrlmode_name[80], bittime_name[80]; - RTCAN_PROC_PRINT_VARS(80); if (down_interruptible(&rtcan_devices_nrt_lock)) return -ERESTARTSYS; @@ -237,46 +248,52 @@ static int rtcan_read_proc_info(char *buf, char **start, off_t offset, rtcan_dev_get_bittime_name(&dev->bit_time, bittime_name, sizeof(bittime_name)); - if (!RTCAN_PROC_PRINT("%s %s\n", "Device ", dev->name) || - !RTCAN_PROC_PRINT("%s %s\n", "Controller", dev->ctrl_name) || - !RTCAN_PROC_PRINT("%s %s\n", "Board ", dev->board_name) || - !RTCAN_PROC_PRINT("%s %d\n", "Clock-Hz ", dev->can_sys_clock) || - !RTCAN_PROC_PRINT("%s %s\n", "Baudrate ", baudrate_name) || - !RTCAN_PROC_PRINT("%s %s\n", "Bit-time ", bittime_name) || - !RTCAN_PROC_PRINT("%s %s\n", "Ctrl-Mode ", ctrlmode_name) || - !RTCAN_PROC_PRINT("%s %s\n", "State ", state_name) || - !RTCAN_PROC_PRINT("%s %d\n", "TX-Counter", dev->tx_count) || - !RTCAN_PROC_PRINT("%s %d\n", "RX-Counter", dev->rx_count) || - !RTCAN_PROC_PRINT("%s %d\n", "Errors ", dev->err_count)) - goto done; - + seq_printf(p, "Device %s\n", dev->name); + seq_printf(p, "Controller %s\n", dev->ctrl_name); + seq_printf(p, "Board %s\n", dev->board_name); + seq_printf(p, "Clock-Hz %d\n", dev->can_sys_clock); + seq_printf(p, "Baudrate %s\n", baudrate_name); + seq_printf(p, "Bit-time %s\n", bittime_name); + seq_printf(p, "Ctrl-Mode %s\n", ctrlmode_name); + seq_printf(p, "State %s\n", state_name); + seq_printf(p, "TX-Counter %d\n", dev->tx_count); + seq_printf(p, "RX-Counter %d\n", dev->rx_count); + seq_printf(p, "Errors %d\n", dev->err_count); #ifdef RTCAN_USE_REFCOUNT - if (!RTCAN_PROC_PRINT("%s %d\n", "Refcount ", atomic_read(&dev->refcount))) - goto done; + seq_printf(p, "Refcount %d\n", atomic_read(&dev->refcount)); #endif - done: up(&rtcan_devices_nrt_lock); - RTCAN_PROC_PRINT_DONE; + + return 0; +} + +static int rtcan_proc_info_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_read_proc_info, PDE_DATA(inode)); } +static const struct file_operations rtcan_proc_info_ops = { + .open = rtcan_proc_info_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + -static int rtcan_read_proc_filter(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_read_proc_filter(struct seq_file *p, void *data) { - struct rtcan_device *dev = (struct rtcan_device *)data; + struct rtcan_device *dev = p->private; struct rtcan_recv *recv_listener = dev->recv_list; struct rtdm_dev_context *context; rtdm_lockctx_t lock_ctx; - RTCAN_PROC_PRINT_VARS(80); /* fd __CAN_ID__ _CAN_Mask_ Inv MatchCount * 3 0x12345678 0x12345678 no 1234567890 */ - if (!RTCAN_PROC_PRINT("fd __CAN_ID__ _CAN_Mask_ Inv MatchCount\n")) - goto done; + seq_printf(p, "fd __CAN_ID__ _CAN_Mask_ Inv MatchCount\n"); rtdm_lock_get_irqsave(&rtcan_recv_list_lock, lock_ctx); @@ -284,38 +301,57 @@ static int rtcan_read_proc_filter(char *buf, char **start, off_t offset, while (recv_listener != NULL) { context = rtcan_socket_context(recv_listener->sock); - if (!RTCAN_PROC_PRINT("%2d 0x%08x 0x%08x %s %10d\n", - context->fd, - recv_listener->can_filter.can_id, - recv_listener->can_filter.can_mask & - ~CAN_INV_FILTER, - (recv_listener->can_filter.can_mask & - CAN_INV_FILTER) ? "yes" : " no", - recv_listener->match_count)) - break; + seq_printf(p, "%2d 0x%08x 0x%08x %s %10d\n", + context->fd, + recv_listener->can_filter.can_id, + recv_listener->can_filter.can_mask & ~CAN_INV_FILTER, + (recv_listener->can_filter.can_mask & CAN_INV_FILTER) ? + "yes" : " no", + recv_listener->match_count); + recv_listener = recv_listener->next; } rtdm_lock_put_irqrestore(&rtcan_recv_list_lock, lock_ctx); - done: - RTCAN_PROC_PRINT_DONE; + return 0; } +static int rtcan_proc_filter_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_read_proc_filter, PDE_DATA(inode)); +} + +static const struct file_operations rtcan_proc_filter_ops = { + .open = rtcan_proc_filter_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + -static int rtcan_read_proc_version(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_read_proc_version(struct seq_file *p, void *data) { - RTCAN_PROC_PRINT_VARS(80); + seq_printf(p, "RT-Socket-CAN %d.%d.%d - built on %s %s\n", + RTCAN_MAJOR_VER, RTCAN_MINOR_VER, RTCAN_BUGFIX_VER, + __DATE__, __TIME__); - RTCAN_PROC_PRINT("RT-Socket-CAN %d.%d.%d - built on %s %s\n", - RTCAN_MAJOR_VER, RTCAN_MINOR_VER, RTCAN_BUGFIX_VER, - __DATE__, __TIME__); + return 0; +} - RTCAN_PROC_PRINT_DONE; +static int rtcan_proc_version_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_read_proc_version, NULL); } +static const struct file_operations rtcan_proc_version_ops = { + .open = rtcan_proc_version_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + void rtcan_dev_remove_proc(struct rtcan_device* dev) { @@ -331,82 +367,39 @@ void rtcan_dev_remove_proc(struct rtcan_device* dev) int rtcan_dev_create_proc(struct rtcan_device* dev) { - struct proc_dir_entry *proc_entry; - if (!rtcan_proc_root) return -EINVAL; - dev->proc_root = create_proc_entry(dev->name, S_IFDIR, rtcan_proc_root); - if (!dev->proc_root) - goto error1; - - proc_entry = create_proc_entry("info", S_IFREG | S_IRUGO | S_IWUSR, - dev->proc_root); - if (!proc_entry) - goto error2; - proc_entry->read_proc = rtcan_read_proc_info; - proc_entry->data = dev; - - proc_entry = create_proc_entry("filters", S_IFREG | S_IRUGO | S_IWUSR, - dev->proc_root); - if (!proc_entry) - goto error3; - proc_entry->read_proc = rtcan_read_proc_filter; - proc_entry->data = dev; + dev->proc_root = proc_mkdir(dev->name, rtcan_proc_root); + if (!dev->proc_root) { + printk("%s: unable to create /proc device entries\n", dev->name); + return -1; + } + proc_create_data("info", S_IFREG | S_IRUGO | S_IWUSR, dev->proc_root, + &rtcan_proc_info_ops, dev); + proc_create_data("filters", S_IFREG | S_IRUGO | S_IWUSR, dev->proc_root, + &rtcan_proc_filter_ops, dev); return 0; - error3: - remove_proc_entry("info", dev->proc_root); - error2: - remove_proc_entry(dev->name, rtcan_proc_root); - error1: - printk("%s: unable to create /proc device entries\n", dev->name); - return -1; - } static int rtcan_proc_register(void) { - struct proc_dir_entry *proc_entry; - - rtcan_proc_root = create_proc_entry("rtcan", S_IFDIR, 0); - if (!rtcan_proc_root) - goto error1; - - proc_entry = create_proc_entry("devices", S_IFREG | S_IRUGO | S_IWUSR, - rtcan_proc_root); - if (!proc_entry) - goto error2; - proc_entry->read_proc = rtcan_read_proc_devices; - - proc_entry = create_proc_entry("version", S_IFREG | S_IRUGO | S_IWUSR, - rtcan_proc_root); - if (!proc_entry) - goto error3; - proc_entry->read_proc = rtcan_read_proc_version; - - proc_entry = create_proc_entry("sockets", S_IFREG | S_IRUGO | S_IWUSR, - rtcan_proc_root); - if (!proc_entry) - goto error4; - proc_entry->read_proc = rtcan_read_proc_sockets; + rtcan_proc_root = proc_mkdir("rtcan", NULL); + if (!rtcan_proc_root) { + printk("rtcan: unable to initialize /proc entries\n"); + return -1; + } + proc_create("devices", S_IFREG | S_IRUGO | S_IWUSR, rtcan_proc_root, + &rtcan_proc_devices_ops); + proc_create("version", S_IFREG | S_IRUGO | S_IWUSR, rtcan_proc_root, + &rtcan_proc_version_ops); + proc_create("sockets", S_IFREG | S_IRUGO | S_IWUSR, rtcan_proc_root, + &rtcan_proc_sockets_ops); return 0; - - error4: - remove_proc_entry("version", rtcan_proc_root); - - error3: - remove_proc_entry("devices", rtcan_proc_root); - - error2: - remove_proc_entry("rtcan", 0); - - error1: - printk("rtcan: unable to initialize /proc entries\n"); - return -1; } @@ -446,7 +439,6 @@ int __init rtcan_init(void) void __exit rtcan_exit(void) { - rtcan_raw_proto_unregister(); #ifdef CONFIG_PROC_FS rtcan_proc_unregister(); diff --git a/kernel/drivers/can/sja1000/rtcan_sja1000_proc.c b/kernel/drivers/can/sja1000/rtcan_sja1000_proc.c index ae80b9a..d8e0a7f 100644 --- a/kernel/drivers/can/sja1000/rtcan_sja1000_proc.c +++ b/kernel/drivers/can/sja1000/rtcan_sja1000_proc.c @@ -29,50 +29,42 @@ #ifdef CONFIG_XENO_DRIVERS_CAN_DEBUG -static int rtcan_sja_proc_regs(char *buf, char **start, off_t offset, - int count, int *eof, void *data) +static int rtcan_sja_proc_regs(struct seq_file *p, void *data) { struct rtcan_device *dev = (struct rtcan_device *)data; struct rtcan_sja1000 *chip = (struct rtcan_sja1000 *)dev->priv; int i; - RTCAN_PROC_PRINT_VARS(80); - if (!RTCAN_PROC_PRINT("SJA1000 registers")) - goto done; + seq_printf(p, "SJA1000 registers"); for (i = 0; i < 0x20; i++) { - if ((i % 0x10) == 0) { - if (!RTCAN_PROC_PRINT("\n%02x:", i)) - goto done; - } - if (!RTCAN_PROC_PRINT(" %02x", chip->read_reg(dev, i))) - goto done; + if ((i % 0x10) == 0) + seq_printf(p, "\n%02x:", i); + seq_printf(p, " %02x", chip->read_reg(dev, i)); } - if (!RTCAN_PROC_PRINT("\n")) - goto done; + seq_printf(p, "\n"); + return 0; +} - done: - RTCAN_PROC_PRINT_DONE; +static int rtcan_sja_proc_regs_open(struct inode *inode, struct file *file) +{ + return single_open(file, rtcan_sja_proc_regs, PDE_DATA(inode)); } +static const struct file_operations rtcan_sja_proc_regs_ops = { + .open = rtcan_sja_proc_regs_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + int rtcan_sja_create_proc(struct rtcan_device* dev) { - struct proc_dir_entry *proc_entry; - if (!dev->proc_root) return -EINVAL; - proc_entry = create_proc_entry("registers", S_IFREG | S_IRUGO | S_IWUSR, - dev->proc_root); - if (!proc_entry) - goto error; - proc_entry->read_proc = rtcan_sja_proc_regs; - proc_entry->data = dev; - + proc_create_data("registers", S_IFREG | S_IRUGO | S_IWUSR, dev->proc_root, + &rtcan_sja_proc_regs_ops, dev); return 0; - - error: - printk("%s: unable to create /proc entries for SJA\n", dev->name); - return -1; } void rtcan_sja_remove_proc(struct rtcan_device* dev) _______________________________________________ Xenomai-git mailing list Xenomai-git@xenomai.org http://www.xenomai.org/mailman/listinfo/xenomai-git