• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  */
i2o_exec_wait_alloc(void)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  */
i2o_exec_wait_free(struct i2o_exec_wait * wait)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  */
i2o_msg_post_wait_mem(struct i2o_controller * c,struct i2o_message * msg,unsigned long timeout,struct i2o_dma * dma)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  */
i2o_msg_post_wait_complete(struct i2o_controller * c,u32 m,struct i2o_message * msg,u32 context)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  */
i2o_exec_show_vendor_id(struct device * d,struct device_attribute * attr,char * buf)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  */
i2o_exec_show_product_id(struct device * d,struct device_attribute * attr,char * buf)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  */
i2o_exec_probe(struct device * dev)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  */
i2o_exec_remove(struct device * dev)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  */
i2o_exec_lct_notify(struct i2o_controller * c,u32 change_ind)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  */
i2o_exec_lct_modified(struct work_struct * _work)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  */
i2o_exec_reply(struct i2o_controller * c,u32 m,struct i2o_message * msg)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  */
i2o_exec_event(struct work_struct * work)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  */
i2o_exec_lct_get(struct i2o_controller * c)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  */
i2o_exec_init(void)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  */
i2o_exec_exit(void)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);
609