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>
22 * i2o_device_issue_claim - claim or release a device
23 * @dev: I2O device to claim or release
24 * @cmd: claim or release command
25 * @type: type of claim
27 * Issue I2O UTIL_CLAIM or UTIL_RELEASE messages. The message to be sent
28 * is set by cmd. dev is the I2O device which should be claim or
29 * released and the type is the claim type (see the I2O spec).
31 * Returs 0 on success or negative error code on failure.
33 static inline int i2o_device_issue_claim(struct i2o_device
*dev
, u32 cmd
,
36 struct i2o_message __iomem
*msg
;
39 m
= i2o_msg_get_wait(dev
->iop
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
40 if (m
== I2O_QUEUE_EMPTY
)
43 writel(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
, &msg
->u
.head
[0]);
44 writel(cmd
<< 24 | HOST_TID
<< 12 | dev
->lct_data
.tid
, &msg
->u
.head
[1]);
45 writel(type
, &msg
->body
[0]);
47 return i2o_msg_post_wait(dev
->iop
, m
, 60);
51 * i2o_device_claim - claim a device for use by an OSM
52 * @dev: I2O device to claim
53 * @drv: I2O driver which wants to claim the device
55 * Do the leg work to assign a device to a given OSM. If the claim succeed
56 * the owner of the rimary. If the attempt fails a negative errno code
57 * is returned. On success zero is returned.
59 int i2o_device_claim(struct i2o_device
*dev
)
65 rc
= i2o_device_issue_claim(dev
, I2O_CMD_UTIL_CLAIM
, I2O_CLAIM_PRIMARY
);
67 pr_debug("i2o: claim of device %d succeded\n",
70 pr_debug("i2o: claim of device %d failed %d\n",
71 dev
->lct_data
.tid
, rc
);
79 * i2o_device_claim_release - release a device that the OSM is using
80 * @dev: device to release
81 * @drv: driver which claimed the device
83 * Drop a claim by an OSM on a given I2O device.
85 * AC - some devices seem to want to refuse an unclaim until they have
86 * finished internal processing. It makes sense since you don't want a
87 * new device to go reconfiguring the entire system until you are done.
88 * Thus we are prepared to wait briefly.
90 * Returns 0 on success or negative error code on failure.
92 int i2o_device_claim_release(struct i2o_device
*dev
)
100 * If the controller takes a nonblocking approach to
101 * releases we have to sleep/poll for a few times.
103 for (tries
= 0; tries
< 10; tries
++) {
104 rc
= i2o_device_issue_claim(dev
, I2O_CMD_UTIL_RELEASE
,
113 pr_debug("i2o: claim release of device %d succeded\n",
116 pr_debug("i2o: claim release of device %d failed %d\n",
117 dev
->lct_data
.tid
, rc
);
126 * i2o_device_release - release the memory for a I2O device
127 * @dev: I2O device which should be released
129 * Release the allocated memory. This function is called if refcount of
130 * device reaches 0 automatically.
132 static void i2o_device_release(struct device
*dev
)
134 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
136 pr_debug("i2o: device %s released\n", dev
->bus_id
);
143 * i2o_device_class_show_class_id - Displays class id of I2O device
144 * @cd: class device of which the class id should be displayed
145 * @buf: buffer into which the class id should be printed
147 * Returns the number of bytes which are printed into the buffer.
149 static ssize_t
i2o_device_show_class_id(struct device
*dev
,
150 struct device_attribute
*attr
,
153 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
155 sprintf(buf
, "0x%03x\n", i2o_dev
->lct_data
.class_id
);
156 return strlen(buf
) + 1;
160 * i2o_device_class_show_tid - Displays TID of I2O device
161 * @cd: class device of which the TID should be displayed
162 * @buf: buffer into which the class id should be printed
164 * Returns the number of bytes which are printed into the buffer.
166 static ssize_t
i2o_device_show_tid(struct device
*dev
,
167 struct device_attribute
*attr
,
170 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
172 sprintf(buf
, "0x%03x\n", i2o_dev
->lct_data
.tid
);
173 return strlen(buf
) + 1;
176 struct device_attribute i2o_device_attrs
[] = {
177 __ATTR(class_id
, S_IRUGO
, i2o_device_show_class_id
, NULL
),
178 __ATTR(tid
, S_IRUGO
, i2o_device_show_tid
, NULL
),
183 * i2o_device_alloc - Allocate a I2O device and initialize it
185 * Allocate the memory for a I2O device and initialize locks and lists
187 * Returns the allocated I2O device or a negative error code if the device
188 * could not be allocated.
190 static struct i2o_device
*i2o_device_alloc(void)
192 struct i2o_device
*dev
;
194 dev
= kmalloc(sizeof(*dev
), GFP_KERNEL
);
196 return ERR_PTR(-ENOMEM
);
198 memset(dev
, 0, sizeof(*dev
));
200 INIT_LIST_HEAD(&dev
->list
);
201 init_MUTEX(&dev
->lock
);
203 dev
->device
.bus
= &i2o_bus_type
;
204 dev
->device
.release
= &i2o_device_release
;
210 * i2o_setup_sysfs_links - Adds attributes to the I2O device
211 * @cd: I2O class device which is added to the I2O device class
213 * This function get called when a I2O device is added to the class. It
214 * creates the attributes for each device and creates user/parent symlink
217 * Returns 0 on success or negative error code on failure.
219 static void i2o_setup_sysfs_links(struct i2o_device
*i2o_dev
)
221 struct i2o_controller
*c
= i2o_dev
->iop
;
222 struct i2o_device
*tmp
;
224 /* create user entries for this device */
225 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.user_tid
);
226 if (tmp
&& tmp
!= i2o_dev
)
227 sysfs_create_link(&i2o_dev
->device
.kobj
,
228 &tmp
->device
.kobj
, "user");
230 /* create user entries refering to this device */
231 list_for_each_entry(tmp
, &c
->devices
, list
)
232 if (tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
&&
234 sysfs_create_link(&tmp
->device
.kobj
,
235 &i2o_dev
->device
.kobj
, "user");
237 /* create parent entries for this device */
238 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.parent_tid
);
239 if (tmp
&& tmp
!= i2o_dev
)
240 sysfs_create_link(&i2o_dev
->device
.kobj
,
241 &tmp
->device
.kobj
, "parent");
243 /* create parent entries refering to this device */
244 list_for_each_entry(tmp
, &c
->devices
, list
)
245 if (tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
&&
247 sysfs_create_link(&tmp
->device
.kobj
,
248 &i2o_dev
->device
.kobj
, "parent");
251 static void i2o_remove_sysfs_links(struct i2o_device
*i2o_dev
)
253 struct i2o_controller
*c
= i2o_dev
->iop
;
254 struct i2o_device
*tmp
;
256 sysfs_remove_link(&i2o_dev
->device
.kobj
, "parent");
257 sysfs_remove_link(&i2o_dev
->device
.kobj
, "user");
259 list_for_each_entry(tmp
, &c
->devices
, list
) {
260 if (tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
)
261 sysfs_remove_link(&tmp
->device
.kobj
, "parent");
262 if (tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
)
263 sysfs_remove_link(&tmp
->device
.kobj
, "user");
270 * i2o_device_add - allocate a new I2O device and add it to the IOP
271 * @iop: I2O controller where the device is on
272 * @entry: LCT entry of the I2O device
274 * Allocate a new I2O device and initialize it with the LCT entry. The
275 * device is appended to the device list of the controller.
277 * Returns a pointer to the I2O device on success or negative error code
280 static struct i2o_device
*i2o_device_add(struct i2o_controller
*c
,
281 i2o_lct_entry
* entry
)
283 struct i2o_device
*dev
;
285 dev
= i2o_device_alloc();
287 printk(KERN_ERR
"i2o: unable to allocate i2o device\n");
291 dev
->lct_data
= *entry
;
294 snprintf(dev
->device
.bus_id
, BUS_ID_SIZE
, "%d:%03x", c
->unit
,
297 dev
->device
.parent
= &c
->device
;
299 device_register(&dev
->device
);
301 list_add_tail(&dev
->list
, &c
->devices
);
303 i2o_setup_sysfs_links(dev
);
305 i2o_driver_notify_device_add_all(dev
);
307 pr_debug("i2o: device %s added\n", dev
->device
.bus_id
);
313 * i2o_device_remove - remove an I2O device from the I2O core
314 * @dev: I2O device which should be released
316 * Is used on I2O controller removal or LCT modification, when the device
317 * is removed from the system. Note that the device could still hang
318 * around until the refcount reaches 0.
320 void i2o_device_remove(struct i2o_device
*i2o_dev
)
322 i2o_driver_notify_device_remove_all(i2o_dev
);
323 i2o_remove_sysfs_links(i2o_dev
);
324 list_del(&i2o_dev
->list
);
325 device_unregister(&i2o_dev
->device
);
329 * i2o_device_parse_lct - Parse a previously fetched LCT and create devices
330 * @c: I2O controller from which the LCT should be parsed.
332 * The Logical Configuration Table tells us what we can talk to on the
333 * board. For every entry we create an I2O device, which is registered in
336 * Returns 0 on success or negative error code on failure.
338 int i2o_device_parse_lct(struct i2o_controller
*c
)
340 struct i2o_device
*dev
, *tmp
;
351 c
->lct
= kmalloc(lct
->table_size
* 4, GFP_KERNEL
);
357 if (lct
->table_size
* 4 > c
->dlct
.len
) {
358 memcpy(c
->lct
, c
->dlct
.virt
, c
->dlct
.len
);
363 memcpy(c
->lct
, c
->dlct
.virt
, lct
->table_size
* 4);
367 max
= (lct
->table_size
- 3) / 9;
369 pr_debug("%s: LCT has %d entries (LCT size: %d)\n", c
->name
, max
,
372 /* remove devices, which are not in the LCT anymore */
373 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
376 for (i
= 0; i
< max
; i
++) {
377 if (lct
->lct_entry
[i
].tid
== dev
->lct_data
.tid
) {
384 i2o_device_remove(dev
);
387 /* add new devices, which are new in the LCT */
388 for (i
= 0; i
< max
; i
++) {
391 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
392 if (lct
->lct_entry
[i
].tid
== dev
->lct_data
.tid
) {
399 i2o_device_add(c
, &lct
->lct_entry
[i
]);
408 * Run time support routines
411 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
413 * This function can be used for all UtilParamsGet/Set operations.
414 * The OperationList is given in oplist-buffer,
415 * and results are returned in reslist-buffer.
416 * Note that the minimum sized reslist is 8 bytes and contains
417 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
419 int i2o_parm_issue(struct i2o_device
*i2o_dev
, int cmd
, void *oplist
,
420 int oplen
, void *reslist
, int reslen
)
422 struct i2o_message __iomem
*msg
;
424 u32
*res32
= (u32
*) reslist
;
425 u32
*restmp
= (u32
*) reslist
;
430 struct i2o_controller
*c
= i2o_dev
->iop
;
431 struct device
*dev
= &c
->pdev
->dev
;
435 if (i2o_dma_alloc(dev
, &res
, reslen
, GFP_KERNEL
))
438 m
= i2o_msg_get_wait(c
, &msg
, I2O_TIMEOUT_MESSAGE_GET
);
439 if (m
== I2O_QUEUE_EMPTY
) {
440 i2o_dma_free(dev
, &res
);
445 writel(cmd
<< 24 | HOST_TID
<< 12 | i2o_dev
->lct_data
.tid
,
447 writel(0, &msg
->body
[i
++]);
448 writel(0x4C000000 | oplen
, &msg
->body
[i
++]); /* OperationList */
449 memcpy_toio(&msg
->body
[i
], oplist
, oplen
);
450 i
+= (oplen
/ 4 + (oplen
% 4 ? 1 : 0));
451 writel(0xD0000000 | res
.len
, &msg
->body
[i
++]); /* ResultList */
452 writel(res
.phys
, &msg
->body
[i
++]);
454 writel(I2O_MESSAGE_SIZE(i
+ sizeof(struct i2o_message
) / 4) |
455 SGL_OFFSET_5
, &msg
->u
.head
[0]);
457 rc
= i2o_msg_post_wait_mem(c
, m
, 10, &res
);
459 /* This only looks like a memory leak - don't "fix" it. */
460 if (rc
== -ETIMEDOUT
)
463 memcpy(reslist
, res
.virt
, res
.len
);
464 i2o_dma_free(dev
, &res
);
470 * Calculate number of bytes of Result LIST
471 * We need to loop through each Result BLOCK and grab the length
475 for (i
= 0; i
< (res32
[0] & 0X0000FFFF); i
++) {
476 if (restmp
[0] & 0x00FF0000) { /* BlockStatus != SUCCESS */
478 "%s - Error:\n ErrorInfoSize = 0x%02x, "
479 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
481 I2O_CMD_UTIL_PARAMS_SET
) ? "PARAMS_SET" :
482 "PARAMS_GET", res32
[1] >> 24,
483 (res32
[1] >> 16) & 0xFF, res32
[1] & 0xFFFF);
486 * If this is the only request,than we return an error
488 if ((res32
[0] & 0x0000FFFF) == 1) {
489 return -((res32
[1] >> 16) & 0xFF); /* -BlockStatus */
492 len
+= restmp
[0] & 0x0000FFFF; /* Length of res BLOCK */
493 restmp
+= restmp
[0] & 0x0000FFFF; /* Skip to next BLOCK */
495 return (len
<< 2); /* bytes used by result list */
499 * Query one field group value or a whole scalar group.
501 int i2o_parm_field_get(struct i2o_device
*i2o_dev
, int group
, int field
,
502 void *buf
, int buflen
)
504 u16 opblk
[] = { 1, 0, I2O_PARAMS_FIELD_GET
, group
, 1, field
};
505 u8
*resblk
; /* 8 bytes for header */
508 if (field
== -1) /* whole group */
511 resblk
= kmalloc(buflen
+ 8, GFP_KERNEL
| GFP_ATOMIC
);
515 size
= i2o_parm_issue(i2o_dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
516 sizeof(opblk
), resblk
, buflen
+ 8);
518 memcpy(buf
, resblk
+ 8, buflen
); /* cut off header */
529 * if oper == I2O_PARAMS_TABLE_GET, get from all rows
530 * if fieldcount == -1 return all fields
531 * ibuf and ibuflen are unused (use NULL, 0)
532 * else return specific fields
533 * ibuf contains fieldindexes
535 * if oper == I2O_PARAMS_LIST_GET, get from specific rows
536 * if fieldcount == -1 return all fields
537 * ibuf contains rowcount, keyvalues
538 * else return specific fields
539 * fieldcount is # of fieldindexes
540 * ibuf contains fieldindexes, rowcount, keyvalues
542 * You could also use directly function i2o_issue_params().
544 int i2o_parm_table_get(struct i2o_device
*dev
, int oper
, int group
,
545 int fieldcount
, void *ibuf
, int ibuflen
, void *resblk
,
553 size
+= 4 - size
% 4;
555 opblk
= kmalloc(size
, GFP_KERNEL
);
557 printk(KERN_ERR
"i2o: no memory for query buffer.\n");
561 opblk
[0] = 1; /* operation count */
562 opblk
[1] = 0; /* pad */
565 opblk
[4] = fieldcount
;
566 memcpy(opblk
+ 5, ibuf
, ibuflen
); /* other params */
568 size
= i2o_parm_issue(dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
569 size
, resblk
, reslen
);
578 EXPORT_SYMBOL(i2o_device_claim
);
579 EXPORT_SYMBOL(i2o_device_claim_release
);
580 EXPORT_SYMBOL(i2o_parm_field_get
);
581 EXPORT_SYMBOL(i2o_parm_table_get
);
582 EXPORT_SYMBOL(i2o_parm_issue
);