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