2 * IBM ASM Service Processor Device Driver
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 * Copyright (C) IBM Corporation, 2004
20 * Author: Max Asböck <amax@us.ibm.com>
25 * Parts of this code are based on an article by Jonathan Corbet
26 * that appeared in Linux Weekly News.
31 * The IBMASM file virtual filesystem. It creates the following hierarchy
32 * dymamically when mounted from user space:
38 * | |-- reverse_heartbeat
49 * |-- reverse_heartbeat
55 * For each service processor the following files are created:
57 * command: execute dot commands
58 * write: execute a dot command on the service processor
59 * read: return the result of a previously executed dot command
61 * events: listen for service processor events
62 * read: sleep (interruptible) until an event occurs
63 * write: wakeup sleeping event listener
65 * reverse_heartbeat: send a heartbeat to the service processor
66 * read: sleep (interruptible) until the reverse heartbeat fails
67 * write: wakeup sleeping heartbeat listener
71 * remote_video/width: control remote display settings
77 #include <linux/pagemap.h>
78 #include <asm/uaccess.h>
82 #include "dot_command.h"
84 #define IBMASMFS_MAGIC 0x66726f67
86 static LIST_HEAD(service_processors);
88 static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode);
89 static void ibmasmfs_create_files (struct super_block *sb, struct dentry *root);
90 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent);
93 static int ibmasmfs_get_super(struct file_system_type *fst,
94 int flags, const char *name, void *data,
97 return get_sb_single(fst, flags, data, ibmasmfs_fill_super, mnt);
100 static struct super_operations ibmasmfs_s_ops = {
101 .statfs = simple_statfs,
102 .drop_inode = generic_delete_inode,
105 static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
107 static struct file_system_type ibmasmfs_type = {
108 .owner = THIS_MODULE,
110 .get_sb = ibmasmfs_get_super,
111 .kill_sb = kill_litter_super,
114 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
117 struct dentry *root_dentry;
119 sb->s_blocksize = PAGE_CACHE_SIZE;
120 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
121 sb->s_magic = IBMASMFS_MAGIC;
122 sb->s_op = &ibmasmfs_s_ops;
125 root = ibmasmfs_make_inode (sb, S_IFDIR | 0500);
129 root->i_op = &simple_dir_inode_operations;
130 root->i_fop = ibmasmfs_dir_ops;
132 root_dentry = d_alloc_root(root);
137 sb->s_root = root_dentry;
139 ibmasmfs_create_files(sb, root_dentry);
143 static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
145 struct inode *ret = new_inode(sb);
149 ret->i_uid = ret->i_gid = 0;
150 ret->i_blksize = PAGE_CACHE_SIZE;
152 ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
157 static struct dentry *ibmasmfs_create_file (struct super_block *sb,
158 struct dentry *parent,
160 struct file_operations *fops,
164 struct dentry *dentry;
167 dentry = d_alloc_name(parent, name);
171 inode = ibmasmfs_make_inode(sb, S_IFREG | mode);
178 inode->u.generic_ip = data;
180 d_add(dentry, inode);
184 static struct dentry *ibmasmfs_create_dir (struct super_block *sb,
185 struct dentry *parent,
188 struct dentry *dentry;
191 dentry = d_alloc_name(parent, name);
195 inode = ibmasmfs_make_inode(sb, S_IFDIR | 0500);
201 inode->i_op = &simple_dir_inode_operations;
202 inode->i_fop = ibmasmfs_dir_ops;
204 d_add(dentry, inode);
208 int ibmasmfs_register(void)
210 return register_filesystem(&ibmasmfs_type);
213 void ibmasmfs_unregister(void)
215 unregister_filesystem(&ibmasmfs_type);
218 void ibmasmfs_add_sp(struct service_processor *sp)
220 list_add(&sp->node, &service_processors);
223 /* struct to save state between command file operations */
224 struct ibmasmfs_command_data {
225 struct service_processor *sp;
226 struct command *command;
229 /* struct to save state between event file operations */
230 struct ibmasmfs_event_data {
231 struct service_processor *sp;
232 struct event_reader reader;
236 /* struct to save state between reverse heartbeat file operations */
237 struct ibmasmfs_heartbeat_data {
238 struct service_processor *sp;
239 struct reverse_heartbeat heartbeat;
243 static int command_file_open(struct inode *inode, struct file *file)
245 struct ibmasmfs_command_data *command_data;
247 if (!inode->u.generic_ip)
250 command_data = kmalloc(sizeof(struct ibmasmfs_command_data), GFP_KERNEL);
254 command_data->command = NULL;
255 command_data->sp = inode->u.generic_ip;
256 file->private_data = command_data;
260 static int command_file_close(struct inode *inode, struct file *file)
262 struct ibmasmfs_command_data *command_data = file->private_data;
264 if (command_data->command)
265 command_put(command_data->command);
271 static ssize_t command_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
273 struct ibmasmfs_command_data *command_data = file->private_data;
280 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
285 spin_lock_irqsave(&command_data->sp->lock, flags);
286 cmd = command_data->command;
288 spin_unlock_irqrestore(&command_data->sp->lock, flags);
291 command_data->command = NULL;
292 spin_unlock_irqrestore(&command_data->sp->lock, flags);
294 if (cmd->status != IBMASM_CMD_COMPLETE) {
298 len = min(count, cmd->buffer_size);
299 if (copy_to_user(buf, cmd->buffer, len)) {
308 static ssize_t command_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
310 struct ibmasmfs_command_data *command_data = file->private_data;
316 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
321 /* commands are executed sequentially, only one command at a time */
322 if (command_data->command)
325 cmd = ibmasm_new_command(command_data->sp, count);
329 if (copy_from_user(cmd->buffer, ubuff, count)) {
334 spin_lock_irqsave(&command_data->sp->lock, flags);
335 if (command_data->command) {
336 spin_unlock_irqrestore(&command_data->sp->lock, flags);
340 command_data->command = cmd;
341 spin_unlock_irqrestore(&command_data->sp->lock, flags);
343 ibmasm_exec_command(command_data->sp, cmd);
344 ibmasm_wait_for_response(cmd, get_dot_command_timeout(cmd->buffer));
349 static int event_file_open(struct inode *inode, struct file *file)
351 struct ibmasmfs_event_data *event_data;
352 struct service_processor *sp;
354 if (!inode->u.generic_ip)
357 sp = inode->u.generic_ip;
359 event_data = kmalloc(sizeof(struct ibmasmfs_event_data), GFP_KERNEL);
363 ibmasm_event_reader_register(sp, &event_data->reader);
366 event_data->active = 0;
367 file->private_data = event_data;
371 static int event_file_close(struct inode *inode, struct file *file)
373 struct ibmasmfs_event_data *event_data = file->private_data;
375 ibmasm_event_reader_unregister(event_data->sp, &event_data->reader);
380 static ssize_t event_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
382 struct ibmasmfs_event_data *event_data = file->private_data;
383 struct event_reader *reader = &event_data->reader;
384 struct service_processor *sp = event_data->sp;
390 if (count == 0 || count > IBMASM_EVENT_MAX_SIZE)
395 spin_lock_irqsave(&sp->lock, flags);
396 if (event_data->active) {
397 spin_unlock_irqrestore(&sp->lock, flags);
400 event_data->active = 1;
401 spin_unlock_irqrestore(&sp->lock, flags);
403 ret = ibmasm_get_next_event(sp, reader);
407 if (count < reader->data_size) {
412 if (copy_to_user(buf, reader->data, reader->data_size)) {
416 ret = reader->data_size;
419 event_data->active = 0;
423 static ssize_t event_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
425 struct ibmasmfs_event_data *event_data = file->private_data;
434 ibmasm_cancel_next_event(&event_data->reader);
438 static int r_heartbeat_file_open(struct inode *inode, struct file *file)
440 struct ibmasmfs_heartbeat_data *rhbeat;
442 if (!inode->u.generic_ip)
445 rhbeat = kmalloc(sizeof(struct ibmasmfs_heartbeat_data), GFP_KERNEL);
449 rhbeat->sp = (struct service_processor *)inode->u.generic_ip;
451 ibmasm_init_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
452 file->private_data = rhbeat;
456 static int r_heartbeat_file_close(struct inode *inode, struct file *file)
458 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
464 static ssize_t r_heartbeat_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
466 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
472 if (count == 0 || count > 1024)
477 /* allow only one reverse heartbeat per process */
478 spin_lock_irqsave(&rhbeat->sp->lock, flags);
479 if (rhbeat->active) {
480 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
484 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
486 result = ibmasm_start_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
492 static ssize_t r_heartbeat_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
494 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
504 ibmasm_stop_reverse_heartbeat(&rhbeat->heartbeat);
509 static int remote_settings_file_open(struct inode *inode, struct file *file)
511 file->private_data = inode->u.generic_ip;
515 static int remote_settings_file_close(struct inode *inode, struct file *file)
520 static ssize_t remote_settings_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
522 void __iomem *address = (void __iomem *)file->private_data;
530 if (count == 0 || count > 1024)
535 page = (unsigned char *)__get_free_page(GFP_KERNEL);
539 value = readl(address);
540 len = sprintf(page, "%d\n", value);
542 if (copy_to_user(buf, page, len)) {
550 free_page((unsigned long)page);
554 static ssize_t remote_settings_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
556 void __iomem *address = (void __iomem *)file->private_data;
562 if (count == 0 || count > 1024)
567 buff = kmalloc (count + 1, GFP_KERNEL);
571 memset(buff, 0x0, count + 1);
573 if (copy_from_user(buff, ubuff, count)) {
578 value = simple_strtoul(buff, NULL, 10);
579 writel(value, address);
585 static struct file_operations command_fops = {
586 .open = command_file_open,
587 .release = command_file_close,
588 .read = command_file_read,
589 .write = command_file_write,
592 static struct file_operations event_fops = {
593 .open = event_file_open,
594 .release = event_file_close,
595 .read = event_file_read,
596 .write = event_file_write,
599 static struct file_operations r_heartbeat_fops = {
600 .open = r_heartbeat_file_open,
601 .release = r_heartbeat_file_close,
602 .read = r_heartbeat_file_read,
603 .write = r_heartbeat_file_write,
606 static struct file_operations remote_settings_fops = {
607 .open = remote_settings_file_open,
608 .release = remote_settings_file_close,
609 .read = remote_settings_file_read,
610 .write = remote_settings_file_write,
614 static void ibmasmfs_create_files (struct super_block *sb, struct dentry *root)
616 struct list_head *entry;
617 struct service_processor *sp;
619 list_for_each(entry, &service_processors) {
621 struct dentry *remote_dir;
622 sp = list_entry(entry, struct service_processor, node);
623 dir = ibmasmfs_create_dir(sb, root, sp->dirname);
627 ibmasmfs_create_file(sb, dir, "command", &command_fops, sp, S_IRUSR|S_IWUSR);
628 ibmasmfs_create_file(sb, dir, "event", &event_fops, sp, S_IRUSR|S_IWUSR);
629 ibmasmfs_create_file(sb, dir, "reverse_heartbeat", &r_heartbeat_fops, sp, S_IRUSR|S_IWUSR);
631 remote_dir = ibmasmfs_create_dir(sb, dir, "remote_video");
635 ibmasmfs_create_file(sb, remote_dir, "width", &remote_settings_fops, (void *)display_width(sp), S_IRUSR|S_IWUSR);
636 ibmasmfs_create_file(sb, remote_dir, "height", &remote_settings_fops, (void *)display_height(sp), S_IRUSR|S_IWUSR);
637 ibmasmfs_create_file(sb, remote_dir, "depth", &remote_settings_fops, (void *)display_depth(sp), S_IRUSR|S_IWUSR);