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