Loading...
1/*
2 * IBM ASM Service Processor Device Driver
3 *
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.
8 *
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.
13 *
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.
17 *
18 * Copyright (C) IBM Corporation, 2004
19 *
20 * Author: Max Asböck <amax@us.ibm.com>
21 *
22 */
23
24/*
25 * Parts of this code are based on an article by Jonathan Corbet
26 * that appeared in Linux Weekly News.
27 */
28
29
30/*
31 * The IBMASM file virtual filesystem. It creates the following hierarchy
32 * dynamically when mounted from user space:
33 *
34 * /ibmasm
35 * |-- 0
36 * | |-- command
37 * | |-- event
38 * | |-- reverse_heartbeat
39 * | `-- remote_video
40 * | |-- depth
41 * | |-- height
42 * | `-- width
43 * .
44 * .
45 * .
46 * `-- n
47 * |-- command
48 * |-- event
49 * |-- reverse_heartbeat
50 * `-- remote_video
51 * |-- depth
52 * |-- height
53 * `-- width
54 *
55 * For each service processor the following files are created:
56 *
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
60 *
61 * events: listen for service processor events
62 * read: sleep (interruptible) until an event occurs
63 * write: wakeup sleeping event listener
64 *
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
68 *
69 * remote_video/width
70 * remote_video/height
71 * remote_video/width: control remote display settings
72 * write: set value
73 * read: read value
74 */
75
76#include <linux/fs.h>
77#include <linux/pagemap.h>
78#include <linux/slab.h>
79#include <asm/uaccess.h>
80#include <asm/io.h>
81#include "ibmasm.h"
82#include "remote.h"
83#include "dot_command.h"
84
85#define IBMASMFS_MAGIC 0x66726f67
86
87static LIST_HEAD(service_processors);
88
89static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode);
90static void ibmasmfs_create_files (struct super_block *sb);
91static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent);
92
93
94static struct dentry *ibmasmfs_mount(struct file_system_type *fst,
95 int flags, const char *name, void *data)
96{
97 return mount_single(fst, flags, data, ibmasmfs_fill_super);
98}
99
100static const struct super_operations ibmasmfs_s_ops = {
101 .statfs = simple_statfs,
102 .drop_inode = generic_delete_inode,
103};
104
105static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
106
107static struct file_system_type ibmasmfs_type = {
108 .owner = THIS_MODULE,
109 .name = "ibmasmfs",
110 .mount = ibmasmfs_mount,
111 .kill_sb = kill_litter_super,
112};
113MODULE_ALIAS_FS("ibmasmfs");
114
115static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
116{
117 struct inode *root;
118
119 sb->s_blocksize = PAGE_SIZE;
120 sb->s_blocksize_bits = PAGE_SHIFT;
121 sb->s_magic = IBMASMFS_MAGIC;
122 sb->s_op = &ibmasmfs_s_ops;
123 sb->s_time_gran = 1;
124
125 root = ibmasmfs_make_inode (sb, S_IFDIR | 0500);
126 if (!root)
127 return -ENOMEM;
128
129 root->i_op = &simple_dir_inode_operations;
130 root->i_fop = ibmasmfs_dir_ops;
131
132 sb->s_root = d_make_root(root);
133 if (!sb->s_root)
134 return -ENOMEM;
135
136 ibmasmfs_create_files(sb);
137 return 0;
138}
139
140static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
141{
142 struct inode *ret = new_inode(sb);
143
144 if (ret) {
145 ret->i_ino = get_next_ino();
146 ret->i_mode = mode;
147 ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
148 }
149 return ret;
150}
151
152static struct dentry *ibmasmfs_create_file(struct dentry *parent,
153 const char *name,
154 const struct file_operations *fops,
155 void *data,
156 int mode)
157{
158 struct dentry *dentry;
159 struct inode *inode;
160
161 dentry = d_alloc_name(parent, name);
162 if (!dentry)
163 return NULL;
164
165 inode = ibmasmfs_make_inode(parent->d_sb, S_IFREG | mode);
166 if (!inode) {
167 dput(dentry);
168 return NULL;
169 }
170
171 inode->i_fop = fops;
172 inode->i_private = data;
173
174 d_add(dentry, inode);
175 return dentry;
176}
177
178static struct dentry *ibmasmfs_create_dir(struct dentry *parent,
179 const char *name)
180{
181 struct dentry *dentry;
182 struct inode *inode;
183
184 dentry = d_alloc_name(parent, name);
185 if (!dentry)
186 return NULL;
187
188 inode = ibmasmfs_make_inode(parent->d_sb, S_IFDIR | 0500);
189 if (!inode) {
190 dput(dentry);
191 return NULL;
192 }
193
194 inode->i_op = &simple_dir_inode_operations;
195 inode->i_fop = ibmasmfs_dir_ops;
196
197 d_add(dentry, inode);
198 return dentry;
199}
200
201int ibmasmfs_register(void)
202{
203 return register_filesystem(&ibmasmfs_type);
204}
205
206void ibmasmfs_unregister(void)
207{
208 unregister_filesystem(&ibmasmfs_type);
209}
210
211void ibmasmfs_add_sp(struct service_processor *sp)
212{
213 list_add(&sp->node, &service_processors);
214}
215
216/* struct to save state between command file operations */
217struct ibmasmfs_command_data {
218 struct service_processor *sp;
219 struct command *command;
220};
221
222/* struct to save state between event file operations */
223struct ibmasmfs_event_data {
224 struct service_processor *sp;
225 struct event_reader reader;
226 int active;
227};
228
229/* struct to save state between reverse heartbeat file operations */
230struct ibmasmfs_heartbeat_data {
231 struct service_processor *sp;
232 struct reverse_heartbeat heartbeat;
233 int active;
234};
235
236static int command_file_open(struct inode *inode, struct file *file)
237{
238 struct ibmasmfs_command_data *command_data;
239
240 if (!inode->i_private)
241 return -ENODEV;
242
243 command_data = kmalloc(sizeof(struct ibmasmfs_command_data), GFP_KERNEL);
244 if (!command_data)
245 return -ENOMEM;
246
247 command_data->command = NULL;
248 command_data->sp = inode->i_private;
249 file->private_data = command_data;
250 return 0;
251}
252
253static int command_file_close(struct inode *inode, struct file *file)
254{
255 struct ibmasmfs_command_data *command_data = file->private_data;
256
257 if (command_data->command)
258 command_put(command_data->command);
259
260 kfree(command_data);
261 return 0;
262}
263
264static ssize_t command_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
265{
266 struct ibmasmfs_command_data *command_data = file->private_data;
267 struct command *cmd;
268 int len;
269 unsigned long flags;
270
271 if (*offset < 0)
272 return -EINVAL;
273 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
274 return 0;
275 if (*offset != 0)
276 return 0;
277
278 spin_lock_irqsave(&command_data->sp->lock, flags);
279 cmd = command_data->command;
280 if (cmd == NULL) {
281 spin_unlock_irqrestore(&command_data->sp->lock, flags);
282 return 0;
283 }
284 command_data->command = NULL;
285 spin_unlock_irqrestore(&command_data->sp->lock, flags);
286
287 if (cmd->status != IBMASM_CMD_COMPLETE) {
288 command_put(cmd);
289 return -EIO;
290 }
291 len = min(count, cmd->buffer_size);
292 if (copy_to_user(buf, cmd->buffer, len)) {
293 command_put(cmd);
294 return -EFAULT;
295 }
296 command_put(cmd);
297
298 return len;
299}
300
301static ssize_t command_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
302{
303 struct ibmasmfs_command_data *command_data = file->private_data;
304 struct command *cmd;
305 unsigned long flags;
306
307 if (*offset < 0)
308 return -EINVAL;
309 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
310 return 0;
311 if (*offset != 0)
312 return 0;
313
314 /* commands are executed sequentially, only one command at a time */
315 if (command_data->command)
316 return -EAGAIN;
317
318 cmd = ibmasm_new_command(command_data->sp, count);
319 if (!cmd)
320 return -ENOMEM;
321
322 if (copy_from_user(cmd->buffer, ubuff, count)) {
323 command_put(cmd);
324 return -EFAULT;
325 }
326
327 spin_lock_irqsave(&command_data->sp->lock, flags);
328 if (command_data->command) {
329 spin_unlock_irqrestore(&command_data->sp->lock, flags);
330 command_put(cmd);
331 return -EAGAIN;
332 }
333 command_data->command = cmd;
334 spin_unlock_irqrestore(&command_data->sp->lock, flags);
335
336 ibmasm_exec_command(command_data->sp, cmd);
337 ibmasm_wait_for_response(cmd, get_dot_command_timeout(cmd->buffer));
338
339 return count;
340}
341
342static int event_file_open(struct inode *inode, struct file *file)
343{
344 struct ibmasmfs_event_data *event_data;
345 struct service_processor *sp;
346
347 if (!inode->i_private)
348 return -ENODEV;
349
350 sp = inode->i_private;
351
352 event_data = kmalloc(sizeof(struct ibmasmfs_event_data), GFP_KERNEL);
353 if (!event_data)
354 return -ENOMEM;
355
356 ibmasm_event_reader_register(sp, &event_data->reader);
357
358 event_data->sp = sp;
359 event_data->active = 0;
360 file->private_data = event_data;
361 return 0;
362}
363
364static int event_file_close(struct inode *inode, struct file *file)
365{
366 struct ibmasmfs_event_data *event_data = file->private_data;
367
368 ibmasm_event_reader_unregister(event_data->sp, &event_data->reader);
369 kfree(event_data);
370 return 0;
371}
372
373static ssize_t event_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
374{
375 struct ibmasmfs_event_data *event_data = file->private_data;
376 struct event_reader *reader = &event_data->reader;
377 struct service_processor *sp = event_data->sp;
378 int ret;
379 unsigned long flags;
380
381 if (*offset < 0)
382 return -EINVAL;
383 if (count == 0 || count > IBMASM_EVENT_MAX_SIZE)
384 return 0;
385 if (*offset != 0)
386 return 0;
387
388 spin_lock_irqsave(&sp->lock, flags);
389 if (event_data->active) {
390 spin_unlock_irqrestore(&sp->lock, flags);
391 return -EBUSY;
392 }
393 event_data->active = 1;
394 spin_unlock_irqrestore(&sp->lock, flags);
395
396 ret = ibmasm_get_next_event(sp, reader);
397 if (ret <= 0)
398 goto out;
399
400 if (count < reader->data_size) {
401 ret = -EINVAL;
402 goto out;
403 }
404
405 if (copy_to_user(buf, reader->data, reader->data_size)) {
406 ret = -EFAULT;
407 goto out;
408 }
409 ret = reader->data_size;
410
411out:
412 event_data->active = 0;
413 return ret;
414}
415
416static ssize_t event_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
417{
418 struct ibmasmfs_event_data *event_data = file->private_data;
419
420 if (*offset < 0)
421 return -EINVAL;
422 if (count != 1)
423 return 0;
424 if (*offset != 0)
425 return 0;
426
427 ibmasm_cancel_next_event(&event_data->reader);
428 return 0;
429}
430
431static int r_heartbeat_file_open(struct inode *inode, struct file *file)
432{
433 struct ibmasmfs_heartbeat_data *rhbeat;
434
435 if (!inode->i_private)
436 return -ENODEV;
437
438 rhbeat = kmalloc(sizeof(struct ibmasmfs_heartbeat_data), GFP_KERNEL);
439 if (!rhbeat)
440 return -ENOMEM;
441
442 rhbeat->sp = inode->i_private;
443 rhbeat->active = 0;
444 ibmasm_init_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
445 file->private_data = rhbeat;
446 return 0;
447}
448
449static int r_heartbeat_file_close(struct inode *inode, struct file *file)
450{
451 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
452
453 kfree(rhbeat);
454 return 0;
455}
456
457static ssize_t r_heartbeat_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
458{
459 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
460 unsigned long flags;
461 int result;
462
463 if (*offset < 0)
464 return -EINVAL;
465 if (count == 0 || count > 1024)
466 return 0;
467 if (*offset != 0)
468 return 0;
469
470 /* allow only one reverse heartbeat per process */
471 spin_lock_irqsave(&rhbeat->sp->lock, flags);
472 if (rhbeat->active) {
473 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
474 return -EBUSY;
475 }
476 rhbeat->active = 1;
477 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
478
479 result = ibmasm_start_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
480 rhbeat->active = 0;
481
482 return result;
483}
484
485static ssize_t r_heartbeat_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
486{
487 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
488
489 if (*offset < 0)
490 return -EINVAL;
491 if (count != 1)
492 return 0;
493 if (*offset != 0)
494 return 0;
495
496 if (rhbeat->active)
497 ibmasm_stop_reverse_heartbeat(&rhbeat->heartbeat);
498
499 return 1;
500}
501
502static int remote_settings_file_close(struct inode *inode, struct file *file)
503{
504 return 0;
505}
506
507static ssize_t remote_settings_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
508{
509 void __iomem *address = (void __iomem *)file->private_data;
510 unsigned char *page;
511 int retval;
512 int len = 0;
513 unsigned int value;
514
515 if (*offset < 0)
516 return -EINVAL;
517 if (count == 0 || count > 1024)
518 return 0;
519 if (*offset != 0)
520 return 0;
521
522 page = (unsigned char *)__get_free_page(GFP_KERNEL);
523 if (!page)
524 return -ENOMEM;
525
526 value = readl(address);
527 len = sprintf(page, "%d\n", value);
528
529 if (copy_to_user(buf, page, len)) {
530 retval = -EFAULT;
531 goto exit;
532 }
533 *offset += len;
534 retval = len;
535
536exit:
537 free_page((unsigned long)page);
538 return retval;
539}
540
541static ssize_t remote_settings_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
542{
543 void __iomem *address = (void __iomem *)file->private_data;
544 char *buff;
545 unsigned int value;
546
547 if (*offset < 0)
548 return -EINVAL;
549 if (count == 0 || count > 1024)
550 return 0;
551 if (*offset != 0)
552 return 0;
553
554 buff = kzalloc (count + 1, GFP_KERNEL);
555 if (!buff)
556 return -ENOMEM;
557
558
559 if (copy_from_user(buff, ubuff, count)) {
560 kfree(buff);
561 return -EFAULT;
562 }
563
564 value = simple_strtoul(buff, NULL, 10);
565 writel(value, address);
566 kfree(buff);
567
568 return count;
569}
570
571static const struct file_operations command_fops = {
572 .open = command_file_open,
573 .release = command_file_close,
574 .read = command_file_read,
575 .write = command_file_write,
576 .llseek = generic_file_llseek,
577};
578
579static const struct file_operations event_fops = {
580 .open = event_file_open,
581 .release = event_file_close,
582 .read = event_file_read,
583 .write = event_file_write,
584 .llseek = generic_file_llseek,
585};
586
587static const struct file_operations r_heartbeat_fops = {
588 .open = r_heartbeat_file_open,
589 .release = r_heartbeat_file_close,
590 .read = r_heartbeat_file_read,
591 .write = r_heartbeat_file_write,
592 .llseek = generic_file_llseek,
593};
594
595static const struct file_operations remote_settings_fops = {
596 .open = simple_open,
597 .release = remote_settings_file_close,
598 .read = remote_settings_file_read,
599 .write = remote_settings_file_write,
600 .llseek = generic_file_llseek,
601};
602
603
604static void ibmasmfs_create_files (struct super_block *sb)
605{
606 struct list_head *entry;
607 struct service_processor *sp;
608
609 list_for_each(entry, &service_processors) {
610 struct dentry *dir;
611 struct dentry *remote_dir;
612 sp = list_entry(entry, struct service_processor, node);
613 dir = ibmasmfs_create_dir(sb->s_root, sp->dirname);
614 if (!dir)
615 continue;
616
617 ibmasmfs_create_file(dir, "command", &command_fops, sp, S_IRUSR|S_IWUSR);
618 ibmasmfs_create_file(dir, "event", &event_fops, sp, S_IRUSR|S_IWUSR);
619 ibmasmfs_create_file(dir, "reverse_heartbeat", &r_heartbeat_fops, sp, S_IRUSR|S_IWUSR);
620
621 remote_dir = ibmasmfs_create_dir(dir, "remote_video");
622 if (!remote_dir)
623 continue;
624
625 ibmasmfs_create_file(remote_dir, "width", &remote_settings_fops, (void *)display_width(sp), S_IRUSR|S_IWUSR);
626 ibmasmfs_create_file(remote_dir, "height", &remote_settings_fops, (void *)display_height(sp), S_IRUSR|S_IWUSR);
627 ibmasmfs_create_file(remote_dir, "depth", &remote_settings_fops, (void *)display_depth(sp), S_IRUSR|S_IWUSR);
628 }
629}
1/*
2 * IBM ASM Service Processor Device Driver
3 *
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.
8 *
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.
13 *
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.
17 *
18 * Copyright (C) IBM Corporation, 2004
19 *
20 * Author: Max Asböck <amax@us.ibm.com>
21 *
22 */
23
24/*
25 * Parts of this code are based on an article by Jonathan Corbet
26 * that appeared in Linux Weekly News.
27 */
28
29
30/*
31 * The IBMASM file virtual filesystem. It creates the following hierarchy
32 * dynamically when mounted from user space:
33 *
34 * /ibmasm
35 * |-- 0
36 * | |-- command
37 * | |-- event
38 * | |-- reverse_heartbeat
39 * | `-- remote_video
40 * | |-- depth
41 * | |-- height
42 * | `-- width
43 * .
44 * .
45 * .
46 * `-- n
47 * |-- command
48 * |-- event
49 * |-- reverse_heartbeat
50 * `-- remote_video
51 * |-- depth
52 * |-- height
53 * `-- width
54 *
55 * For each service processor the following files are created:
56 *
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
60 *
61 * events: listen for service processor events
62 * read: sleep (interruptible) until an event occurs
63 * write: wakeup sleeping event listener
64 *
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
68 *
69 * remote_video/width
70 * remote_video/height
71 * remote_video/width: control remote display settings
72 * write: set value
73 * read: read value
74 */
75
76#include <linux/fs.h>
77#include <linux/pagemap.h>
78#include <linux/slab.h>
79#include <asm/uaccess.h>
80#include <asm/io.h>
81#include "ibmasm.h"
82#include "remote.h"
83#include "dot_command.h"
84
85#define IBMASMFS_MAGIC 0x66726f67
86
87static LIST_HEAD(service_processors);
88
89static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode);
90static void ibmasmfs_create_files (struct super_block *sb);
91static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent);
92
93
94static struct dentry *ibmasmfs_mount(struct file_system_type *fst,
95 int flags, const char *name, void *data)
96{
97 return mount_single(fst, flags, data, ibmasmfs_fill_super);
98}
99
100static const struct super_operations ibmasmfs_s_ops = {
101 .statfs = simple_statfs,
102 .drop_inode = generic_delete_inode,
103};
104
105static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
106
107static struct file_system_type ibmasmfs_type = {
108 .owner = THIS_MODULE,
109 .name = "ibmasmfs",
110 .mount = ibmasmfs_mount,
111 .kill_sb = kill_litter_super,
112};
113
114static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
115{
116 struct inode *root;
117
118 sb->s_blocksize = PAGE_CACHE_SIZE;
119 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
120 sb->s_magic = IBMASMFS_MAGIC;
121 sb->s_op = &ibmasmfs_s_ops;
122 sb->s_time_gran = 1;
123
124 root = ibmasmfs_make_inode (sb, S_IFDIR | 0500);
125 if (!root)
126 return -ENOMEM;
127
128 root->i_op = &simple_dir_inode_operations;
129 root->i_fop = ibmasmfs_dir_ops;
130
131 sb->s_root = d_make_root(root);
132 if (!sb->s_root)
133 return -ENOMEM;
134
135 ibmasmfs_create_files(sb);
136 return 0;
137}
138
139static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
140{
141 struct inode *ret = new_inode(sb);
142
143 if (ret) {
144 ret->i_ino = get_next_ino();
145 ret->i_mode = mode;
146 ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
147 }
148 return ret;
149}
150
151static struct dentry *ibmasmfs_create_file (struct super_block *sb,
152 struct dentry *parent,
153 const char *name,
154 const struct file_operations *fops,
155 void *data,
156 int mode)
157{
158 struct dentry *dentry;
159 struct inode *inode;
160
161 dentry = d_alloc_name(parent, name);
162 if (!dentry)
163 return NULL;
164
165 inode = ibmasmfs_make_inode(sb, S_IFREG | mode);
166 if (!inode) {
167 dput(dentry);
168 return NULL;
169 }
170
171 inode->i_fop = fops;
172 inode->i_private = data;
173
174 d_add(dentry, inode);
175 return dentry;
176}
177
178static struct dentry *ibmasmfs_create_dir (struct super_block *sb,
179 struct dentry *parent,
180 const char *name)
181{
182 struct dentry *dentry;
183 struct inode *inode;
184
185 dentry = d_alloc_name(parent, name);
186 if (!dentry)
187 return NULL;
188
189 inode = ibmasmfs_make_inode(sb, S_IFDIR | 0500);
190 if (!inode) {
191 dput(dentry);
192 return NULL;
193 }
194
195 inode->i_op = &simple_dir_inode_operations;
196 inode->i_fop = ibmasmfs_dir_ops;
197
198 d_add(dentry, inode);
199 return dentry;
200}
201
202int ibmasmfs_register(void)
203{
204 return register_filesystem(&ibmasmfs_type);
205}
206
207void ibmasmfs_unregister(void)
208{
209 unregister_filesystem(&ibmasmfs_type);
210}
211
212void ibmasmfs_add_sp(struct service_processor *sp)
213{
214 list_add(&sp->node, &service_processors);
215}
216
217/* struct to save state between command file operations */
218struct ibmasmfs_command_data {
219 struct service_processor *sp;
220 struct command *command;
221};
222
223/* struct to save state between event file operations */
224struct ibmasmfs_event_data {
225 struct service_processor *sp;
226 struct event_reader reader;
227 int active;
228};
229
230/* struct to save state between reverse heartbeat file operations */
231struct ibmasmfs_heartbeat_data {
232 struct service_processor *sp;
233 struct reverse_heartbeat heartbeat;
234 int active;
235};
236
237static int command_file_open(struct inode *inode, struct file *file)
238{
239 struct ibmasmfs_command_data *command_data;
240
241 if (!inode->i_private)
242 return -ENODEV;
243
244 command_data = kmalloc(sizeof(struct ibmasmfs_command_data), GFP_KERNEL);
245 if (!command_data)
246 return -ENOMEM;
247
248 command_data->command = NULL;
249 command_data->sp = inode->i_private;
250 file->private_data = command_data;
251 return 0;
252}
253
254static int command_file_close(struct inode *inode, struct file *file)
255{
256 struct ibmasmfs_command_data *command_data = file->private_data;
257
258 if (command_data->command)
259 command_put(command_data->command);
260
261 kfree(command_data);
262 return 0;
263}
264
265static ssize_t command_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
266{
267 struct ibmasmfs_command_data *command_data = file->private_data;
268 struct command *cmd;
269 int len;
270 unsigned long flags;
271
272 if (*offset < 0)
273 return -EINVAL;
274 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
275 return 0;
276 if (*offset != 0)
277 return 0;
278
279 spin_lock_irqsave(&command_data->sp->lock, flags);
280 cmd = command_data->command;
281 if (cmd == NULL) {
282 spin_unlock_irqrestore(&command_data->sp->lock, flags);
283 return 0;
284 }
285 command_data->command = NULL;
286 spin_unlock_irqrestore(&command_data->sp->lock, flags);
287
288 if (cmd->status != IBMASM_CMD_COMPLETE) {
289 command_put(cmd);
290 return -EIO;
291 }
292 len = min(count, cmd->buffer_size);
293 if (copy_to_user(buf, cmd->buffer, len)) {
294 command_put(cmd);
295 return -EFAULT;
296 }
297 command_put(cmd);
298
299 return len;
300}
301
302static ssize_t command_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
303{
304 struct ibmasmfs_command_data *command_data = file->private_data;
305 struct command *cmd;
306 unsigned long flags;
307
308 if (*offset < 0)
309 return -EINVAL;
310 if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
311 return 0;
312 if (*offset != 0)
313 return 0;
314
315 /* commands are executed sequentially, only one command at a time */
316 if (command_data->command)
317 return -EAGAIN;
318
319 cmd = ibmasm_new_command(command_data->sp, count);
320 if (!cmd)
321 return -ENOMEM;
322
323 if (copy_from_user(cmd->buffer, ubuff, count)) {
324 command_put(cmd);
325 return -EFAULT;
326 }
327
328 spin_lock_irqsave(&command_data->sp->lock, flags);
329 if (command_data->command) {
330 spin_unlock_irqrestore(&command_data->sp->lock, flags);
331 command_put(cmd);
332 return -EAGAIN;
333 }
334 command_data->command = cmd;
335 spin_unlock_irqrestore(&command_data->sp->lock, flags);
336
337 ibmasm_exec_command(command_data->sp, cmd);
338 ibmasm_wait_for_response(cmd, get_dot_command_timeout(cmd->buffer));
339
340 return count;
341}
342
343static int event_file_open(struct inode *inode, struct file *file)
344{
345 struct ibmasmfs_event_data *event_data;
346 struct service_processor *sp;
347
348 if (!inode->i_private)
349 return -ENODEV;
350
351 sp = inode->i_private;
352
353 event_data = kmalloc(sizeof(struct ibmasmfs_event_data), GFP_KERNEL);
354 if (!event_data)
355 return -ENOMEM;
356
357 ibmasm_event_reader_register(sp, &event_data->reader);
358
359 event_data->sp = sp;
360 event_data->active = 0;
361 file->private_data = event_data;
362 return 0;
363}
364
365static int event_file_close(struct inode *inode, struct file *file)
366{
367 struct ibmasmfs_event_data *event_data = file->private_data;
368
369 ibmasm_event_reader_unregister(event_data->sp, &event_data->reader);
370 kfree(event_data);
371 return 0;
372}
373
374static ssize_t event_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
375{
376 struct ibmasmfs_event_data *event_data = file->private_data;
377 struct event_reader *reader = &event_data->reader;
378 struct service_processor *sp = event_data->sp;
379 int ret;
380 unsigned long flags;
381
382 if (*offset < 0)
383 return -EINVAL;
384 if (count == 0 || count > IBMASM_EVENT_MAX_SIZE)
385 return 0;
386 if (*offset != 0)
387 return 0;
388
389 spin_lock_irqsave(&sp->lock, flags);
390 if (event_data->active) {
391 spin_unlock_irqrestore(&sp->lock, flags);
392 return -EBUSY;
393 }
394 event_data->active = 1;
395 spin_unlock_irqrestore(&sp->lock, flags);
396
397 ret = ibmasm_get_next_event(sp, reader);
398 if (ret <= 0)
399 goto out;
400
401 if (count < reader->data_size) {
402 ret = -EINVAL;
403 goto out;
404 }
405
406 if (copy_to_user(buf, reader->data, reader->data_size)) {
407 ret = -EFAULT;
408 goto out;
409 }
410 ret = reader->data_size;
411
412out:
413 event_data->active = 0;
414 return ret;
415}
416
417static ssize_t event_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
418{
419 struct ibmasmfs_event_data *event_data = file->private_data;
420
421 if (*offset < 0)
422 return -EINVAL;
423 if (count != 1)
424 return 0;
425 if (*offset != 0)
426 return 0;
427
428 ibmasm_cancel_next_event(&event_data->reader);
429 return 0;
430}
431
432static int r_heartbeat_file_open(struct inode *inode, struct file *file)
433{
434 struct ibmasmfs_heartbeat_data *rhbeat;
435
436 if (!inode->i_private)
437 return -ENODEV;
438
439 rhbeat = kmalloc(sizeof(struct ibmasmfs_heartbeat_data), GFP_KERNEL);
440 if (!rhbeat)
441 return -ENOMEM;
442
443 rhbeat->sp = inode->i_private;
444 rhbeat->active = 0;
445 ibmasm_init_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
446 file->private_data = rhbeat;
447 return 0;
448}
449
450static int r_heartbeat_file_close(struct inode *inode, struct file *file)
451{
452 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
453
454 kfree(rhbeat);
455 return 0;
456}
457
458static ssize_t r_heartbeat_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
459{
460 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
461 unsigned long flags;
462 int result;
463
464 if (*offset < 0)
465 return -EINVAL;
466 if (count == 0 || count > 1024)
467 return 0;
468 if (*offset != 0)
469 return 0;
470
471 /* allow only one reverse heartbeat per process */
472 spin_lock_irqsave(&rhbeat->sp->lock, flags);
473 if (rhbeat->active) {
474 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
475 return -EBUSY;
476 }
477 rhbeat->active = 1;
478 spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
479
480 result = ibmasm_start_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
481 rhbeat->active = 0;
482
483 return result;
484}
485
486static ssize_t r_heartbeat_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
487{
488 struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
489
490 if (*offset < 0)
491 return -EINVAL;
492 if (count != 1)
493 return 0;
494 if (*offset != 0)
495 return 0;
496
497 if (rhbeat->active)
498 ibmasm_stop_reverse_heartbeat(&rhbeat->heartbeat);
499
500 return 1;
501}
502
503static int remote_settings_file_close(struct inode *inode, struct file *file)
504{
505 return 0;
506}
507
508static ssize_t remote_settings_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
509{
510 void __iomem *address = (void __iomem *)file->private_data;
511 unsigned char *page;
512 int retval;
513 int len = 0;
514 unsigned int value;
515
516 if (*offset < 0)
517 return -EINVAL;
518 if (count == 0 || count > 1024)
519 return 0;
520 if (*offset != 0)
521 return 0;
522
523 page = (unsigned char *)__get_free_page(GFP_KERNEL);
524 if (!page)
525 return -ENOMEM;
526
527 value = readl(address);
528 len = sprintf(page, "%d\n", value);
529
530 if (copy_to_user(buf, page, len)) {
531 retval = -EFAULT;
532 goto exit;
533 }
534 *offset += len;
535 retval = len;
536
537exit:
538 free_page((unsigned long)page);
539 return retval;
540}
541
542static ssize_t remote_settings_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
543{
544 void __iomem *address = (void __iomem *)file->private_data;
545 char *buff;
546 unsigned int value;
547
548 if (*offset < 0)
549 return -EINVAL;
550 if (count == 0 || count > 1024)
551 return 0;
552 if (*offset != 0)
553 return 0;
554
555 buff = kzalloc (count + 1, GFP_KERNEL);
556 if (!buff)
557 return -ENOMEM;
558
559
560 if (copy_from_user(buff, ubuff, count)) {
561 kfree(buff);
562 return -EFAULT;
563 }
564
565 value = simple_strtoul(buff, NULL, 10);
566 writel(value, address);
567 kfree(buff);
568
569 return count;
570}
571
572static const struct file_operations command_fops = {
573 .open = command_file_open,
574 .release = command_file_close,
575 .read = command_file_read,
576 .write = command_file_write,
577 .llseek = generic_file_llseek,
578};
579
580static const struct file_operations event_fops = {
581 .open = event_file_open,
582 .release = event_file_close,
583 .read = event_file_read,
584 .write = event_file_write,
585 .llseek = generic_file_llseek,
586};
587
588static const struct file_operations r_heartbeat_fops = {
589 .open = r_heartbeat_file_open,
590 .release = r_heartbeat_file_close,
591 .read = r_heartbeat_file_read,
592 .write = r_heartbeat_file_write,
593 .llseek = generic_file_llseek,
594};
595
596static const struct file_operations remote_settings_fops = {
597 .open = simple_open,
598 .release = remote_settings_file_close,
599 .read = remote_settings_file_read,
600 .write = remote_settings_file_write,
601 .llseek = generic_file_llseek,
602};
603
604
605static void ibmasmfs_create_files (struct super_block *sb)
606{
607 struct list_head *entry;
608 struct service_processor *sp;
609
610 list_for_each(entry, &service_processors) {
611 struct dentry *dir;
612 struct dentry *remote_dir;
613 sp = list_entry(entry, struct service_processor, node);
614 dir = ibmasmfs_create_dir(sb, sb->s_root, sp->dirname);
615 if (!dir)
616 continue;
617
618 ibmasmfs_create_file(sb, dir, "command", &command_fops, sp, S_IRUSR|S_IWUSR);
619 ibmasmfs_create_file(sb, dir, "event", &event_fops, sp, S_IRUSR|S_IWUSR);
620 ibmasmfs_create_file(sb, dir, "reverse_heartbeat", &r_heartbeat_fops, sp, S_IRUSR|S_IWUSR);
621
622 remote_dir = ibmasmfs_create_dir(sb, dir, "remote_video");
623 if (!remote_dir)
624 continue;
625
626 ibmasmfs_create_file(sb, remote_dir, "width", &remote_settings_fops, (void *)display_width(sp), S_IRUSR|S_IWUSR);
627 ibmasmfs_create_file(sb, remote_dir, "height", &remote_settings_fops, (void *)display_height(sp), S_IRUSR|S_IWUSR);
628 ibmasmfs_create_file(sb, remote_dir, "depth", &remote_settings_fops, (void *)display_depth(sp), S_IRUSR|S_IWUSR);
629 }
630}