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