drivers/misc/ibmasm/ibmasmfs.c

   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 }