Linux Audio

Check our new training course

Loading...
v4.6
  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}
v3.1
  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, struct dentry *root);
 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	struct dentry *root_dentry;
118
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;
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	root_dentry = d_alloc_root(root);
133	if (!root_dentry) {
134		iput(root);
135		return -ENOMEM;
136	}
137	sb->s_root = root_dentry;
138
139	ibmasmfs_create_files(sb, root_dentry);
140	return 0;
141}
142
143static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
144{
145	struct inode *ret = new_inode(sb);
146
147	if (ret) {
148		ret->i_ino = get_next_ino();
149		ret->i_mode = mode;
150		ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
151	}
152	return ret;
153}
154
155static struct dentry *ibmasmfs_create_file (struct super_block *sb,
156			struct dentry *parent,
157			const char *name,
158			const struct file_operations *fops,
159			void *data,
160			int mode)
161{
162	struct dentry *dentry;
163	struct inode *inode;
164
165	dentry = d_alloc_name(parent, name);
166	if (!dentry)
167		return NULL;
168
169	inode = ibmasmfs_make_inode(sb, S_IFREG | mode);
170	if (!inode) {
171		dput(dentry);
172		return NULL;
173	}
174
175	inode->i_fop = fops;
176	inode->i_private = data;
177
178	d_add(dentry, inode);
179	return dentry;
180}
181
182static struct dentry *ibmasmfs_create_dir (struct super_block *sb,
183				struct dentry *parent,
184				const char *name)
185{
186	struct dentry *dentry;
187	struct inode *inode;
188
189	dentry = d_alloc_name(parent, name);
190	if (!dentry)
191		return NULL;
192
193	inode = ibmasmfs_make_inode(sb, S_IFDIR | 0500);
194	if (!inode) {
195		dput(dentry);
196		return NULL;
197	}
198
199	inode->i_op = &simple_dir_inode_operations;
200	inode->i_fop = ibmasmfs_dir_ops;
201
202	d_add(dentry, inode);
203	return dentry;
204}
205
206int ibmasmfs_register(void)
207{
208	return register_filesystem(&ibmasmfs_type);
209}
210
211void ibmasmfs_unregister(void)
212{
213	unregister_filesystem(&ibmasmfs_type);
214}
215
216void ibmasmfs_add_sp(struct service_processor *sp)
217{
218	list_add(&sp->node, &service_processors);
219}
220
221/* struct to save state between command file operations */
222struct ibmasmfs_command_data {
223	struct service_processor	*sp;
224	struct command			*command;
225};
226
227/* struct to save state between event file operations */
228struct ibmasmfs_event_data {
229	struct service_processor	*sp;
230	struct event_reader		reader;
231	int				active;
232};
233
234/* struct to save state between reverse heartbeat file operations */
235struct ibmasmfs_heartbeat_data {
236	struct service_processor	*sp;
237	struct reverse_heartbeat	heartbeat;
238	int				active;
239};
240
241static int command_file_open(struct inode *inode, struct file *file)
242{
243	struct ibmasmfs_command_data *command_data;
244
245	if (!inode->i_private)
246		return -ENODEV;
247
248	command_data = kmalloc(sizeof(struct ibmasmfs_command_data), GFP_KERNEL);
249	if (!command_data)
250		return -ENOMEM;
251
252	command_data->command = NULL;
253	command_data->sp = inode->i_private;
254	file->private_data = command_data;
255	return 0;
256}
257
258static int command_file_close(struct inode *inode, struct file *file)
259{
260	struct ibmasmfs_command_data *command_data = file->private_data;
261
262	if (command_data->command)
263		command_put(command_data->command);
264
265	kfree(command_data);
266	return 0;
267}
268
269static ssize_t command_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
270{
271	struct ibmasmfs_command_data *command_data = file->private_data;
272	struct command *cmd;
273	int len;
274	unsigned long flags;
275
276	if (*offset < 0)
277		return -EINVAL;
278	if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
279		return 0;
280	if (*offset != 0)
281		return 0;
282
283	spin_lock_irqsave(&command_data->sp->lock, flags);
284	cmd = command_data->command;
285	if (cmd == NULL) {
286		spin_unlock_irqrestore(&command_data->sp->lock, flags);
287		return 0;
288	}
289	command_data->command = NULL;
290	spin_unlock_irqrestore(&command_data->sp->lock, flags);
291
292	if (cmd->status != IBMASM_CMD_COMPLETE) {
293		command_put(cmd);
294		return -EIO;
295	}
296	len = min(count, cmd->buffer_size);
297	if (copy_to_user(buf, cmd->buffer, len)) {
298		command_put(cmd);
299		return -EFAULT;
300	}
301	command_put(cmd);
302
303	return len;
304}
305
306static ssize_t command_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
307{
308	struct ibmasmfs_command_data *command_data = file->private_data;
309	struct command *cmd;
310	unsigned long flags;
311
312	if (*offset < 0)
313		return -EINVAL;
314	if (count == 0 || count > IBMASM_CMD_MAX_BUFFER_SIZE)
315		return 0;
316	if (*offset != 0)
317		return 0;
318
319	/* commands are executed sequentially, only one command at a time */
320	if (command_data->command)
321		return -EAGAIN;
322
323	cmd = ibmasm_new_command(command_data->sp, count);
324	if (!cmd)
325		return -ENOMEM;
326
327	if (copy_from_user(cmd->buffer, ubuff, count)) {
328		command_put(cmd);
329		return -EFAULT;
330	}
331
332	spin_lock_irqsave(&command_data->sp->lock, flags);
333	if (command_data->command) {
334		spin_unlock_irqrestore(&command_data->sp->lock, flags);
335		command_put(cmd);
336		return -EAGAIN;
337	}
338	command_data->command = cmd;
339	spin_unlock_irqrestore(&command_data->sp->lock, flags);
340
341	ibmasm_exec_command(command_data->sp, cmd);
342	ibmasm_wait_for_response(cmd, get_dot_command_timeout(cmd->buffer));
343
344	return count;
345}
346
347static int event_file_open(struct inode *inode, struct file *file)
348{
349	struct ibmasmfs_event_data *event_data;
350	struct service_processor *sp;
351
352	if (!inode->i_private)
353		return -ENODEV;
354
355	sp = inode->i_private;
356
357	event_data = kmalloc(sizeof(struct ibmasmfs_event_data), GFP_KERNEL);
358	if (!event_data)
359		return -ENOMEM;
360
361	ibmasm_event_reader_register(sp, &event_data->reader);
362
363	event_data->sp = sp;
364	event_data->active = 0;
365	file->private_data = event_data;
366	return 0;
367}
368
369static int event_file_close(struct inode *inode, struct file *file)
370{
371	struct ibmasmfs_event_data *event_data = file->private_data;
372
373	ibmasm_event_reader_unregister(event_data->sp, &event_data->reader);
374	kfree(event_data);
375	return 0;
376}
377
378static ssize_t event_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
379{
380	struct ibmasmfs_event_data *event_data = file->private_data;
381	struct event_reader *reader = &event_data->reader;
382	struct service_processor *sp = event_data->sp;
383	int ret;
384	unsigned long flags;
385
386	if (*offset < 0)
387		return -EINVAL;
388	if (count == 0 || count > IBMASM_EVENT_MAX_SIZE)
389		return 0;
390	if (*offset != 0)
391		return 0;
392
393	spin_lock_irqsave(&sp->lock, flags);
394	if (event_data->active) {
395		spin_unlock_irqrestore(&sp->lock, flags);
396		return -EBUSY;
397	}
398	event_data->active = 1;
399	spin_unlock_irqrestore(&sp->lock, flags);
400
401	ret = ibmasm_get_next_event(sp, reader);
402	if (ret <= 0)
403		goto out;
404
405	if (count < reader->data_size) {
406		ret = -EINVAL;
407		goto out;
408	}
409
410        if (copy_to_user(buf, reader->data, reader->data_size)) {
411		ret = -EFAULT;
412		goto out;
413	}
414	ret = reader->data_size;
415
416out:
417	event_data->active = 0;
418	return ret;
419}
420
421static ssize_t event_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
422{
423	struct ibmasmfs_event_data *event_data = file->private_data;
424
425	if (*offset < 0)
426		return -EINVAL;
427	if (count != 1)
428		return 0;
429	if (*offset != 0)
430		return 0;
431
432	ibmasm_cancel_next_event(&event_data->reader);
433	return 0;
434}
435
436static int r_heartbeat_file_open(struct inode *inode, struct file *file)
437{
438	struct ibmasmfs_heartbeat_data *rhbeat;
439
440	if (!inode->i_private)
441		return -ENODEV;
442
443	rhbeat = kmalloc(sizeof(struct ibmasmfs_heartbeat_data), GFP_KERNEL);
444	if (!rhbeat)
445		return -ENOMEM;
446
447	rhbeat->sp = inode->i_private;
448	rhbeat->active = 0;
449	ibmasm_init_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
450	file->private_data = rhbeat;
451	return 0;
452}
453
454static int r_heartbeat_file_close(struct inode *inode, struct file *file)
455{
456	struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
457
458	kfree(rhbeat);
459	return 0;
460}
461
462static ssize_t r_heartbeat_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
463{
464	struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
465	unsigned long flags;
466	int result;
467
468	if (*offset < 0)
469		return -EINVAL;
470	if (count == 0 || count > 1024)
471		return 0;
472	if (*offset != 0)
473		return 0;
474
475	/* allow only one reverse heartbeat per process */
476	spin_lock_irqsave(&rhbeat->sp->lock, flags);
477	if (rhbeat->active) {
478		spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
479		return -EBUSY;
480	}
481	rhbeat->active = 1;
482	spin_unlock_irqrestore(&rhbeat->sp->lock, flags);
483
484	result = ibmasm_start_reverse_heartbeat(rhbeat->sp, &rhbeat->heartbeat);
485	rhbeat->active = 0;
486
487	return result;
488}
489
490static ssize_t r_heartbeat_file_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
491{
492	struct ibmasmfs_heartbeat_data *rhbeat = file->private_data;
493
494	if (*offset < 0)
495		return -EINVAL;
496	if (count != 1)
497		return 0;
498	if (*offset != 0)
499		return 0;
500
501	if (rhbeat->active)
502		ibmasm_stop_reverse_heartbeat(&rhbeat->heartbeat);
503
504	return 1;
505}
506
507static int remote_settings_file_open(struct inode *inode, struct file *file)
508{
509	file->private_data = inode->i_private;
510	return 0;
511}
512
513static int remote_settings_file_close(struct inode *inode, struct file *file)
514{
515	return 0;
516}
517
518static ssize_t remote_settings_file_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
519{
520	void __iomem *address = (void __iomem *)file->private_data;
521	unsigned char *page;
522	int retval;
523	int len = 0;
524	unsigned int value;
525
526	if (*offset < 0)
527		return -EINVAL;
528	if (count == 0 || count > 1024)
529		return 0;
530	if (*offset != 0)
531		return 0;
532
533	page = (unsigned char *)__get_free_page(GFP_KERNEL);
534	if (!page)
535		return -ENOMEM;
536
537	value = readl(address);
538	len = sprintf(page, "%d\n", value);
539
540	if (copy_to_user(buf, page, len)) {
541		retval = -EFAULT;
542		goto exit;
543	}
544	*offset += len;
545	retval = len;
546
547exit:
548	free_page((unsigned long)page);
549	return retval;
550}
551
552static ssize_t remote_settings_file_write(struct file *file, const char __user *ubuff, size_t count, loff_t *offset)
553{
554	void __iomem *address = (void __iomem *)file->private_data;
555	char *buff;
556	unsigned int value;
557
558	if (*offset < 0)
559		return -EINVAL;
560	if (count == 0 || count > 1024)
561		return 0;
562	if (*offset != 0)
563		return 0;
564
565	buff = kzalloc (count + 1, GFP_KERNEL);
566	if (!buff)
567		return -ENOMEM;
568
569
570	if (copy_from_user(buff, ubuff, count)) {
571		kfree(buff);
572		return -EFAULT;
573	}
574
575	value = simple_strtoul(buff, NULL, 10);
576	writel(value, address);
577	kfree(buff);
578
579	return count;
580}
581
582static const struct file_operations command_fops = {
583	.open =		command_file_open,
584	.release =	command_file_close,
585	.read =		command_file_read,
586	.write =	command_file_write,
587	.llseek =	generic_file_llseek,
588};
589
590static const struct file_operations event_fops = {
591	.open =		event_file_open,
592	.release =	event_file_close,
593	.read =		event_file_read,
594	.write =	event_file_write,
595	.llseek =	generic_file_llseek,
596};
597
598static const struct file_operations r_heartbeat_fops = {
599	.open =		r_heartbeat_file_open,
600	.release =	r_heartbeat_file_close,
601	.read =		r_heartbeat_file_read,
602	.write =	r_heartbeat_file_write,
603	.llseek =	generic_file_llseek,
604};
605
606static const 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,
611	.llseek =	generic_file_llseek,
612};
613
614
615static void ibmasmfs_create_files (struct super_block *sb, struct dentry *root)
616{
617	struct list_head *entry;
618	struct service_processor *sp;
619
620	list_for_each(entry, &service_processors) {
621		struct dentry *dir;
622		struct dentry *remote_dir;
623		sp = list_entry(entry, struct service_processor, node);
624		dir = ibmasmfs_create_dir(sb, root, sp->dirname);
625		if (!dir)
626			continue;
627
628		ibmasmfs_create_file(sb, dir, "command", &command_fops, sp, S_IRUSR|S_IWUSR);
629		ibmasmfs_create_file(sb, dir, "event", &event_fops, sp, S_IRUSR|S_IWUSR);
630		ibmasmfs_create_file(sb, dir, "reverse_heartbeat", &r_heartbeat_fops, sp, S_IRUSR|S_IWUSR);
631
632		remote_dir = ibmasmfs_create_dir(sb, dir, "remote_video");
633		if (!remote_dir)
634			continue;
635
636		ibmasmfs_create_file(sb, remote_dir, "width", &remote_settings_fops, (void *)display_width(sp), S_IRUSR|S_IWUSR);
637		ibmasmfs_create_file(sb, remote_dir, "height", &remote_settings_fops, (void *)display_height(sp), S_IRUSR|S_IWUSR);
638		ibmasmfs_create_file(sb, remote_dir, "depth", &remote_settings_fops, (void *)display_depth(sp), S_IRUSR|S_IWUSR);
639	}
640}