drivers/message/i2o/exec-osm.c

   1 /*
   2  *      Executive OSM
   3  *
   4  *      Copyright (C) 1999-2002 Red Hat Software
   5  *
   6  *      Written by Alan Cox, Building Number Three Ltd
   7  *
   8  *      This program is free software; you can redistribute it and/or modify it
   9  *      under the terms of the GNU General Public License as published by the
  10  *      Free Software Foundation; either version 2 of the License, or (at your
  11  *      option) any later version.
  12  *
  13  *      A lot of the I2O message side code from this is taken from the Red
  14  *      Creek RCPCI45 adapter driver by Red Creek Communications
  15  *
  16  *      Fixes/additions:
  17  *              Philipp Rumpf
  18  *              Juha Sievänen <Juha.Sievanen@cs.Helsinki.FI>
  19  *              Auvo Häkkinen <Auvo.Hakkinen@cs.Helsinki.FI>
  20  *              Deepak Saxena <deepak@plexity.net>
  21  *              Boji T Kannanthanam <boji.t.kannanthanam@intel.com>
  22  *              Alan Cox <alan@lxorguk.ukuu.org.uk>:
  23  *                      Ported to Linux 2.5.
  24  *              Markus Lidel <Markus.Lidel@shadowconnect.com>:
  25  *                      Minor fixes for 2.6.
  26  *              Markus Lidel <Markus.Lidel@shadowconnect.com>:
  27  *                      Support for sysfs included.
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/i2o.h>
  32 #include <linux/delay.h>
  33 #include <linux/workqueue.h>
  34 #include <linux/string.h>
  35 #include <linux/slab.h>
  36 #include <linux/sched.h>        /* wait_event_interruptible_timeout() needs this */
  37 #include <asm/param.h>          /* HZ */
  38 #include "core.h"
  39
  40 #define OSM_NAME "exec-osm"
  41
  42 struct i2o_driver i2o_exec_driver;
  43
  44 /* global wait list for POST WAIT */
  45 static LIST_HEAD(i2o_exec_wait_list);
  46
  47 /* Wait struct needed for POST WAIT */
  48 struct i2o_exec_wait {
  49         wait_queue_head_t *wq;  /* Pointer to Wait queue */
  50         struct i2o_dma dma;     /* DMA buffers to free on failure */
  51         u32 tcntxt;             /* transaction context from reply */
  52         int complete;           /* 1 if reply received otherwise 0 */
  53         u32 m;                  /* message id */
  54         struct i2o_message *msg;        /* pointer to the reply message */
  55         struct list_head list;  /* node in global wait list */
  56         spinlock_t lock;        /* lock before modifying */
  57 };
  58
  59 /* Work struct needed to handle LCT NOTIFY replies */
  60 struct i2o_exec_lct_notify_work {
  61         struct work_struct work;        /* work struct */
  62         struct i2o_controller *c;       /* controller on which the LCT NOTIFY
  63                                            was received */
  64 };
  65
  66 /* Exec OSM class handling definition */
  67 static struct i2o_class_id i2o_exec_class_id[] = {
  68         {I2O_CLASS_EXECUTIVE},
  69         {I2O_CLASS_END}
  70 };
  71
  72 /**
  73  *      i2o_exec_wait_alloc - Allocate a i2o_exec_wait struct an initialize it
  74  *
  75  *      Allocate the i2o_exec_wait struct and initialize the wait.
  76  *
  77  *      Returns i2o_exec_wait pointer on success or negative error code on
  78  *      failure.
  79  */
  80 static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
  81 {
  82         struct i2o_exec_wait *wait;
  83
  84         wait = kzalloc(sizeof(*wait), GFP_KERNEL);
  85         if (!wait)
  86                 return NULL;
  87
  88         INIT_LIST_HEAD(&wait->list);
  89         spin_lock_init(&wait->lock);
  90
  91         return wait;
  92 };
  93
  94 /**
  95  *      i2o_exec_wait_free - Free an i2o_exec_wait struct
  96  *      @wait: I2O wait data which should be cleaned up
  97  */
  98 static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
  99 {
 100         kfree(wait);
 101 };
 102
 103 /**
 104  *      i2o_msg_post_wait_mem - Post and wait a message with DMA buffers
 105  *      @c: controller
 106  *      @msg: message to post
 107  *      @timeout: time in seconds to wait
 108  *      @dma: i2o_dma struct of the DMA buffer to free on failure
 109  *
 110  *      This API allows an OSM to post a message and then be told whether or
 111  *      not the system received a successful reply. If the message times out
 112  *      then the value '-ETIMEDOUT' is returned. This is a special case. In
 113  *      this situation the message may (should) complete at an indefinite time
 114  *      in the future. When it completes it will use the memory buffer
 115  *      attached to the request. If -ETIMEDOUT is returned then the memory
 116  *      buffer must not be freed. Instead the event completion will free them
 117  *      for you. In all other cases the buffer are your problem.
 118  *
 119  *      Returns 0 on success, negative error code on timeout or positive error
 120  *      code from reply.
 121  */
 122 int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
 123                           unsigned long timeout, struct i2o_dma *dma)
 124 {
 125         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
 126         struct i2o_exec_wait *wait;
 127         static u32 tcntxt = 0x80000000;
 128         unsigned long flags;
 129         int rc = 0;
 130
 131         wait = i2o_exec_wait_alloc();
 132         if (!wait) {
 133                 i2o_msg_nop(c, msg);
 134                 return -ENOMEM;
 135         }
 136
 137         if (tcntxt == 0xffffffff)
 138                 tcntxt = 0x80000000;
 139
 140         if (dma)
 141                 wait->dma = *dma;
 142
 143         /*
 144          * Fill in the message initiator context and transaction context.
 145          * We will only use transaction contexts >= 0x80000000 for POST WAIT,
 146          * so we could find a POST WAIT reply easier in the reply handler.
 147          */
 148         msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
 149         wait->tcntxt = tcntxt++;
 150         msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);
 151
 152         wait->wq = &wq;
 153         /*
 154          * we add elements to the head, because if a entry in the list will
 155          * never be removed, we have to iterate over it every time
 156          */
 157         list_add(&wait->list, &i2o_exec_wait_list);
 158
 159         /*
 160          * Post the message to the controller. At some point later it will
 161          * return. If we time out before it returns then complete will be zero.
 162          */
 163         i2o_msg_post(c, msg);
 164
 165         wait_event_interruptible_timeout(wq, wait->complete, timeout * HZ);
 166
 167         spin_lock_irqsave(&wait->lock, flags);
 168
 169         wait->wq = NULL;
 170
 171         if (wait->complete)
 172                 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
 173         else {
 174                 /*
 175                  * We cannot remove it now. This is important. When it does
 176                  * terminate (which it must do if the controller has not
 177                  * died...) then it will otherwise scribble on stuff.
 178                  *
 179                  * FIXME: try abort message
 180                  */
 181                 if (dma)
 182                         dma->virt = NULL;
 183
 184                 rc = -ETIMEDOUT;
 185         }
 186
 187         spin_unlock_irqrestore(&wait->lock, flags);
 188
 189         if (rc != -ETIMEDOUT) {
 190                 i2o_flush_reply(c, wait->m);
 191                 i2o_exec_wait_free(wait);
 192         }
 193
 194         return rc;
 195 };
 196
 197 /**
 198  *      i2o_msg_post_wait_complete - Reply to a i2o_msg_post request from IOP
 199  *      @c: I2O controller which answers
 200  *      @m: message id
 201  *      @msg: pointer to the I2O reply message
 202  *      @context: transaction context of request
 203  *
 204  *      This function is called in interrupt context only. If the reply reached
 205  *      before the timeout, the i2o_exec_wait struct is filled with the message
 206  *      and the task will be waked up. The task is now responsible for returning
 207  *      the message m back to the controller! If the message reaches us after
 208  *      the timeout clean up the i2o_exec_wait struct (including allocated
 209  *      DMA buffer).
 210  *
 211  *      Return 0 on success and if the message m should not be given back to the
 212  *      I2O controller, or >0 on success and if the message should be given back
 213  *      afterwords. Returns negative error code on failure. In this case the
 214  *      message must also be given back to the controller.
 215  */
 216 static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
 217                                       struct i2o_message *msg, u32 context)
 218 {
 219         struct i2o_exec_wait *wait, *tmp;
 220         unsigned long flags;
 221         int rc = 1;
 222
 223         /*
 224          * We need to search through the i2o_exec_wait_list to see if the given
 225          * message is still outstanding. If not, it means that the IOP took
 226          * longer to respond to the message than we had allowed and timer has
 227          * already expired. Not much we can do about that except log it for
 228          * debug purposes, increase timeout, and recompile.
 229          */
 230         list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
 231                 if (wait->tcntxt == context) {
 232                         spin_lock_irqsave(&wait->lock, flags);
 233
 234                         list_del(&wait->list);
 235
 236                         wait->m = m;
 237                         wait->msg = msg;
 238                         wait->complete = 1;
 239
 240                         if (wait->wq)
 241                                 rc = 0;
 242                         else
 243                                 rc = -1;
 244
 245                         spin_unlock_irqrestore(&wait->lock, flags);
 246
 247                         if (rc) {
 248                                 struct device *dev;
 249
 250                                 dev = &c->pdev->dev;
 251
 252                                 pr_debug("%s: timedout reply received!\n",
 253                                          c->name);
 254                                 i2o_dma_free(dev, &wait->dma);
 255                                 i2o_exec_wait_free(wait);
 256                         } else
 257                                 wake_up_interruptible(wait->wq);
 258
 259                         return rc;
 260                 }
 261         }
 262
 263         osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
 264                  context);
 265
 266         return -1;
 267 };
 268
 269 /**
 270  *      i2o_exec_show_vendor_id - Displays Vendor ID of controller
 271  *      @d: device of which the Vendor ID should be displayed
 272  *      @attr: device_attribute to display
 273  *      @buf: buffer into which the Vendor ID should be printed
 274  *
 275  *      Returns number of bytes printed into buffer.
 276  */
 277 static ssize_t i2o_exec_show_vendor_id(struct device *d,
 278                                        struct device_attribute *attr, char *buf)
 279 {
 280         struct i2o_device *dev = to_i2o_device(d);
 281         u16 id;
 282
 283         if (!i2o_parm_field_get(dev, 0x0000, 0, &id, 2)) {
 284                 sprintf(buf, "0x%04x", le16_to_cpu(id));
 285                 return strlen(buf) + 1;
 286         }
 287
 288         return 0;
 289 };
 290
 291 /**
 292  *      i2o_exec_show_product_id - Displays Product ID of controller
 293  *      @d: device of which the Product ID should be displayed
 294  *      @attr: device_attribute to display
 295  *      @buf: buffer into which the Product ID should be printed
 296  *
 297  *      Returns number of bytes printed into buffer.
 298  */
 299 static ssize_t i2o_exec_show_product_id(struct device *d,
 300                                         struct device_attribute *attr,
 301                                         char *buf)
 302 {
 303         struct i2o_device *dev = to_i2o_device(d);
 304         u16 id;
 305
 306         if (!i2o_parm_field_get(dev, 0x0000, 1, &id, 2)) {
 307                 sprintf(buf, "0x%04x", le16_to_cpu(id));
 308                 return strlen(buf) + 1;
 309         }
 310
 311         return 0;
 312 };
 313
 314 /* Exec-OSM device attributes */
 315 static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL);
 316 static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
 317
 318 /**
 319  *      i2o_exec_probe - Called if a new I2O device (executive class) appears
 320  *      @dev: I2O device which should be probed
 321  *
 322  *      Registers event notification for every event from Executive device. The
 323  *      return is always 0, because we want all devices of class Executive.
 324  *
 325  *      Returns 0 on success.
 326  */
 327 static int i2o_exec_probe(struct device *dev)
 328 {
 329         struct i2o_device *i2o_dev = to_i2o_device(dev);
 330         int rc;
 331
 332         rc = i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
 333         if (rc) goto err_out;
 334
 335         rc = device_create_file(dev, &dev_attr_vendor_id);
 336         if (rc) goto err_evtreg;
 337         rc = device_create_file(dev, &dev_attr_product_id);
 338         if (rc) goto err_vid;
 339
 340         i2o_dev->iop->exec = i2o_dev;
 341
 342         return 0;
 343
 344 err_vid:
 345         device_remove_file(dev, &dev_attr_vendor_id);
 346 err_evtreg:
 347         i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
 348 err_out:
 349         return rc;
 350 };
 351
 352 /**
 353  *      i2o_exec_remove - Called on I2O device removal
 354  *      @dev: I2O device which was removed
 355  *
 356  *      Unregisters event notification from Executive I2O device.
 357  *
 358  *      Returns 0 on success.
 359  */
 360 static int i2o_exec_remove(struct device *dev)
 361 {
 362         device_remove_file(dev, &dev_attr_product_id);
 363         device_remove_file(dev, &dev_attr_vendor_id);
 364
 365         i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0);
 366
 367         return 0;
 368 };
 369
 370 #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
 371 /**
 372  *      i2o_exec_lct_notify - Send a asynchronus LCT NOTIFY request
 373  *      @c: I2O controller to which the request should be send
 374  *      @change_ind: change indicator
 375  *
 376  *      This function sends a LCT NOTIFY request to the I2O controller with
 377  *      the change indicator change_ind. If the change_ind == 0 the controller
 378  *      replies immediately after the request. If change_ind > 0 the reply is
 379  *      send after change indicator of the LCT is > change_ind.
 380  */
 381 static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
 382 {
 383         i2o_status_block *sb = c->status_block.virt;
 384         struct device *dev;
 385         struct i2o_message *msg;
 386
 387         mutex_lock(&c->lct_lock);
 388
 389         dev = &c->pdev->dev;
 390
 391         if (i2o_dma_realloc(dev, &c->dlct,
 392                                         le32_to_cpu(sb->expected_lct_size)))
 393                 return -ENOMEM;
 394
 395         msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 396         if (IS_ERR(msg))
 397                 return PTR_ERR(msg);
 398
 399         msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
 400         msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
 401                                      ADAPTER_TID);
 402         msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
 403         msg->u.s.tcntxt = cpu_to_le32(0x00000000);
 404         msg->body[0] = cpu_to_le32(0xffffffff);
 405         msg->body[1] = cpu_to_le32(change_ind);
 406         msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
 407         msg->body[3] = cpu_to_le32(c->dlct.phys);
 408
 409         i2o_msg_post(c, msg);
 410
 411         mutex_unlock(&c->lct_lock);
 412
 413         return 0;
 414 }
 415 #endif
 416
 417 /**
 418  *      i2o_exec_lct_modified - Called on LCT NOTIFY reply
 419  *      @_work: work struct for a specific controller
 420  *
 421  *      This function handles asynchronus LCT NOTIFY replies. It parses the
 422  *      new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY
 423  *      again, otherwise send LCT NOTIFY to get informed on next LCT change.
 424  */
 425 static void i2o_exec_lct_modified(struct work_struct *_work)
 426 {
 427         struct i2o_exec_lct_notify_work *work =
 428                 container_of(_work, struct i2o_exec_lct_notify_work, work);
 429         u32 change_ind = 0;
 430         struct i2o_controller *c = work->c;
 431
 432         kfree(work);
 433
 434         if (i2o_device_parse_lct(c) != -EAGAIN)
 435                 change_ind = c->lct->change_ind + 1;
 436
 437 #ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES
 438         i2o_exec_lct_notify(c, change_ind);
 439 #endif
 440 };
 441
 442 /**
 443  *      i2o_exec_reply -  I2O Executive reply handler
 444  *      @c: I2O controller from which the reply comes
 445  *      @m: message id
 446  *      @msg: pointer to the I2O reply message
 447  *
 448  *      This function is always called from interrupt context. If a POST WAIT
 449  *      reply was received, pass it to the complete function. If a LCT NOTIFY
 450  *      reply was received, a new event is created to handle the update.
 451  *
 452  *      Returns 0 on success and if the reply should not be flushed or > 0
 453  *      on success and if the reply should be flushed. Returns negative error
 454  *      code on failure and if the reply should be flushed.
 455  */
 456 static int i2o_exec_reply(struct i2o_controller *c, u32 m,
 457                           struct i2o_message *msg)
 458 {
 459         u32 context;
 460
 461         if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {
 462                 struct i2o_message __iomem *pmsg;
 463                 u32 pm;
 464
 465                 /*
 466                  * If Fail bit is set we must take the transaction context of
 467                  * the preserved message to find the right request again.
 468                  */
 469
 470                 pm = le32_to_cpu(msg->body[3]);
 471                 pmsg = i2o_msg_in_to_virt(c, pm);
 472                 context = readl(&pmsg->u.s.tcntxt);
 473
 474                 i2o_report_status(KERN_INFO, "i2o_core", msg);
 475
 476                 /* Release the preserved msg */
 477                 i2o_msg_nop_mfa(c, pm);
 478         } else
 479                 context = le32_to_cpu(msg->u.s.tcntxt);
 480
 481         if (context & 0x80000000)
 482                 return i2o_msg_post_wait_complete(c, m, msg, context);
 483
 484         if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
 485                 struct i2o_exec_lct_notify_work *work;
 486
 487                 pr_debug("%s: LCT notify received\n", c->name);
 488
 489                 work = kmalloc(sizeof(*work), GFP_ATOMIC);
 490                 if (!work)
 491                         return -ENOMEM;
 492
 493                 work->c = c;
 494
 495                 INIT_WORK(&work->work, i2o_exec_lct_modified);
 496                 queue_work(i2o_exec_driver.event_queue, &work->work);
 497                 return 1;
 498         }
 499
 500         /*
 501          * If this happens, we want to dump the message to the syslog so
 502          * it can be sent back to the card manufacturer by the end user
 503          * to aid in debugging.
 504          *
 505          */
 506         printk(KERN_WARNING "%s: Unsolicited message reply sent to core!"
 507                "Message dumped to syslog\n", c->name);
 508         i2o_dump_message(msg);
 509
 510         return -EFAULT;
 511 }
 512
 513 /**
 514  *      i2o_exec_event - Event handling function
 515  *      @work: Work item in occurring event
 516  *
 517  *      Handles events send by the Executive device. At the moment does not do
 518  *      anything useful.
 519  */
 520 static void i2o_exec_event(struct work_struct *work)
 521 {
 522         struct i2o_event *evt = container_of(work, struct i2o_event, work);
 523
 524         if (likely(evt->i2o_dev))
 525                 osm_debug("Event received from device: %d\n",
 526                           evt->i2o_dev->lct_data.tid);
 527         kfree(evt);
 528 };
 529
 530 /**
 531  *      i2o_exec_lct_get - Get the IOP's Logical Configuration Table
 532  *      @c: I2O controller from which the LCT should be fetched
 533  *
 534  *      Send a LCT NOTIFY request to the controller, and wait
 535  *      I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is
 536  *      to large, retry it.
 537  *
 538  *      Returns 0 on success or negative error code on failure.
 539  */
 540 int i2o_exec_lct_get(struct i2o_controller *c)
 541 {
 542         struct i2o_message *msg;
 543         int i = 0;
 544         int rc = -EAGAIN;
 545
 546         for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {
 547                 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 548                 if (IS_ERR(msg))
 549                         return PTR_ERR(msg);
 550
 551                 msg->u.head[0] =
 552                     cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
 553                 msg->u.head[1] =
 554                     cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |
 555                                 ADAPTER_TID);
 556                 msg->body[0] = cpu_to_le32(0xffffffff);
 557                 msg->body[1] = cpu_to_le32(0x00000000);
 558                 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);
 559                 msg->body[3] = cpu_to_le32(c->dlct.phys);
 560
 561                 rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);
 562                 if (rc < 0)
 563                         break;
 564
 565                 rc = i2o_device_parse_lct(c);
 566                 if (rc != -EAGAIN)
 567                         break;
 568         }
 569
 570         return rc;
 571 }
 572
 573 /* Exec OSM driver struct */
 574 struct i2o_driver i2o_exec_driver = {
 575         .name = OSM_NAME,
 576         .reply = i2o_exec_reply,
 577         .event = i2o_exec_event,
 578         .classes = i2o_exec_class_id,
 579         .driver = {
 580                    .probe = i2o_exec_probe,
 581                    .remove = i2o_exec_remove,
 582                    },
 583 };
 584
 585 /**
 586  *      i2o_exec_init - Registers the Exec OSM
 587  *
 588  *      Registers the Exec OSM in the I2O core.
 589  *
 590  *      Returns 0 on success or negative error code on failure.
 591  */
 592 int __init i2o_exec_init(void)
 593 {
 594         return i2o_driver_register(&i2o_exec_driver);
 595 };
 596
 597 /**
 598  *      i2o_exec_exit - Removes the Exec OSM
 599  *
 600  *      Unregisters the Exec OSM from the I2O core.
 601  */
 602 void i2o_exec_exit(void)
 603 {
 604         i2o_driver_unregister(&i2o_exec_driver);
 605 };
 606
 607 EXPORT_SYMBOL(i2o_msg_post_wait_mem);
 608 EXPORT_SYMBOL(i2o_exec_lct_get);