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("claim of device %d succeded\n", dev->lct_data.tid);
71 pr_debug("claim of device %d failed %d\n", dev->lct_data.tid,
80 * i2o_device_claim_release - release a device that the OSM is using
81 * @dev: device to release
82 * @drv: driver which claimed the device
84 * Drop a claim by an OSM on a given I2O device.
86 * AC - some devices seem to want to refuse an unclaim until they have
87 * finished internal processing. It makes sense since you don't want a
88 * new device to go reconfiguring the entire system until you are done.
89 * Thus we are prepared to wait briefly.
91 * Returns 0 on success or negative error code on failure.
93 int i2o_device_claim_release(struct i2o_device *dev)
101 * If the controller takes a nonblocking approach to
102 * releases we have to sleep/poll for a few times.
104 for (tries = 0; tries < 10; tries++) {
105 rc = i2o_device_issue_claim(dev, I2O_CMD_UTIL_RELEASE,
114 pr_debug("claim release of device %d succeded\n",
117 pr_debug("claim release of device %d failed %d\n",
118 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("Release I2O device %s\n", dev->bus_id);
142 * i2o_device_class_release - Remove I2O device attributes
143 * @cd: I2O class device which is added to the I2O device class
145 * Removes attributes from the I2O device again. Also search each device
146 * on the controller for I2O devices which refert to this device as parent
147 * or user and remove this links also.
149 static void i2o_device_class_release(struct class_device *cd)
151 struct i2o_device *i2o_dev, *tmp;
152 struct i2o_controller *c;
154 i2o_dev = to_i2o_device(cd->dev);
157 sysfs_remove_link(&i2o_dev->device.kobj, "parent");
158 sysfs_remove_link(&i2o_dev->device.kobj, "user");
160 list_for_each_entry(tmp, &c->devices, list) {
161 if (tmp->lct_data.parent_tid == i2o_dev->lct_data.tid)
162 sysfs_remove_link(&tmp->device.kobj, "parent");
163 if (tmp->lct_data.user_tid == i2o_dev->lct_data.tid)
164 sysfs_remove_link(&tmp->device.kobj, "user");
168 /* I2O device class */
169 static struct class i2o_device_class = {
170 .name = "i2o_device",
171 .release = i2o_device_class_release
175 * i2o_device_alloc - Allocate a I2O device and initialize it
177 * Allocate the memory for a I2O device and initialize locks and lists
179 * Returns the allocated I2O device or a negative error code if the device
180 * could not be allocated.
182 static struct i2o_device *i2o_device_alloc(void)
184 struct i2o_device *dev;
186 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
188 return ERR_PTR(-ENOMEM);
190 memset(dev, 0, sizeof(*dev));
192 INIT_LIST_HEAD(&dev->list);
193 init_MUTEX(&dev->lock);
195 dev->device.bus = &i2o_bus_type;
196 dev->device.release = &i2o_device_release;
197 dev->classdev.class = &i2o_device_class;
198 dev->classdev.dev = &dev->device;
204 * i2o_device_add - allocate a new I2O device and add it to the IOP
205 * @iop: I2O controller where the device is on
206 * @entry: LCT entry of the I2O device
208 * Allocate a new I2O device and initialize it with the LCT entry. The
209 * device is appended to the device list of the controller.
211 * Returns a pointer to the I2O device on success or negative error code
214 static struct i2o_device *i2o_device_add(struct i2o_controller *c,
215 i2o_lct_entry * entry)
217 struct i2o_device *dev;
219 dev = i2o_device_alloc();
221 printk(KERN_ERR "i2o: unable to allocate i2o device\n");
225 dev->lct_data = *entry;
227 snprintf(dev->device.bus_id, BUS_ID_SIZE, "%d:%03x", c->unit,
230 snprintf(dev->classdev.class_id, BUS_ID_SIZE, "%d:%03x", c->unit,
234 dev->device.parent = &c->device;
236 device_register(&dev->device);
238 list_add_tail(&dev->list, &c->devices);
240 class_device_register(&dev->classdev);
242 i2o_driver_notify_device_add_all(dev);
244 pr_debug("I2O device %s added\n", dev->device.bus_id);
250 * i2o_device_remove - remove an I2O device from the I2O core
251 * @dev: I2O device which should be released
253 * Is used on I2O controller removal or LCT modification, when the device
254 * is removed from the system. Note that the device could still hang
255 * around until the refcount reaches 0.
257 void i2o_device_remove(struct i2o_device *i2o_dev)
259 i2o_driver_notify_device_remove_all(i2o_dev);
260 class_device_unregister(&i2o_dev->classdev);
261 list_del(&i2o_dev->list);
262 device_unregister(&i2o_dev->device);
266 * i2o_device_parse_lct - Parse a previously fetched LCT and create devices
267 * @c: I2O controller from which the LCT should be parsed.
269 * The Logical Configuration Table tells us what we can talk to on the
270 * board. For every entry we create an I2O device, which is registered in
273 * Returns 0 on success or negative error code on failure.
275 int i2o_device_parse_lct(struct i2o_controller *c)
277 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("LCT has %d entries (LCT size: %d)\n", max, lct->table_size);
309 /* remove devices, which are not in the LCT anymore */
310 list_for_each_entry_safe(dev, tmp, &c->devices, list) {
313 for (i = 0; i < max; i++) {
314 if (lct->lct_entry[i].tid == dev->lct_data.tid) {
321 i2o_device_remove(dev);
324 /* add new devices, which are new in the LCT */
325 for (i = 0; i < max; i++) {
328 list_for_each_entry_safe(dev, tmp, &c->devices, list) {
329 if (lct->lct_entry[i].tid == dev->lct_data.tid) {
336 i2o_device_add(c, &lct->lct_entry[i]);
344 * i2o_device_class_show_class_id - Displays class id of I2O device
345 * @cd: class device of which the class id should be displayed
346 * @buf: buffer into which the class id should be printed
348 * Returns the number of bytes which are printed into the buffer.
350 static ssize_t i2o_device_class_show_class_id(struct class_device *cd,
353 struct i2o_device *dev = to_i2o_device(cd->dev);
355 sprintf(buf, "%03x\n", dev->lct_data.class_id);
356 return strlen(buf) + 1;
360 * i2o_device_class_show_tid - Displays TID of I2O device
361 * @cd: class device of which the TID should be displayed
362 * @buf: buffer into which the class id should be printed
364 * Returns the number of bytes which are printed into the buffer.
366 static ssize_t i2o_device_class_show_tid(struct class_device *cd, char *buf)
368 struct i2o_device *dev = to_i2o_device(cd->dev);
370 sprintf(buf, "%03x\n", dev->lct_data.tid);
371 return strlen(buf) + 1;
374 /* I2O device class attributes */
375 static CLASS_DEVICE_ATTR(class_id, S_IRUGO, i2o_device_class_show_class_id,
377 static CLASS_DEVICE_ATTR(tid, S_IRUGO, i2o_device_class_show_tid, NULL);
380 * i2o_device_class_add - Adds attributes to the I2O device
381 * @cd: I2O class device which is added to the I2O device class
383 * This function get called when a I2O device is added to the class. It
384 * creates the attributes for each device and creates user/parent symlink
387 * Returns 0 on success or negative error code on failure.
389 static int i2o_device_class_add(struct class_device *cd)
391 struct i2o_device *i2o_dev, *tmp;
392 struct i2o_controller *c;
394 i2o_dev = to_i2o_device(cd->dev);
397 class_device_create_file(cd, &class_device_attr_class_id);
398 class_device_create_file(cd, &class_device_attr_tid);
400 /* create user entries for this device */
401 tmp = i2o_iop_find_device(i2o_dev->iop, i2o_dev->lct_data.user_tid);
403 sysfs_create_link(&i2o_dev->device.kobj, &tmp->device.kobj,
406 /* create user entries refering to this device */
407 list_for_each_entry(tmp, &c->devices, list)
408 if (tmp->lct_data.user_tid == i2o_dev->lct_data.tid)
409 sysfs_create_link(&tmp->device.kobj,
410 &i2o_dev->device.kobj, "user");
412 /* create parent entries for this device */
413 tmp = i2o_iop_find_device(i2o_dev->iop, i2o_dev->lct_data.parent_tid);
415 sysfs_create_link(&i2o_dev->device.kobj, &tmp->device.kobj,
418 /* create parent entries refering to this device */
419 list_for_each_entry(tmp, &c->devices, list)
420 if (tmp->lct_data.parent_tid == i2o_dev->lct_data.tid)
421 sysfs_create_link(&tmp->device.kobj,
422 &i2o_dev->device.kobj, "parent");
427 /* I2O device class interface */
428 static struct class_interface i2o_device_class_interface = {
429 .class = &i2o_device_class,
430 .add = i2o_device_class_add
434 * Run time support routines
437 /* Issue UTIL_PARAMS_GET or UTIL_PARAMS_SET
439 * This function can be used for all UtilParamsGet/Set operations.
440 * The OperationList is given in oplist-buffer,
441 * and results are returned in reslist-buffer.
442 * Note that the minimum sized reslist is 8 bytes and contains
443 * ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
446 int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,
447 int oplen, void *reslist, int reslen)
449 struct i2o_message __iomem *msg;
451 u32 *res32 = (u32 *) reslist;
452 u32 *restmp = (u32 *) reslist;
457 struct i2o_controller *c = i2o_dev->iop;
458 struct device *dev = &c->pdev->dev;
462 if (i2o_dma_alloc(dev, &res, reslen, GFP_KERNEL))
465 m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);
466 if (m == I2O_QUEUE_EMPTY) {
467 i2o_dma_free(dev, &res);
472 writel(cmd << 24 | HOST_TID << 12 | i2o_dev->lct_data.tid,
474 writel(0, &msg->body[i++]);
475 writel(0x4C000000 | oplen, &msg->body[i++]); /* OperationList */
476 memcpy_toio(&msg->body[i], oplist, oplen);
477 i += (oplen / 4 + (oplen % 4 ? 1 : 0));
478 writel(0xD0000000 | res.len, &msg->body[i++]); /* ResultList */
479 writel(res.phys, &msg->body[i++]);
481 writel(I2O_MESSAGE_SIZE(i + sizeof(struct i2o_message) / 4) |
482 SGL_OFFSET_5, &msg->u.head[0]);
484 rc = i2o_msg_post_wait_mem(c, m, 10, &res);
486 /* This only looks like a memory leak - don't "fix" it. */
487 if (rc == -ETIMEDOUT)
490 memcpy_fromio(reslist, res.virt, res.len);
491 i2o_dma_free(dev, &res);
497 * Calculate number of bytes of Result LIST
498 * We need to loop through each Result BLOCK and grab the length
502 for (i = 0; i < (res32[0] & 0X0000FFFF); i++) {
503 if (restmp[0] & 0x00FF0000) { /* BlockStatus != SUCCESS */
505 "%s - Error:\n ErrorInfoSize = 0x%02x, "
506 "BlockStatus = 0x%02x, BlockSize = 0x%04x\n",
508 I2O_CMD_UTIL_PARAMS_SET) ? "PARAMS_SET" :
509 "PARAMS_GET", res32[1] >> 24,
510 (res32[1] >> 16) & 0xFF, res32[1] & 0xFFFF);
513 * If this is the only request,than we return an error
515 if ((res32[0] & 0x0000FFFF) == 1) {
516 return -((res32[1] >> 16) & 0xFF); /* -BlockStatus */
519 len += restmp[0] & 0x0000FFFF; /* Length of res BLOCK */
520 restmp += restmp[0] & 0x0000FFFF; /* Skip to next BLOCK */
522 return (len << 2); /* bytes used by result list */
526 * Query one field group value or a whole scalar group.
528 int i2o_parm_field_get(struct i2o_device *i2o_dev, int group, int field,
529 void *buf, int buflen)
531 u16 opblk[] = { 1, 0, I2O_PARAMS_FIELD_GET, group, 1, field };
532 u8 resblk[8 + buflen]; /* 8 bytes for header */
535 if (field == -1) /* whole group */
538 size = i2o_parm_issue(i2o_dev, I2O_CMD_UTIL_PARAMS_GET, opblk,
539 sizeof(opblk), resblk, sizeof(resblk));
541 memcpy(buf, resblk + 8, buflen); /* cut off header */
550 * if oper == I2O_PARAMS_TABLE_GET, get from all rows
551 * if fieldcount == -1 return all fields
552 * ibuf and ibuflen are unused (use NULL, 0)
553 * else return specific fields
554 * ibuf contains fieldindexes
556 * if oper == I2O_PARAMS_LIST_GET, get from specific rows
557 * if fieldcount == -1 return all fields
558 * ibuf contains rowcount, keyvalues
559 * else return specific fields
560 * fieldcount is # of fieldindexes
561 * ibuf contains fieldindexes, rowcount, keyvalues
563 * You could also use directly function i2o_issue_params().
565 int i2o_parm_table_get(struct i2o_device *dev, int oper, int group,
566 int fieldcount, void *ibuf, int ibuflen, void *resblk,
574 size += 4 - size % 4;
576 opblk = kmalloc(size, GFP_KERNEL);
578 printk(KERN_ERR "i2o: no memory for query buffer.\n");
582 opblk[0] = 1; /* operation count */
583 opblk[1] = 0; /* pad */
586 opblk[4] = fieldcount;
587 memcpy(opblk + 5, ibuf, ibuflen); /* other params */
589 size = i2o_parm_issue(dev, I2O_CMD_UTIL_PARAMS_GET, opblk,
590 size, resblk, reslen);
600 * i2o_device_init - Initialize I2O devices
602 * Registers the I2O device class.
604 * Returns 0 on success or negative error code on failure.
606 int i2o_device_init(void)
610 rc = class_register(&i2o_device_class);
614 return class_interface_register(&i2o_device_class_interface);
618 * i2o_device_exit - I2O devices exit function
620 * Unregisters the I2O device class.
622 void i2o_device_exit(void)
624 class_interface_register(&i2o_device_class_interface);
625 class_unregister(&i2o_device_class);
628 EXPORT_SYMBOL(i2o_device_claim);
629 EXPORT_SYMBOL(i2o_device_claim_release);
630 EXPORT_SYMBOL(i2o_parm_field_get);
631 EXPORT_SYMBOL(i2o_parm_table_get);
632 EXPORT_SYMBOL(i2o_parm_issue);