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