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 87 static LIST_HEAD(service_processors); 88 89 static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode); 90 static void ibmasmfs_create_files (struct super_block *sb); 91 static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent); 92 93 94 static 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 100 static const struct super_operations ibmasmfs_s_ops = { 101 .statfs = simple_statfs, 102 .drop_inode = generic_delete_inode, 103 }; 104 105 static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations; 106 107 static 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 114 static 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 139 static 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 151 static 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 178 static 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 202 int ibmasmfs_register(void) 203 { 204 return register_filesystem(&ibmasmfs_type); 205 } 206 207 void ibmasmfs_unregister(void) 208 { 209 unregister_filesystem(&ibmasmfs_type); 210 } 211 212 void 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 */ 218 struct ibmasmfs_command_data { 219 struct service_processor *sp; 220 struct command *command; 221 }; 222 223 /* struct to save state between event file operations */ 224 struct 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 */ 231 struct ibmasmfs_heartbeat_data { 232 struct service_processor *sp; 233 struct reverse_heartbeat heartbeat; 234 int active; 235 }; 236 237 static 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 254 static 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 265 static 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 302 static 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 343 static 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 365 static 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 374 static 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 412 out: 413 event_data->active = 0; 414 return ret; 415 } 416 417 static 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 432 static 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 450 static 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 458 static 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 486 static 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 503 static int remote_settings_file_close(struct inode *inode, struct file *file) 504 { 505 return 0; 506 } 507 508 static 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 537 exit: 538 free_page((unsigned long)page); 539 return retval; 540 } 541 542 static 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 572 static 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 580 static 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 588 static 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 596 static 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 605 static 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 } 631