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>
19 #include <linux/string.h>
20 #include <linux/slab.h>
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
*msg
;
40 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
44 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
46 cpu_to_le32(cmd
<< 24 | HOST_TID
<< 12 | dev
->lct_data
.tid
);
47 msg
->body
[0] = cpu_to_le32(type
);
49 return i2o_msg_post_wait(dev
->iop
, msg
, 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_show_class_id - Displays class id of I2O device
144 * @dev: device of which the class id should be displayed
145 * @attr: pointer to device attribute
146 * @buf: buffer into which the class id should be printed
148 * Returns the number of bytes which are printed into the buffer.
150 static ssize_t
i2o_device_show_class_id(struct device
*dev
,
151 struct device_attribute
*attr
,
154 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
156 sprintf(buf
, "0x%03x\n", i2o_dev
->lct_data
.class_id
);
157 return strlen(buf
) + 1;
161 * i2o_device_show_tid - Displays TID of I2O device
162 * @dev: device of which the TID should be displayed
163 * @attr: pointer to device attribute
164 * @buf: buffer into which the TID should be printed
166 * Returns the number of bytes which are printed into the buffer.
168 static ssize_t
i2o_device_show_tid(struct device
*dev
,
169 struct device_attribute
*attr
, char *buf
)
171 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
173 sprintf(buf
, "0x%03x\n", i2o_dev
->lct_data
.tid
);
174 return strlen(buf
) + 1;
177 /* I2O device attributes */
178 struct device_attribute i2o_device_attrs
[] = {
179 __ATTR(class_id
, S_IRUGO
, i2o_device_show_class_id
, NULL
),
180 __ATTR(tid
, S_IRUGO
, i2o_device_show_tid
, NULL
),
185 * i2o_device_alloc - Allocate a I2O device and initialize it
187 * Allocate the memory for a I2O device and initialize locks and lists
189 * Returns the allocated I2O device or a negative error code if the device
190 * could not be allocated.
192 static struct i2o_device
*i2o_device_alloc(void)
194 struct i2o_device
*dev
;
196 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
198 return ERR_PTR(-ENOMEM
);
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_device_add - allocate a new I2O device and add it to the IOP
211 * @iop: I2O controller where the device is on
212 * @entry: LCT entry of the I2O device
214 * Allocate a new I2O device and initialize it with the LCT entry. The
215 * device is appended to the device list of the controller.
217 * Returns a pointer to the I2O device on success or negative error code
220 static struct i2o_device
*i2o_device_add(struct i2o_controller
*c
,
221 i2o_lct_entry
* entry
)
223 struct i2o_device
*i2o_dev
, *tmp
;
225 i2o_dev
= i2o_device_alloc();
226 if (IS_ERR(i2o_dev
)) {
227 printk(KERN_ERR
"i2o: unable to allocate i2o device\n");
231 i2o_dev
->lct_data
= *entry
;
233 snprintf(i2o_dev
->device
.bus_id
, BUS_ID_SIZE
, "%d:%03x", c
->unit
,
234 i2o_dev
->lct_data
.tid
);
237 i2o_dev
->device
.parent
= &c
->device
;
239 device_register(&i2o_dev
->device
);
241 list_add_tail(&i2o_dev
->list
, &c
->devices
);
243 /* create user entries for this device */
244 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.user_tid
);
245 if (tmp
&& (tmp
!= i2o_dev
))
246 sysfs_create_link(&i2o_dev
->device
.kobj
, &tmp
->device
.kobj
,
249 /* create user entries refering to this device */
250 list_for_each_entry(tmp
, &c
->devices
, list
)
251 if ((tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
)
253 sysfs_create_link(&tmp
->device
.kobj
,
254 &i2o_dev
->device
.kobj
, "user");
256 /* create parent entries for this device */
257 tmp
= i2o_iop_find_device(i2o_dev
->iop
, i2o_dev
->lct_data
.parent_tid
);
258 if (tmp
&& (tmp
!= i2o_dev
))
259 sysfs_create_link(&i2o_dev
->device
.kobj
, &tmp
->device
.kobj
,
262 /* create parent entries refering to this device */
263 list_for_each_entry(tmp
, &c
->devices
, list
)
264 if ((tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
)
266 sysfs_create_link(&tmp
->device
.kobj
,
267 &i2o_dev
->device
.kobj
, "parent");
269 i2o_driver_notify_device_add_all(i2o_dev
);
271 pr_debug("i2o: device %s added\n", i2o_dev
->device
.bus_id
);
277 * i2o_device_remove - remove an I2O device from the I2O core
278 * @dev: I2O device which should be released
280 * Is used on I2O controller removal or LCT modification, when the device
281 * is removed from the system. Note that the device could still hang
282 * around until the refcount reaches 0.
284 void i2o_device_remove(struct i2o_device
*i2o_dev
)
286 struct i2o_device
*tmp
;
287 struct i2o_controller
*c
= i2o_dev
->iop
;
289 i2o_driver_notify_device_remove_all(i2o_dev
);
291 sysfs_remove_link(&i2o_dev
->device
.kobj
, "parent");
292 sysfs_remove_link(&i2o_dev
->device
.kobj
, "user");
294 list_for_each_entry(tmp
, &c
->devices
, list
) {
295 if (tmp
->lct_data
.parent_tid
== i2o_dev
->lct_data
.tid
)
296 sysfs_remove_link(&tmp
->device
.kobj
, "parent");
297 if (tmp
->lct_data
.user_tid
== i2o_dev
->lct_data
.tid
)
298 sysfs_remove_link(&tmp
->device
.kobj
, "user");
300 list_del(&i2o_dev
->list
);
302 device_unregister(&i2o_dev
->device
);
306 * i2o_device_parse_lct - Parse a previously fetched LCT and create devices
307 * @c: I2O controller from which the LCT should be parsed.
309 * The Logical Configuration Table tells us what we can talk to on the
310 * board. For every entry we create an I2O device, which is registered in
313 * Returns 0 on success or negative error code on failure.
315 int i2o_device_parse_lct(struct i2o_controller
*c
)
317 struct i2o_device
*dev
, *tmp
;
319 u32
*dlct
= c
->dlct
.virt
;
328 buf
= le32_to_cpu(*dlct
++);
329 table_size
= buf
& 0xffff;
331 lct
= c
->lct
= kmalloc(table_size
* 4, GFP_KERNEL
);
337 lct
->lct_ver
= buf
>> 28;
338 lct
->boot_tid
= buf
>> 16 & 0xfff;
339 lct
->table_size
= table_size
;
340 lct
->change_ind
= le32_to_cpu(*dlct
++);
341 lct
->iop_flags
= le32_to_cpu(*dlct
++);
345 pr_debug("%s: LCT has %d entries (LCT size: %d)\n", c
->name
, max
,
348 while (table_size
> 0) {
349 i2o_lct_entry
*entry
= &lct
->lct_entry
[max
];
352 buf
= le32_to_cpu(*dlct
++);
353 entry
->entry_size
= buf
& 0xffff;
354 entry
->tid
= buf
>> 16 & 0xfff;
356 entry
->change_ind
= le32_to_cpu(*dlct
++);
357 entry
->device_flags
= le32_to_cpu(*dlct
++);
359 buf
= le32_to_cpu(*dlct
++);
360 entry
->class_id
= buf
& 0xfff;
361 entry
->version
= buf
>> 12 & 0xf;
362 entry
->vendor_id
= buf
>> 16;
364 entry
->sub_class
= le32_to_cpu(*dlct
++);
366 buf
= le32_to_cpu(*dlct
++);
367 entry
->user_tid
= buf
& 0xfff;
368 entry
->parent_tid
= buf
>> 12 & 0xfff;
369 entry
->bios_info
= buf
>> 24;
371 memcpy(&entry
->identity_tag
, dlct
, 8);
374 entry
->event_capabilities
= le32_to_cpu(*dlct
++);
376 /* add new devices, which are new in the LCT */
377 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
378 if (entry
->tid
== dev
->lct_data
.tid
) {
385 i2o_device_add(c
, entry
);
391 /* remove devices, which are not in the LCT anymore */
392 list_for_each_entry_safe(dev
, tmp
, &c
->devices
, list
) {
395 for (i
= 0; i
< max
; i
++) {
396 if (lct
->lct_entry
[i
].tid
== dev
->lct_data
.tid
) {
403 i2o_device_remove(dev
);
412 * Run time support routines
415 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
417 * This function can be used for all UtilParamsGet/Set operations.
418 * The OperationList is given in oplist-buffer,
419 * and results are returned in reslist-buffer.
420 * Note that the minimum sized reslist is 8 bytes and contains
421 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
423 int i2o_parm_issue(struct i2o_device
*i2o_dev
, int cmd
, void *oplist
,
424 int oplen
, void *reslist
, int reslen
)
426 struct i2o_message
*msg
;
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 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
440 i2o_dma_free(dev
, &res
);
446 cpu_to_le32(cmd
<< 24 | HOST_TID
<< 12 | i2o_dev
->lct_data
.tid
);
447 msg
->body
[i
++] = cpu_to_le32(0x00000000);
448 msg
->body
[i
++] = cpu_to_le32(0x4C000000 | oplen
); /* OperationList */
449 memcpy(&msg
->body
[i
], oplist
, oplen
);
450 i
+= (oplen
/ 4 + (oplen
% 4 ? 1 : 0));
451 msg
->body
[i
++] = cpu_to_le32(0xD0000000 | res
.len
); /* ResultList */
452 msg
->body
[i
++] = cpu_to_le32(res
.phys
);
455 cpu_to_le32(I2O_MESSAGE_SIZE(i
+ sizeof(struct i2o_message
) / 4) |
458 rc
= i2o_msg_post_wait_mem(c
, msg
, 10, &res
);
460 /* This only looks like a memory leak - don't "fix" it. */
461 if (rc
== -ETIMEDOUT
)
464 memcpy(reslist
, res
.virt
, res
.len
);
465 i2o_dma_free(dev
, &res
);
471 * Query one field group value or a whole scalar group.
473 int i2o_parm_field_get(struct i2o_device
*i2o_dev
, int group
, int field
,
474 void *buf
, int buflen
)
476 u32 opblk
[] = { cpu_to_le32(0x00000001),
477 cpu_to_le32((u16
) group
<< 16 | I2O_PARAMS_FIELD_GET
),
478 cpu_to_le32((s16
) field
<< 16 | 0x00000001)
480 u8
*resblk
; /* 8 bytes for header */
483 resblk
= kmalloc(buflen
+ 8, GFP_KERNEL
| GFP_ATOMIC
);
487 rc
= i2o_parm_issue(i2o_dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
488 sizeof(opblk
), resblk
, buflen
+ 8);
490 memcpy(buf
, resblk
+ 8, buflen
); /* cut off header */
498 * if oper == I2O_PARAMS_TABLE_GET, get from all rows
499 * if fieldcount == -1 return all fields
500 * ibuf and ibuflen are unused (use NULL, 0)
501 * else return specific fields
502 * ibuf contains fieldindexes
504 * if oper == I2O_PARAMS_LIST_GET, get from specific rows
505 * if fieldcount == -1 return all fields
506 * ibuf contains rowcount, keyvalues
507 * else return specific fields
508 * fieldcount is # of fieldindexes
509 * ibuf contains fieldindexes, rowcount, keyvalues
511 * You could also use directly function i2o_issue_params().
513 int i2o_parm_table_get(struct i2o_device
*dev
, int oper
, int group
,
514 int fieldcount
, void *ibuf
, int ibuflen
, void *resblk
,
522 size
+= 4 - size
% 4;
524 opblk
= kmalloc(size
, GFP_KERNEL
);
526 printk(KERN_ERR
"i2o: no memory for query buffer.\n");
530 opblk
[0] = 1; /* operation count */
531 opblk
[1] = 0; /* pad */
534 opblk
[4] = fieldcount
;
535 memcpy(opblk
+ 5, ibuf
, ibuflen
); /* other params */
537 size
= i2o_parm_issue(dev
, I2O_CMD_UTIL_PARAMS_GET
, opblk
,
538 size
, resblk
, reslen
);
547 EXPORT_SYMBOL(i2o_device_claim
);
548 EXPORT_SYMBOL(i2o_device_claim_release
);
549 EXPORT_SYMBOL(i2o_parm_field_get
);
550 EXPORT_SYMBOL(i2o_parm_table_get
);
551 EXPORT_SYMBOL(i2o_parm_issue
);