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