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 "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 42struct i2o_driver i2o_exec_driver; 43 44/* global wait list for POST WAIT */ 45static LIST_HEAD(i2o_exec_wait_list); 46 47/* Wait struct needed for POST WAIT */ 48struct 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 */ 60struct 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 */ 67static 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 */ 80static 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 */ 98static 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 */ 122int 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 */ 216static 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 */ 277static 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 */ 299static 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 */ 315static DEVICE_ATTR(vendor_id, S_IRUGO, i2o_exec_show_vendor_id, NULL); 316static 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 */ 327static 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 344err_vid: 345 device_remove_file(dev, &dev_attr_vendor_id); 346err_evtreg: 347 i2o_event_register(to_i2o_device(dev), &i2o_exec_driver, 0, 0); 348err_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 */ 360static 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 */ 381static 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 mutex_unlock(&c->lct_lock); 394 return -ENOMEM; 395 } 396 397 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET); 398 if (IS_ERR(msg)) { 399 mutex_unlock(&c->lct_lock); 400 return PTR_ERR(msg); 401 } 402 403 msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6); 404 msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | 405 ADAPTER_TID); 406 msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context); 407 msg->u.s.tcntxt = cpu_to_le32(0x00000000); 408 msg->body[0] = cpu_to_le32(0xffffffff); 409 msg->body[1] = cpu_to_le32(change_ind); 410 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len); 411 msg->body[3] = cpu_to_le32(c->dlct.phys); 412 413 i2o_msg_post(c, msg); 414 415 mutex_unlock(&c->lct_lock); 416 417 return 0; 418} 419#endif 420 421/** 422 * i2o_exec_lct_modified - Called on LCT NOTIFY reply 423 * @_work: work struct for a specific controller 424 * 425 * This function handles asynchronus LCT NOTIFY replies. It parses the 426 * new LCT and if the buffer for the LCT was to small sends a LCT NOTIFY 427 * again, otherwise send LCT NOTIFY to get informed on next LCT change. 428 */ 429static void i2o_exec_lct_modified(struct work_struct *_work) 430{ 431 struct i2o_exec_lct_notify_work *work = 432 container_of(_work, struct i2o_exec_lct_notify_work, work); 433 u32 change_ind = 0; 434 struct i2o_controller *c = work->c; 435 436 kfree(work); 437 438 if (i2o_device_parse_lct(c) != -EAGAIN) 439 change_ind = c->lct->change_ind + 1; 440 441#ifdef CONFIG_I2O_LCT_NOTIFY_ON_CHANGES 442 i2o_exec_lct_notify(c, change_ind); 443#endif 444}; 445 446/** 447 * i2o_exec_reply - I2O Executive reply handler 448 * @c: I2O controller from which the reply comes 449 * @m: message id 450 * @msg: pointer to the I2O reply message 451 * 452 * This function is always called from interrupt context. If a POST WAIT 453 * reply was received, pass it to the complete function. If a LCT NOTIFY 454 * reply was received, a new event is created to handle the update. 455 * 456 * Returns 0 on success and if the reply should not be flushed or > 0 457 * on success and if the reply should be flushed. Returns negative error 458 * code on failure and if the reply should be flushed. 459 */ 460static int i2o_exec_reply(struct i2o_controller *c, u32 m, 461 struct i2o_message *msg) 462{ 463 u32 context; 464 465 if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) { 466 struct i2o_message __iomem *pmsg; 467 u32 pm; 468 469 /* 470 * If Fail bit is set we must take the transaction context of 471 * the preserved message to find the right request again. 472 */ 473 474 pm = le32_to_cpu(msg->body[3]); 475 pmsg = i2o_msg_in_to_virt(c, pm); 476 context = readl(&pmsg->u.s.tcntxt); 477 478 i2o_report_status(KERN_INFO, "i2o_core", msg); 479 480 /* Release the preserved msg */ 481 i2o_msg_nop_mfa(c, pm); 482 } else 483 context = le32_to_cpu(msg->u.s.tcntxt); 484 485 if (context & 0x80000000) 486 return i2o_msg_post_wait_complete(c, m, msg, context); 487 488 if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) { 489 struct i2o_exec_lct_notify_work *work; 490 491 pr_debug("%s: LCT notify received\n", c->name); 492 493 work = kmalloc(sizeof(*work), GFP_ATOMIC); 494 if (!work) 495 return -ENOMEM; 496 497 work->c = c; 498 499 INIT_WORK(&work->work, i2o_exec_lct_modified); 500 queue_work(i2o_exec_driver.event_queue, &work->work); 501 return 1; 502 } 503 504 /* 505 * If this happens, we want to dump the message to the syslog so 506 * it can be sent back to the card manufacturer by the end user 507 * to aid in debugging. 508 * 509 */ 510 printk(KERN_WARNING "%s: Unsolicited message reply sent to core! Message dumped to syslog\n", 511 c->name); 512 i2o_dump_message(msg); 513 514 return -EFAULT; 515} 516 517/** 518 * i2o_exec_event - Event handling function 519 * @work: Work item in occurring event 520 * 521 * Handles events send by the Executive device. At the moment does not do 522 * anything useful. 523 */ 524static void i2o_exec_event(struct work_struct *work) 525{ 526 struct i2o_event *evt = container_of(work, struct i2o_event, work); 527 528 if (likely(evt->i2o_dev)) 529 osm_debug("Event received from device: %d\n", 530 evt->i2o_dev->lct_data.tid); 531 kfree(evt); 532}; 533 534/** 535 * i2o_exec_lct_get - Get the IOP's Logical Configuration Table 536 * @c: I2O controller from which the LCT should be fetched 537 * 538 * Send a LCT NOTIFY request to the controller, and wait 539 * I2O_TIMEOUT_LCT_GET seconds until arrival of response. If the LCT is 540 * to large, retry it. 541 * 542 * Returns 0 on success or negative error code on failure. 543 */ 544int i2o_exec_lct_get(struct i2o_controller *c) 545{ 546 struct i2o_message *msg; 547 int i = 0; 548 int rc = -EAGAIN; 549 550 for (i = 1; i <= I2O_LCT_GET_TRIES; i++) { 551 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET); 552 if (IS_ERR(msg)) 553 return PTR_ERR(msg); 554 555 msg->u.head[0] = 556 cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6); 557 msg->u.head[1] = 558 cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | 559 ADAPTER_TID); 560 msg->body[0] = cpu_to_le32(0xffffffff); 561 msg->body[1] = cpu_to_le32(0x00000000); 562 msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len); 563 msg->body[3] = cpu_to_le32(c->dlct.phys); 564 565 rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET); 566 if (rc < 0) 567 break; 568 569 rc = i2o_device_parse_lct(c); 570 if (rc != -EAGAIN) 571 break; 572 } 573 574 return rc; 575} 576 577/* Exec OSM driver struct */ 578struct i2o_driver i2o_exec_driver = { 579 .name = OSM_NAME, 580 .reply = i2o_exec_reply, 581 .event = i2o_exec_event, 582 .classes = i2o_exec_class_id, 583 .driver = { 584 .probe = i2o_exec_probe, 585 .remove = i2o_exec_remove, 586 }, 587}; 588 589/** 590 * i2o_exec_init - Registers the Exec OSM 591 * 592 * Registers the Exec OSM in the I2O core. 593 * 594 * Returns 0 on success or negative error code on failure. 595 */ 596int __init i2o_exec_init(void) 597{ 598 return i2o_driver_register(&i2o_exec_driver); 599}; 600 601/** 602 * i2o_exec_exit - Removes the Exec OSM 603 * 604 * Unregisters the Exec OSM from the I2O core. 605 */ 606void i2o_exec_exit(void) 607{ 608 i2o_driver_unregister(&i2o_exec_driver); 609}; 610 611EXPORT_SYMBOL(i2o_msg_post_wait_mem); 612EXPORT_SYMBOL(i2o_exec_lct_get); 613