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