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