2 * Functions to handle I2O devices
4 * Copyright (C) 2004 Markus Lidel <Markus.Lidel@shadowconnect.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
12 * Markus Lidel <Markus.Lidel@shadowconnect.com>
16 #include <linux/module.h>
17 #include <linux/i2o.h>
18 #include <linux/delay.h>
20 /* Exec OSM functions */
21 extern struct bus_type i2o_bus_type
;
24 * i2o_device_issue_claim - claim or release a device
25 * @dev: I2O device to claim or release
26 * @cmd: claim or release command
27 * @type: type of claim
29 * Issue I2O UTIL_CLAIM or UTIL_RELEASE messages. The message to be sent
30 * is set by cmd. dev is the I2O device which should be claim or
31 * released and the type is the claim type (see the I2O spec).
33 * Returs 0 on success or negative error code on failure.
35 static inline int i2o_device_issue_claim(struct i2o_device
*dev
, u32 cmd
,
38 struct i2o_message __iomem
*msg
;
41 m
= i2o_msg_get_wait(dev
->iop
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
42 if (m
== I2O_QUEUE_EMPTY
)
45 writel(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
, &msg
->u
.head
[0]);
46 writel(cmd
<< 24 | HOST_TID
<< 12 | dev
->lct_data
.tid
, &msg
->u
.head
[1]);
47 writel(type
, &msg
->body
[0]);
49 return i2o_msg_post_wait(dev
->iop
, m
, 60);
53 * i2o_device_claim - claim a device for use by an OSM
54 * @dev: I2O device to claim
55 * @drv: I2O driver which wants to claim the device
57 * Do the leg work to assign a device to a given OSM. If the claim succeed
58 * the owner of the rimary. If the attempt fails a negative errno code
59 * is returned. On success zero is returned.
61 int i2o_device_claim(struct i2o_device
*dev
)
67 rc
= i2o_device_issue_claim(dev
, I2O_CMD_UTIL_CLAIM
, I2O_CLAIM_PRIMARY
);
69 pr_debug("i2o: claim of device %d succeded\n",
72 pr_debug("i2o: claim of device %d failed %d\n",
73 dev
->lct_data
.tid
, rc
);
81 * i2o_device_claim_release - release a device that the OSM is using
82 * @dev: device to release
83 * @drv: driver which claimed the device
85 * Drop a claim by an OSM on a given I2O device.
87 * AC - some devices seem to want to refuse an unclaim until they have
88 * finished internal processing. It makes sense since you don't want a
89 * new device to go reconfiguring the entire system until you are done.
90 * Thus we are prepared to wait briefly.
92 * Returns 0 on success or negative error code on failure.
94 int i2o_device_claim_release(struct i2o_device
*dev
)
102 * If the controller takes a nonblocking approach to
103 * releases we have to sleep/poll for a few times.
105 for (tries
= 0; tries
< 10; tries
++) {
106 rc
= i2o_device_issue_claim(dev
, I2O_CMD_UTIL_RELEASE
,
115 pr_debug("i2o: claim release of device %d succeded\n",
118 pr_debug("i2o: claim release of device %d failed %d\n",
119 dev
->lct_data
.tid
, rc
);
127 * i2o_device_release - release the memory for a I2O device
128 * @dev: I2O device which should be released
130 * Release the allocated memory. This function is called if refcount of
131 * device reaches 0 automatically.
133 static void i2o_device_release(struct device
*dev
)
135 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
137 pr_debug("i2o: device %s released\n", dev
->bus_id
);
143 * i2o_device_class_release - Remove I2O device attributes
144 * @cd: I2O class device which is added to the I2O device class
146 * Removes attributes from the I2O device again. Also search each device
147 * on the controller for I2O devices which refert to this device as parent
148 * or user and remove this links also.
150 static void i2o_device_class_release(struct class_device
*cd
)
152 struct i2o_device
*i2o_dev
, *tmp
;
153 struct i2o_controller
*c
;
155 i2o_dev
= to_i2o_device(cd
->dev
);
158 sysfs_remove_link(&i2o_dev
->device
.kobj
, "parent");
159 sysfs_remove_link(&i2o_dev
->device
.kobj
, "user");
161 list_for_each_entry(tmp
, &c
->devices
, list
) {
162 if (tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
)
163 sysfs_remove_link(&tmp
->device
.kobj
, "parent");
164 if (tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
)
165 sysfs_remove_link(&tmp
->device
.kobj
, "user");
169 /* I2O device class */
170 static struct class i2o_device_class
= {
171 .name
= "i2o_device",
172 .release
= i2o_device_class_release
176 * i2o_device_alloc - Allocate a I2O device and initialize it
178 * Allocate the memory for a I2O device and initialize locks and lists
180 * Returns the allocated I2O device or a negative error code if the device
181 * could not be allocated.
183 static struct i2o_device
*i2o_device_alloc(void)
185 struct i2o_device
*dev
;
187 dev
= kmalloc(sizeof(*dev
), GFP_KERNEL
);
189 return ERR_PTR(-ENOMEM
);
191 memset(dev
, 0, sizeof(*dev
));
193 INIT_LIST_HEAD(&dev
->list
);
194 init_MUTEX(&dev
->lock
);
196 dev
->device
.bus
= &i2o_bus_type
;
197 dev
->device
.release
= &i2o_device_release
;
198 dev
->classdev
.class = &i2o_device_class
;
199 dev
->classdev
.dev
= &dev
->device
;
205 * i2o_device_add - allocate a new I2O device and add it to the IOP
206 * @iop: I2O controller where the device is on
207 * @entry: LCT entry of the I2O device
209 * Allocate a new I2O device and initialize it with the LCT entry. The
210 * device is appended to the device list of the controller.
212 * Returns a pointer to the I2O device on success or negative error code
215 static struct i2o_device
*i2o_device_add(struct i2o_controller
*c
,
216 i2o_lct_entry
* entry
)
218 struct i2o_device
*dev
;
220 dev
= i2o_device_alloc();
222 printk(KERN_ERR
"i2o: unable to allocate i2o device\n");
226 dev
->lct_data
= *entry
;
228 snprintf(dev
->device
.bus_id
, BUS_ID_SIZE
, "%d:%03x", c
->unit
,
231 snprintf(dev
->classdev
.class_id
, BUS_ID_SIZE
, "%d:%03x", c
->unit
,
235 dev
->device
.parent
= &c
->device
;
237 device_register(&dev
->device
);
239 list_add_tail(&dev
->list
, &c
->devices
);
241 class_device_register(&dev
->classdev
);
243 i2o_driver_notify_device_add_all(dev
);
245 pr_debug("i2o: device %s added\n", dev
->device
.bus_id
);
251 * i2o_device_remove - remove an I2O device from the I2O core
252 * @dev: I2O device which should be released
254 * Is used on I2O controller removal or LCT modification, when the device
255 * is removed from the system. Note that the device could still hang
256 * around until the refcount reaches 0.
258 void i2o_device_remove(struct i2o_device
*i2o_dev
)
260 i2o_driver_notify_device_remove_all(i2o_dev
);
261 class_device_unregister(&i2o_dev
->classdev
);
262 list_del(&i2o_dev
->list
);
263 device_unregister(&i2o_dev
->device
);
267 * i2o_device_parse_lct - Parse a previously fetched LCT and create devices
268 * @c: I2O controller from which the LCT should be parsed.
270 * The Logical Configuration Table tells us what we can talk to on the
271 * board. For every entry we create an I2O device, which is registered in
274 * Returns 0 on success or negative error code on failure.
276 int i2o_device_parse_lct(struct i2o_controller
*c
)
278 struct i2o_device
*dev
, *tmp
;
289 c
->lct
= kmalloc(lct
->table_size
* 4, GFP_KERNEL
);
295 if (lct
->table_size
* 4 > c
->dlct
.len
) {
296 memcpy_fromio(c
->lct
, c
->dlct
.virt
, c
->dlct
.len
);
301 memcpy_fromio(c
->lct
, c
->dlct
.virt
, lct
->table_size
* 4);
305 max
= (lct
->table_size
- 3) / 9;
307 pr_debug("%s: LCT has %d entries (LCT size: %d)\n", c
->name
, max
,
310 /* remove devices, which are not in the LCT anymore */
311 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
314 for (i
= 0; i
< max
; i
++) {
315 if (lct
->lct_entry
[i
].tid
== dev
->lct_data
.tid
) {
322 i2o_device_remove(dev
);
325 /* add new devices, which are new in the LCT */
326 for (i
= 0; i
< max
; i
++) {
329 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
330 if (lct
->lct_entry
[i
].tid
== dev
->lct_data
.tid
) {
337 i2o_device_add(c
, &lct
->lct_entry
[i
]);
345 * i2o_device_class_show_class_id - Displays class id of I2O device
346 * @cd: class device of which the class id should be displayed
347 * @buf: buffer into which the class id should be printed
349 * Returns the number of bytes which are printed into the buffer.
351 static ssize_t
i2o_device_class_show_class_id(struct class_device
*cd
,
354 struct i2o_device
*dev
= to_i2o_device(cd
->dev
);
356 sprintf(buf
, "%03x\n", dev
->lct_data
.class_id
);
357 return strlen(buf
) + 1;
361 * i2o_device_class_show_tid - Displays TID of I2O device
362 * @cd: class device of which the TID should be displayed
363 * @buf: buffer into which the class id should be printed
365 * Returns the number of bytes which are printed into the buffer.
367 static ssize_t
i2o_device_class_show_tid(struct class_device
*cd
, char *buf
)
369 struct i2o_device
*dev
= to_i2o_device(cd
->dev
);
371 sprintf(buf
, "%03x\n", dev
->lct_data
.tid
);
372 return strlen(buf
) + 1;
375 /* I2O device class attributes */
376 static CLASS_DEVICE_ATTR(class_id
, S_IRUGO
, i2o_device_class_show_class_id
,
378 static CLASS_DEVICE_ATTR(tid
, S_IRUGO
, i2o_device_class_show_tid
, NULL
);
381 * i2o_device_class_add - Adds attributes to the I2O device
382 * @cd: I2O class device which is added to the I2O device class
384 * This function get called when a I2O device is added to the class. It
385 * creates the attributes for each device and creates user/parent symlink
388 * Returns 0 on success or negative error code on failure.
390 static int i2o_device_class_add(struct class_device
*cd
)
392 struct i2o_device
*i2o_dev
, *tmp
;
393 struct i2o_controller
*c
;
395 i2o_dev
= to_i2o_device(cd
->dev
);
398 class_device_create_file(cd
, &class_device_attr_class_id
);
399 class_device_create_file(cd
, &class_device_attr_tid
);
401 /* create user entries for this device */
402 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.user_tid
);
403 if (tmp
&& (tmp
!= i2o_dev
))
404 sysfs_create_link(&i2o_dev
->device
.kobj
, &tmp
->device
.kobj
,
407 /* create user entries refering to this device */
408 list_for_each_entry(tmp
, &c
->devices
, list
)
409 if ((tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
)
411 sysfs_create_link(&tmp
->device
.kobj
,
412 &i2o_dev
->device
.kobj
, "user");
414 /* create parent entries for this device */
415 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.parent_tid
);
416 if (tmp
&& (tmp
!= i2o_dev
))
417 sysfs_create_link(&i2o_dev
->device
.kobj
, &tmp
->device
.kobj
,
420 /* create parent entries refering to this device */
421 list_for_each_entry(tmp
, &c
->devices
, list
)
422 if ((tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
)
424 sysfs_create_link(&tmp
->device
.kobj
,
425 &i2o_dev
->device
.kobj
, "parent");
430 /* I2O device class interface */
431 static struct class_interface i2o_device_class_interface
= {
432 .class = &i2o_device_class
,
433 .add
= i2o_device_class_add
437 * Run time support routines
440 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
442 * This function can be used for all UtilParamsGet/Set operations.
443 * The OperationList is given in oplist-buffer,
444 * and results are returned in reslist-buffer.
445 * Note that the minimum sized reslist is 8 bytes and contains
446 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
449 static int i2o_parm_issue(struct i2o_device
*i2o_dev
, int cmd
, void *oplist
,
450 int oplen
, void *reslist
, int reslen
)
452 struct i2o_message __iomem
*msg
;
454 u32
*res32
= (u32
*) reslist
;
455 u32
*restmp
= (u32
*) reslist
;
460 struct i2o_controller
*c
= i2o_dev
->iop
;
461 struct device
*dev
= &c
->pdev
->dev
;
465 if (i2o_dma_alloc(dev
, &res
, reslen
, GFP_KERNEL
))
468 m
= i2o_msg_get_wait(c
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
469 if (m
== I2O_QUEUE_EMPTY
) {
470 i2o_dma_free(dev
, &res
);
475 writel(cmd
<< 24 | HOST_TID
<< 12 | i2o_dev
->lct_data
.tid
,
477 writel(0, &msg
->body
[i
++]);
478 writel(0x4C000000 | oplen
, &msg
->body
[i
++]); /* OperationList */
479 memcpy_toio(&msg
->body
[i
], oplist
, oplen
);
480 i
+= (oplen
/ 4 + (oplen
% 4 ? 1 : 0));
481 writel(0xD0000000 | res
.len
, &msg
->body
[i
++]); /* ResultList */
482 writel(res
.phys
, &msg
->body
[i
++]);
484 writel(I2O_MESSAGE_SIZE(i
+ sizeof(struct i2o_message
) / 4) |
485 SGL_OFFSET_5
, &msg
->u
.head
[0]);
487 rc
= i2o_msg_post_wait_mem(c
, m
, 10, &res
);
489 /* This only looks like a memory leak - don't "fix" it. */
490 if (rc
== -ETIMEDOUT
)
493 memcpy_fromio(reslist
, res
.virt
, res
.len
);
494 i2o_dma_free(dev
, &res
);
500 * Calculate number of bytes of Result LIST
501 * We need to loop through each Result BLOCK and grab the length
505 for (i
= 0; i
< (res32
[0] & 0X0000FFFF); i
++) {
506 if (restmp
[0] & 0x00FF0000) { /* BlockStatus != SUCCESS */
508 "%s - Error:\n ErrorInfoSize = 0x%02x, "
509 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
511 I2O_CMD_UTIL_PARAMS_SET
) ? "PARAMS_SET" :
512 "PARAMS_GET", res32
[1] >> 24,
513 (res32
[1] >> 16) & 0xFF, res32
[1] & 0xFFFF);
516 * If this is the only request,than we return an error
518 if ((res32
[0] & 0x0000FFFF) == 1) {
519 return -((res32
[1] >> 16) & 0xFF); /* -BlockStatus */
522 len
+= restmp
[0] & 0x0000FFFF; /* Length of res BLOCK */
523 restmp
+= restmp
[0] & 0x0000FFFF; /* Skip to next BLOCK */
525 return (len
<< 2); /* bytes used by result list */
529 * Query one field group value or a whole scalar group.
531 int i2o_parm_field_get(struct i2o_device
*i2o_dev
, int group
, int field
,
532 void *buf
, int buflen
)
534 u16 opblk
[] = { 1, 0, I2O_PARAMS_FIELD_GET
, group
, 1, field
};
535 u8 resblk
[8 + buflen
]; /* 8 bytes for header */
538 if (field
== -1) /* whole group */
541 size
= i2o_parm_issue(i2o_dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
542 sizeof(opblk
), resblk
, buflen
+ 8);
544 memcpy(buf
, resblk
+ 8, buflen
); /* cut off header */
553 * if oper == I2O_PARAMS_TABLE_GET, get from all rows
554 * if fieldcount == -1 return all fields
555 * ibuf and ibuflen are unused (use NULL, 0)
556 * else return specific fields
557 * ibuf contains fieldindexes
559 * if oper == I2O_PARAMS_LIST_GET, get from specific rows
560 * if fieldcount == -1 return all fields
561 * ibuf contains rowcount, keyvalues
562 * else return specific fields
563 * fieldcount is # of fieldindexes
564 * ibuf contains fieldindexes, rowcount, keyvalues
566 * You could also use directly function i2o_issue_params().
568 int i2o_parm_table_get(struct i2o_device
*dev
, int oper
, int group
,
569 int fieldcount
, void *ibuf
, int ibuflen
, void *resblk
,
577 size
+= 4 - size
% 4;
579 opblk
= kmalloc(size
, GFP_KERNEL
);
581 printk(KERN_ERR
"i2o: no memory for query buffer.\n");
585 opblk
[0] = 1; /* operation count */
586 opblk
[1] = 0; /* pad */
589 opblk
[4] = fieldcount
;
590 memcpy(opblk
+ 5, ibuf
, ibuflen
); /* other params */
592 size
= i2o_parm_issue(dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
593 size
, resblk
, reslen
);
603 * i2o_device_init - Initialize I2O devices
605 * Registers the I2O device class.
607 * Returns 0 on success or negative error code on failure.
609 int i2o_device_init(void)
613 rc
= class_register(&i2o_device_class
);
617 return class_interface_register(&i2o_device_class_interface
);
621 * i2o_device_exit - I2O devices exit function
623 * Unregisters the I2O device class.
625 void i2o_device_exit(void)
627 class_interface_register(&i2o_device_class_interface
);
628 class_unregister(&i2o_device_class
);
631 EXPORT_SYMBOL(i2o_device_claim
);
632 EXPORT_SYMBOL(i2o_device_claim_release
);
633 EXPORT_SYMBOL(i2o_parm_field_get
);
634 EXPORT_SYMBOL(i2o_parm_table_get
);
635 EXPORT_SYMBOL(i2o_parm_issue
);