← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/message/i2o/iop.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/message/i2o/iop.c
 
1
/*
 
2
 *      Functions to handle I2O controllers and I2O message handling
 
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
 
14
 *      Red 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
 */
 
27
 
 
28
#include <linux/module.h>
 
29
#include <linux/i2o.h>
 
30
#include <linux/delay.h>
 
31
#include <linux/sched.h>
 
32
#include <linux/slab.h>
 
33
#include "core.h"
 
34
 
 
35
#define OSM_NAME        "i2o"
 
36
#define OSM_VERSION     "1.325"
 
37
#define OSM_DESCRIPTION "I2O subsystem"
 
38
 
 
39
/* global I2O controller list */
 
40
LIST_HEAD(i2o_controllers);
 
41
 
 
42
/*
 
43
 * global I2O System Table. Contains information about all the IOPs in the
 
44
 * system. Used to inform IOPs about each others existence.
 
45
 */
 
46
static struct i2o_dma i2o_systab;
 
47
 
 
48
static int i2o_hrt_get(struct i2o_controller *c);
 
49
 
 
50
/**
 
51
 *      i2o_msg_get_wait - obtain an I2O message from the IOP
 
52
 *      @c: I2O controller
 
53
 *      @wait: how long to wait until timeout
 
54
 *
 
55
 *      This function waits up to wait seconds for a message slot to be
 
56
 *      available.
 
57
 *
 
58
 *      On a success the message is returned and the pointer to the message is
 
59
 *      set in msg. The returned message is the physical page frame offset
 
60
 *      address from the read port (see the i2o spec). If no message is
 
61
 *      available returns I2O_QUEUE_EMPTY and msg is leaved untouched.
 
62
 */
 
63
struct i2o_message *i2o_msg_get_wait(struct i2o_controller *c, int wait)
 
64
{
 
65
        unsigned long timeout = jiffies + wait * HZ;
 
66
        struct i2o_message *msg;
 
67
 
 
68
        while (IS_ERR(msg = i2o_msg_get(c))) {
 
69
                if (time_after(jiffies, timeout)) {
 
70
                        osm_debug("%s: Timeout waiting for message frame.\n",
 
71
                                  c->name);
 
72
                        return ERR_PTR(-ETIMEDOUT);
 
73
                }
 
74
                schedule_timeout_uninterruptible(1);
 
75
        }
 
76
 
 
77
        return msg;
 
78
};
 
79
 
 
80
#if BITS_PER_LONG == 64
 
81
/**
 
82
 *      i2o_cntxt_list_add - Append a pointer to context list and return a id
 
83
 *      @c: controller to which the context list belong
 
84
 *      @ptr: pointer to add to the context list
 
85
 *
 
86
 *      Because the context field in I2O is only 32-bit large, on 64-bit the
 
87
 *      pointer is to large to fit in the context field. The i2o_cntxt_list
 
88
 *      functions therefore map pointers to context fields.
 
89
 *
 
90
 *      Returns context id > 0 on success or 0 on failure.
 
91
 */
 
92
u32 i2o_cntxt_list_add(struct i2o_controller * c, void *ptr)
 
93
{
 
94
        struct i2o_context_list_element *entry;
 
95
        unsigned long flags;
 
96
 
 
97
        if (!ptr)
 
98
                osm_err("%s: couldn't add NULL pointer to context list!\n",
 
99
                        c->name);
 
100
 
 
101
        entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 
102
        if (!entry) {
 
103
                osm_err("%s: Could not allocate memory for context list element"
 
104
                        "\n", c->name);
 
105
                return 0;
 
106
        }
 
107
 
 
108
        entry->ptr = ptr;
 
109
        entry->timestamp = jiffies;
 
110
        INIT_LIST_HEAD(&entry->list);
 
111
 
 
112
        spin_lock_irqsave(&c->context_list_lock, flags);
 
113
 
 
114
        if (unlikely(atomic_inc_and_test(&c->context_list_counter)))
 
115
                atomic_inc(&c->context_list_counter);
 
116
 
 
117
        entry->context = atomic_read(&c->context_list_counter);
 
118
 
 
119
        list_add(&entry->list, &c->context_list);
 
120
 
 
121
        spin_unlock_irqrestore(&c->context_list_lock, flags);
 
122
 
 
123
        osm_debug("%s: Add context to list %p -> %d\n", c->name, ptr, context);
 
124
 
 
125
        return entry->context;
 
126
};
 
127
 
 
128
/**
 
129
 *      i2o_cntxt_list_remove - Remove a pointer from the context list
 
130
 *      @c: controller to which the context list belong
 
131
 *      @ptr: pointer which should be removed from the context list
 
132
 *
 
133
 *      Removes a previously added pointer from the context list and returns
 
134
 *      the matching context id.
 
135
 *
 
136
 *      Returns context id on success or 0 on failure.
 
137
 */
 
138
u32 i2o_cntxt_list_remove(struct i2o_controller * c, void *ptr)
 
139
{
 
140
        struct i2o_context_list_element *entry;
 
141
        u32 context = 0;
 
142
        unsigned long flags;
 
143
 
 
144
        spin_lock_irqsave(&c->context_list_lock, flags);
 
145
        list_for_each_entry(entry, &c->context_list, list)
 
146
            if (entry->ptr == ptr) {
 
147
                list_del(&entry->list);
 
148
                context = entry->context;
 
149
                kfree(entry);
 
150
                break;
 
151
        }
 
152
        spin_unlock_irqrestore(&c->context_list_lock, flags);
 
153
 
 
154
        if (!context)
 
155
                osm_warn("%s: Could not remove nonexistent ptr %p\n", c->name,
 
156
                         ptr);
 
157
 
 
158
        osm_debug("%s: remove ptr from context list %d -> %p\n", c->name,
 
159
                  context, ptr);
 
160
 
 
161
        return context;
 
162
};
 
163
 
 
164
/**
 
165
 *      i2o_cntxt_list_get - Get a pointer from the context list and remove it
 
166
 *      @c: controller to which the context list belong
 
167
 *      @context: context id to which the pointer belong
 
168
 *
 
169
 *      Returns pointer to the matching context id on success or NULL on
 
170
 *      failure.
 
171
 */
 
172
void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
 
173
{
 
174
        struct i2o_context_list_element *entry;
 
175
        unsigned long flags;
 
176
        void *ptr = NULL;
 
177
 
 
178
        spin_lock_irqsave(&c->context_list_lock, flags);
 
179
        list_for_each_entry(entry, &c->context_list, list)
 
180
            if (entry->context == context) {
 
181
                list_del(&entry->list);
 
182
                ptr = entry->ptr;
 
183
                kfree(entry);
 
184
                break;
 
185
        }
 
186
        spin_unlock_irqrestore(&c->context_list_lock, flags);
 
187
 
 
188
        if (!ptr)
 
189
                osm_warn("%s: context id %d not found\n", c->name, context);
 
190
 
 
191
        osm_debug("%s: get ptr from context list %d -> %p\n", c->name, context,
 
192
                  ptr);
 
193
 
 
194
        return ptr;
 
195
};
 
196
 
 
197
/**
 
198
 *      i2o_cntxt_list_get_ptr - Get a context id from the context list
 
199
 *      @c: controller to which the context list belong
 
200
 *      @ptr: pointer to which the context id should be fetched
 
201
 *
 
202
 *      Returns context id which matches to the pointer on success or 0 on
 
203
 *      failure.
 
204
 */
 
205
u32 i2o_cntxt_list_get_ptr(struct i2o_controller * c, void *ptr)
 
206
{
 
207
        struct i2o_context_list_element *entry;
 
208
        u32 context = 0;
 
209
        unsigned long flags;
 
210
 
 
211
        spin_lock_irqsave(&c->context_list_lock, flags);
 
212
        list_for_each_entry(entry, &c->context_list, list)
 
213
            if (entry->ptr == ptr) {
 
214
                context = entry->context;
 
215
                break;
 
216
        }
 
217
        spin_unlock_irqrestore(&c->context_list_lock, flags);
 
218
 
 
219
        if (!context)
 
220
                osm_warn("%s: Could not find nonexistent ptr %p\n", c->name,
 
221
                         ptr);
 
222
 
 
223
        osm_debug("%s: get context id from context list %p -> %d\n", c->name,
 
224
                  ptr, context);
 
225
 
 
226
        return context;
 
227
};
 
228
#endif
 
229
 
 
230
/**
 
231
 *      i2o_iop_find - Find an I2O controller by id
 
232
 *      @unit: unit number of the I2O controller to search for
 
233
 *
 
234
 *      Lookup the I2O controller on the controller list.
 
235
 *
 
236
 *      Returns pointer to the I2O controller on success or NULL if not found.
 
237
 */
 
238
struct i2o_controller *i2o_find_iop(int unit)
 
239
{
 
240
        struct i2o_controller *c;
 
241
 
 
242
        list_for_each_entry(c, &i2o_controllers, list) {
 
243
                if (c->unit == unit)
 
244
                        return c;
 
245
        }
 
246
 
 
247
        return NULL;
 
248
};
 
249
 
 
250
/**
 
251
 *      i2o_iop_find_device - Find a I2O device on an I2O controller
 
252
 *      @c: I2O controller where the I2O device hangs on
 
253
 *      @tid: TID of the I2O device to search for
 
254
 *
 
255
 *      Searches the devices of the I2O controller for a device with TID tid and
 
256
 *      returns it.
 
257
 *
 
258
 *      Returns a pointer to the I2O device if found, otherwise NULL.
 
259
 */
 
260
struct i2o_device *i2o_iop_find_device(struct i2o_controller *c, u16 tid)
 
261
{
 
262
        struct i2o_device *dev;
 
263
 
 
264
        list_for_each_entry(dev, &c->devices, list)
 
265
            if (dev->lct_data.tid == tid)
 
266
                return dev;
 
267
 
 
268
        return NULL;
 
269
};
 
270
 
 
271
/**
 
272
 *      i2o_quiesce_controller - quiesce controller
 
273
 *      @c: controller
 
274
 *
 
275
 *      Quiesce an IOP. Causes IOP to make external operation quiescent
 
276
 *      (i2o 'READY' state). Internal operation of the IOP continues normally.
 
277
 *
 
278
 *      Returns 0 on success or negative error code on failure.
 
279
 */
 
280
static int i2o_iop_quiesce(struct i2o_controller *c)
 
281
{
 
282
        struct i2o_message *msg;
 
283
        i2o_status_block *sb = c->status_block.virt;
 
284
        int rc;
 
285
 
 
286
        i2o_status_get(c);
 
287
 
 
288
        /* SysQuiesce discarded if IOP not in READY or OPERATIONAL state */
 
289
        if ((sb->iop_state != ADAPTER_STATE_READY) &&
 
290
            (sb->iop_state != ADAPTER_STATE_OPERATIONAL))
 
291
                return 0;
 
292
 
 
293
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
294
        if (IS_ERR(msg))
 
295
                return PTR_ERR(msg);
 
296
 
 
297
        msg->u.head[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0);
 
298
        msg->u.head[1] =
 
299
            cpu_to_le32(I2O_CMD_SYS_QUIESCE << 24 | HOST_TID << 12 |
 
300
                        ADAPTER_TID);
 
301
 
 
302
        /* Long timeout needed for quiesce if lots of devices */
 
303
        if ((rc = i2o_msg_post_wait(c, msg, 240)))
 
304
                osm_info("%s: Unable to quiesce (status=%#x).\n", c->name, -rc);
 
305
        else
 
306
                osm_debug("%s: Quiesced.\n", c->name);
 
307
 
 
308
        i2o_status_get(c);      // Entered READY state
 
309
 
 
310
        return rc;
 
311
};
 
312
 
 
313
/**
 
314
 *      i2o_iop_enable - move controller from ready to OPERATIONAL
 
315
 *      @c: I2O controller
 
316
 *
 
317
 *      Enable IOP. This allows the IOP to resume external operations and
 
318
 *      reverses the effect of a quiesce. Returns zero or an error code if
 
319
 *      an error occurs.
 
320
 */
 
321
static int i2o_iop_enable(struct i2o_controller *c)
 
322
{
 
323
        struct i2o_message *msg;
 
324
        i2o_status_block *sb = c->status_block.virt;
 
325
        int rc;
 
326
 
 
327
        i2o_status_get(c);
 
328
 
 
329
        /* Enable only allowed on READY state */
 
330
        if (sb->iop_state != ADAPTER_STATE_READY)
 
331
                return -EINVAL;
 
332
 
 
333
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
334
        if (IS_ERR(msg))
 
335
                return PTR_ERR(msg);
 
336
 
 
337
        msg->u.head[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0);
 
338
        msg->u.head[1] =
 
339
            cpu_to_le32(I2O_CMD_SYS_ENABLE << 24 | HOST_TID << 12 |
 
340
                        ADAPTER_TID);
 
341
 
 
342
        /* How long of a timeout do we need? */
 
343
        if ((rc = i2o_msg_post_wait(c, msg, 240)))
 
344
                osm_err("%s: Could not enable (status=%#x).\n", c->name, -rc);
 
345
        else
 
346
                osm_debug("%s: Enabled.\n", c->name);
 
347
 
 
348
        i2o_status_get(c);      // entered OPERATIONAL state
 
349
 
 
350
        return rc;
 
351
};
 
352
 
 
353
/**
 
354
 *      i2o_iop_quiesce_all - Quiesce all I2O controllers on the system
 
355
 *
 
356
 *      Quiesce all I2O controllers which are connected to the system.
 
357
 */
 
358
static inline void i2o_iop_quiesce_all(void)
 
359
{
 
360
        struct i2o_controller *c, *tmp;
 
361
 
 
362
        list_for_each_entry_safe(c, tmp, &i2o_controllers, list) {
 
363
                if (!c->no_quiesce)
 
364
                        i2o_iop_quiesce(c);
 
365
        }
 
366
};
 
367
 
 
368
/**
 
369
 *      i2o_iop_enable_all - Enables all controllers on the system
 
370
 *
 
371
 *      Enables all I2O controllers which are connected to the system.
 
372
 */
 
373
static inline void i2o_iop_enable_all(void)
 
374
{
 
375
        struct i2o_controller *c, *tmp;
 
376
 
 
377
        list_for_each_entry_safe(c, tmp, &i2o_controllers, list)
 
378
            i2o_iop_enable(c);
 
379
};
 
380
 
 
381
/**
 
382
 *      i2o_clear_controller - Bring I2O controller into HOLD state
 
383
 *      @c: controller
 
384
 *
 
385
 *      Clear an IOP to HOLD state, ie. terminate external operations, clear all
 
386
 *      input queues and prepare for a system restart. IOP's internal operation
 
387
 *      continues normally and the outbound queue is alive. The IOP is not
 
388
 *      expected to rebuild its LCT.
 
389
 *
 
390
 *      Returns 0 on success or negative error code on failure.
 
391
 */
 
392
static int i2o_iop_clear(struct i2o_controller *c)
 
393
{
 
394
        struct i2o_message *msg;
 
395
        int rc;
 
396
 
 
397
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
398
        if (IS_ERR(msg))
 
399
                return PTR_ERR(msg);
 
400
 
 
401
        /* Quiesce all IOPs first */
 
402
        i2o_iop_quiesce_all();
 
403
 
 
404
        msg->u.head[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0);
 
405
        msg->u.head[1] =
 
406
            cpu_to_le32(I2O_CMD_ADAPTER_CLEAR << 24 | HOST_TID << 12 |
 
407
                        ADAPTER_TID);
 
408
 
 
409
        if ((rc = i2o_msg_post_wait(c, msg, 30)))
 
410
                osm_info("%s: Unable to clear (status=%#x).\n", c->name, -rc);
 
411
        else
 
412
                osm_debug("%s: Cleared.\n", c->name);
 
413
 
 
414
        /* Enable all IOPs */
 
415
        i2o_iop_enable_all();
 
416
 
 
417
        return rc;
 
418
}
 
419
 
 
420
/**
 
421
 *      i2o_iop_init_outbound_queue - setup the outbound message queue
 
422
 *      @c: I2O controller
 
423
 *
 
424
 *      Clear and (re)initialize IOP's outbound queue and post the message
 
425
 *      frames to the IOP.
 
426
 *
 
427
 *      Returns 0 on success or negative error code on failure.
 
428
 */
 
429
static int i2o_iop_init_outbound_queue(struct i2o_controller *c)
 
430
{
 
431
        u32 m;
 
432
        volatile u8 *status = c->status.virt;
 
433
        struct i2o_message *msg;
 
434
        ulong timeout;
 
435
        int i;
 
436
 
 
437
        osm_debug("%s: Initializing Outbound Queue...\n", c->name);
 
438
 
 
439
        memset(c->status.virt, 0, 4);
 
440
 
 
441
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
442
        if (IS_ERR(msg))
 
443
                return PTR_ERR(msg);
 
444
 
 
445
        msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);
 
446
        msg->u.head[1] =
 
447
            cpu_to_le32(I2O_CMD_OUTBOUND_INIT << 24 | HOST_TID << 12 |
 
448
                        ADAPTER_TID);
 
449
        msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
 
450
        msg->u.s.tcntxt = cpu_to_le32(0x00000000);
 
451
        msg->body[0] = cpu_to_le32(PAGE_SIZE);
 
452
        /* Outbound msg frame size in words and Initcode */
 
453
        msg->body[1] = cpu_to_le32(I2O_OUTBOUND_MSG_FRAME_SIZE << 16 | 0x80);
 
454
        msg->body[2] = cpu_to_le32(0xd0000004);
 
455
        msg->body[3] = cpu_to_le32(i2o_dma_low(c->status.phys));
 
456
        msg->body[4] = cpu_to_le32(i2o_dma_high(c->status.phys));
 
457
 
 
458
        i2o_msg_post(c, msg);
 
459
 
 
460
        timeout = jiffies + I2O_TIMEOUT_INIT_OUTBOUND_QUEUE * HZ;
 
461
        while (*status <= I2O_CMD_IN_PROGRESS) {
 
462
                if (time_after(jiffies, timeout)) {
 
463
                        osm_warn("%s: Timeout Initializing\n", c->name);
 
464
                        return -ETIMEDOUT;
 
465
                }
 
466
                schedule_timeout_uninterruptible(1);
 
467
        }
 
468
 
 
469
        m = c->out_queue.phys;
 
470
 
 
471
        /* Post frames */
 
472
        for (i = 0; i < I2O_MAX_OUTBOUND_MSG_FRAMES; i++) {
 
473
                i2o_flush_reply(c, m);
 
474
                udelay(1);      /* Promise */
 
475
                m += I2O_OUTBOUND_MSG_FRAME_SIZE * sizeof(u32);
 
476
        }
 
477
 
 
478
        return 0;
 
479
}
 
480
 
 
481
/**
 
482
 *      i2o_iop_reset - reset an I2O controller
 
483
 *      @c: controller to reset
 
484
 *
 
485
 *      Reset the IOP into INIT state and wait until IOP gets into RESET state.
 
486
 *      Terminate all external operations, clear IOP's inbound and outbound
 
487
 *      queues, terminate all DDMs, and reload the IOP's operating environment
 
488
 *      and all local DDMs. The IOP rebuilds its LCT.
 
489
 */
 
490
static int i2o_iop_reset(struct i2o_controller *c)
 
491
{
 
492
        volatile u8 *status = c->status.virt;
 
493
        struct i2o_message *msg;
 
494
        unsigned long timeout;
 
495
        i2o_status_block *sb = c->status_block.virt;
 
496
        int rc = 0;
 
497
 
 
498
        osm_debug("%s: Resetting controller\n", c->name);
 
499
 
 
500
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
501
        if (IS_ERR(msg))
 
502
                return PTR_ERR(msg);
 
503
 
 
504
        memset(c->status_block.virt, 0, 8);
 
505
 
 
506
        /* Quiesce all IOPs first */
 
507
        i2o_iop_quiesce_all();
 
508
 
 
509
        msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_0);
 
510
        msg->u.head[1] =
 
511
            cpu_to_le32(I2O_CMD_ADAPTER_RESET << 24 | HOST_TID << 12 |
 
512
                        ADAPTER_TID);
 
513
        msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
 
514
        msg->u.s.tcntxt = cpu_to_le32(0x00000000);
 
515
        msg->body[0] = cpu_to_le32(0x00000000);
 
516
        msg->body[1] = cpu_to_le32(0x00000000);
 
517
        msg->body[2] = cpu_to_le32(i2o_dma_low(c->status.phys));
 
518
        msg->body[3] = cpu_to_le32(i2o_dma_high(c->status.phys));
 
519
 
 
520
        i2o_msg_post(c, msg);
 
521
 
 
522
        /* Wait for a reply */
 
523
        timeout = jiffies + I2O_TIMEOUT_RESET * HZ;
 
524
        while (!*status) {
 
525
                if (time_after(jiffies, timeout))
 
526
                        break;
 
527
 
 
528
                schedule_timeout_uninterruptible(1);
 
529
        }
 
530
 
 
531
        switch (*status) {
 
532
        case I2O_CMD_REJECTED:
 
533
                osm_warn("%s: IOP reset rejected\n", c->name);
 
534
                rc = -EPERM;
 
535
                break;
 
536
 
 
537
        case I2O_CMD_IN_PROGRESS:
 
538
                /*
 
539
                 * Once the reset is sent, the IOP goes into the INIT state
 
540
                 * which is indeterminate. We need to wait until the IOP has
 
541
                 * rebooted before we can let the system talk to it. We read
 
542
                 * the inbound Free_List until a message is available. If we
 
543
                 * can't read one in the given amount of time, we assume the
 
544
                 * IOP could not reboot properly.
 
545
                 */
 
546
                osm_debug("%s: Reset in progress, waiting for reboot...\n",
 
547
                          c->name);
 
548
 
 
549
                while (IS_ERR(msg = i2o_msg_get_wait(c, I2O_TIMEOUT_RESET))) {
 
550
                        if (time_after(jiffies, timeout)) {
 
551
                                osm_err("%s: IOP reset timeout.\n", c->name);
 
552
                                rc = PTR_ERR(msg);
 
553
                                goto exit;
 
554
                        }
 
555
                        schedule_timeout_uninterruptible(1);
 
556
                }
 
557
                i2o_msg_nop(c, msg);
 
558
 
 
559
                /* from here all quiesce commands are safe */
 
560
                c->no_quiesce = 0;
 
561
 
 
562
                /* verify if controller is in state RESET */
 
563
                i2o_status_get(c);
 
564
 
 
565
                if (!c->promise && (sb->iop_state != ADAPTER_STATE_RESET))
 
566
                        osm_warn("%s: reset completed, but adapter not in RESET"
 
567
                                 " state.\n", c->name);
 
568
                else
 
569
                        osm_debug("%s: reset completed.\n", c->name);
 
570
 
 
571
                break;
 
572
 
 
573
        default:
 
574
                osm_err("%s: IOP reset timeout.\n", c->name);
 
575
                rc = -ETIMEDOUT;
 
576
                break;
 
577
        }
 
578
 
 
579
      exit:
 
580
        /* Enable all IOPs */
 
581
        i2o_iop_enable_all();
 
582
 
 
583
        return rc;
 
584
};
 
585
 
 
586
/**
 
587
 *      i2o_iop_activate - Bring controller up to HOLD
 
588
 *      @c: controller
 
589
 *
 
590
 *      This function brings an I2O controller into HOLD state. The adapter
 
591
 *      is reset if necessary and then the queues and resource table are read.
 
592
 *
 
593
 *      Returns 0 on success or negative error code on failure.
 
594
 */
 
595
static int i2o_iop_activate(struct i2o_controller *c)
 
596
{
 
597
        i2o_status_block *sb = c->status_block.virt;
 
598
        int rc;
 
599
        int state;
 
600
 
 
601
        /* In INIT state, Wait Inbound Q to initialize (in i2o_status_get) */
 
602
        /* In READY state, Get status */
 
603
 
 
604
        rc = i2o_status_get(c);
 
605
        if (rc) {
 
606
                osm_info("%s: Unable to obtain status, attempting a reset.\n",
 
607
                         c->name);
 
608
                rc = i2o_iop_reset(c);
 
609
                if (rc)
 
610
                        return rc;
 
611
        }
 
612
 
 
613
        if (sb->i2o_version > I2OVER15) {
 
614
                osm_err("%s: Not running version 1.5 of the I2O Specification."
 
615
                        "\n", c->name);
 
616
                return -ENODEV;
 
617
        }
 
618
 
 
619
        switch (sb->iop_state) {
 
620
        case ADAPTER_STATE_FAULTED:
 
621
                osm_err("%s: hardware fault\n", c->name);
 
622
                return -EFAULT;
 
623
 
 
624
        case ADAPTER_STATE_READY:
 
625
        case ADAPTER_STATE_OPERATIONAL:
 
626
        case ADAPTER_STATE_HOLD:
 
627
        case ADAPTER_STATE_FAILED:
 
628
                osm_debug("%s: already running, trying to reset...\n", c->name);
 
629
                rc = i2o_iop_reset(c);
 
630
                if (rc)
 
631
                        return rc;
 
632
        }
 
633
 
 
634
        /* preserve state */
 
635
        state = sb->iop_state;
 
636
 
 
637
        rc = i2o_iop_init_outbound_queue(c);
 
638
        if (rc)
 
639
                return rc;
 
640
 
 
641
        /* if adapter was not in RESET state clear now */
 
642
        if (state != ADAPTER_STATE_RESET)
 
643
                i2o_iop_clear(c);
 
644
 
 
645
        i2o_status_get(c);
 
646
 
 
647
        if (sb->iop_state != ADAPTER_STATE_HOLD) {
 
648
                osm_err("%s: failed to bring IOP into HOLD state\n", c->name);
 
649
                return -EIO;
 
650
        }
 
651
 
 
652
        return i2o_hrt_get(c);
 
653
};
 
654
 
 
655
/**
 
656
 *      i2o_iop_systab_set - Set the I2O System Table of the specified IOP
 
657
 *      @c: I2O controller to which the system table should be send
 
658
 *
 
659
 *      Before the systab could be set i2o_systab_build() must be called.
 
660
 *
 
661
 *      Returns 0 on success or negative error code on failure.
 
662
 */
 
663
static int i2o_iop_systab_set(struct i2o_controller *c)
 
664
{
 
665
        struct i2o_message *msg;
 
666
        i2o_status_block *sb = c->status_block.virt;
 
667
        struct device *dev = &c->pdev->dev;
 
668
        struct resource *root;
 
669
        int rc;
 
670
 
 
671
        if (sb->current_mem_size < sb->desired_mem_size) {
 
672
                struct resource *res = &c->mem_resource;
 
673
                res->name = c->pdev->bus->name;
 
674
                res->flags = IORESOURCE_MEM;
 
675
                res->start = 0;
 
676
                res->end = 0;
 
677
                osm_info("%s: requires private memory resources.\n", c->name);
 
678
                root = pci_find_parent_resource(c->pdev, res);
 
679
                if (root == NULL)
 
680
                        osm_warn("%s: Can't find parent resource!\n", c->name);
 
681
                if (root && allocate_resource(root, res, sb->desired_mem_size, sb->desired_mem_size, sb->desired_mem_size, 1 << 20,     /* Unspecified, so use 1Mb and play safe */
 
682
                                              NULL, NULL) >= 0) {
 
683
                        c->mem_alloc = 1;
 
684
                        sb->current_mem_size = resource_size(res);
 
685
                        sb->current_mem_base = res->start;
 
686
                        osm_info("%s: allocated %llu bytes of PCI memory at "
 
687
                                "0x%016llX.\n", c->name,
 
688
                                (unsigned long long)resource_size(res),
 
689
                                (unsigned long long)res->start);
 
690
                }
 
691
        }
 
692
 
 
693
        if (sb->current_io_size < sb->desired_io_size) {
 
694
                struct resource *res = &c->io_resource;
 
695
                res->name = c->pdev->bus->name;
 
696
                res->flags = IORESOURCE_IO;
 
697
                res->start = 0;
 
698
                res->end = 0;
 
699
                osm_info("%s: requires private memory resources.\n", c->name);
 
700
                root = pci_find_parent_resource(c->pdev, res);
 
701
                if (root == NULL)
 
702
                        osm_warn("%s: Can't find parent resource!\n", c->name);
 
703
                if (root && allocate_resource(root, res, sb->desired_io_size, sb->desired_io_size, sb->desired_io_size, 1 << 20,        /* Unspecified, so use 1Mb and play safe */
 
704
                                              NULL, NULL) >= 0) {
 
705
                        c->io_alloc = 1;
 
706
                        sb->current_io_size = resource_size(res);
 
707
                        sb->current_mem_base = res->start;
 
708
                        osm_info("%s: allocated %llu bytes of PCI I/O at "
 
709
                                "0x%016llX.\n", c->name,
 
710
                                (unsigned long long)resource_size(res),
 
711
                                (unsigned long long)res->start);
 
712
                }
 
713
        }
 
714
 
 
715
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
716
        if (IS_ERR(msg))
 
717
                return PTR_ERR(msg);
 
718
 
 
719
        i2o_systab.phys = dma_map_single(dev, i2o_systab.virt, i2o_systab.len,
 
720
                                         PCI_DMA_TODEVICE);
 
721
        if (!i2o_systab.phys) {
 
722
                i2o_msg_nop(c, msg);
 
723
                return -ENOMEM;
 
724
        }
 
725
 
 
726
        msg->u.head[0] = cpu_to_le32(I2O_MESSAGE_SIZE(12) | SGL_OFFSET_6);
 
727
        msg->u.head[1] =
 
728
            cpu_to_le32(I2O_CMD_SYS_TAB_SET << 24 | HOST_TID << 12 |
 
729
                        ADAPTER_TID);
 
730
 
 
731
        /*
 
732
         * Provide three SGL-elements:
 
733
         * System table (SysTab), Private memory space declaration and
 
734
         * Private i/o space declaration
 
735
         */
 
736
 
 
737
        msg->body[0] = cpu_to_le32(c->unit + 2);
 
738
        msg->body[1] = cpu_to_le32(0x00000000);
 
739
        msg->body[2] = cpu_to_le32(0x54000000 | i2o_systab.len);
 
740
        msg->body[3] = cpu_to_le32(i2o_systab.phys);
 
741
        msg->body[4] = cpu_to_le32(0x54000000 | sb->current_mem_size);
 
742
        msg->body[5] = cpu_to_le32(sb->current_mem_base);
 
743
        msg->body[6] = cpu_to_le32(0xd4000000 | sb->current_io_size);
 
744
        msg->body[6] = cpu_to_le32(sb->current_io_base);
 
745
 
 
746
        rc = i2o_msg_post_wait(c, msg, 120);
 
747
 
 
748
        dma_unmap_single(dev, i2o_systab.phys, i2o_systab.len,
 
749
                         PCI_DMA_TODEVICE);
 
750
 
 
751
        if (rc < 0)
 
752
                osm_err("%s: Unable to set SysTab (status=%#x).\n", c->name,
 
753
                        -rc);
 
754
        else
 
755
                osm_debug("%s: SysTab set.\n", c->name);
 
756
 
 
757
        return rc;
 
758
}
 
759
 
 
760
/**
 
761
 *      i2o_iop_online - Bring a controller online into OPERATIONAL state.
 
762
 *      @c: I2O controller
 
763
 *
 
764
 *      Send the system table and enable the I2O controller.
 
765
 *
 
766
 *      Returns 0 on success or negative error code on failure.
 
767
 */
 
768
static int i2o_iop_online(struct i2o_controller *c)
 
769
{
 
770
        int rc;
 
771
 
 
772
        rc = i2o_iop_systab_set(c);
 
773
        if (rc)
 
774
                return rc;
 
775
 
 
776
        /* In READY state */
 
777
        osm_debug("%s: Attempting to enable...\n", c->name);
 
778
        rc = i2o_iop_enable(c);
 
779
        if (rc)
 
780
                return rc;
 
781
 
 
782
        return 0;
 
783
};
 
784
 
 
785
/**
 
786
 *      i2o_iop_remove - Remove the I2O controller from the I2O core
 
787
 *      @c: I2O controller
 
788
 *
 
789
 *      Remove the I2O controller from the I2O core. If devices are attached to
 
790
 *      the controller remove these also and finally reset the controller.
 
791
 */
 
792
void i2o_iop_remove(struct i2o_controller *c)
 
793
{
 
794
        struct i2o_device *dev, *tmp;
 
795
 
 
796
        osm_debug("%s: deleting controller\n", c->name);
 
797
 
 
798
        i2o_driver_notify_controller_remove_all(c);
 
799
 
 
800
        list_del(&c->list);
 
801
 
 
802
        list_for_each_entry_safe(dev, tmp, &c->devices, list)
 
803
            i2o_device_remove(dev);
 
804
 
 
805
        device_del(&c->device);
 
806
 
 
807
        /* Ask the IOP to switch to RESET state */
 
808
        i2o_iop_reset(c);
 
809
}
 
810
 
 
811
/**
 
812
 *      i2o_systab_build - Build system table
 
813
 *
 
814
 *      The system table contains information about all the IOPs in the system
 
815
 *      (duh) and is used by the Executives on the IOPs to establish peer2peer
 
816
 *      connections. We're not supporting peer2peer at the moment, but this
 
817
 *      will be needed down the road for things like lan2lan forwarding.
 
818
 *
 
819
 *      Returns 0 on success or negative error code on failure.
 
820
 */
 
821
static int i2o_systab_build(void)
 
822
{
 
823
        struct i2o_controller *c, *tmp;
 
824
        int num_controllers = 0;
 
825
        u32 change_ind = 0;
 
826
        int count = 0;
 
827
        struct i2o_sys_tbl *systab = i2o_systab.virt;
 
828
 
 
829
        list_for_each_entry_safe(c, tmp, &i2o_controllers, list)
 
830
            num_controllers++;
 
831
 
 
832
        if (systab) {
 
833
                change_ind = systab->change_ind;
 
834
                kfree(i2o_systab.virt);
 
835
        }
 
836
 
 
837
        /* Header + IOPs */
 
838
        i2o_systab.len = sizeof(struct i2o_sys_tbl) + num_controllers *
 
839
            sizeof(struct i2o_sys_tbl_entry);
 
840
 
 
841
        systab = i2o_systab.virt = kzalloc(i2o_systab.len, GFP_KERNEL);
 
842
        if (!systab) {
 
843
                osm_err("unable to allocate memory for System Table\n");
 
844
                return -ENOMEM;
 
845
        }
 
846
 
 
847
        systab->version = I2OVERSION;
 
848
        systab->change_ind = change_ind + 1;
 
849
 
 
850
        list_for_each_entry_safe(c, tmp, &i2o_controllers, list) {
 
851
                i2o_status_block *sb;
 
852
 
 
853
                if (count >= num_controllers) {
 
854
                        osm_err("controller added while building system table"
 
855
                                "\n");
 
856
                        break;
 
857
                }
 
858
 
 
859
                sb = c->status_block.virt;
 
860
 
 
861
                /*
 
862
                 * Get updated IOP state so we have the latest information
 
863
                 *
 
864
                 * We should delete the controller at this point if it
 
865
                 * doesn't respond since if it's not on the system table
 
866
                 * it is techninically not part of the I2O subsystem...
 
867
                 */
 
868
                if (unlikely(i2o_status_get(c))) {
 
869
                        osm_err("%s: Deleting b/c could not get status while "
 
870
                                "attempting to build system table\n", c->name);
 
871
                        i2o_iop_remove(c);
 
872
                        continue;       // try the next one
 
873
                }
 
874
 
 
875
                systab->iops[count].org_id = sb->org_id;
 
876
                systab->iops[count].iop_id = c->unit + 2;
 
877
                systab->iops[count].seg_num = 0;
 
878
                systab->iops[count].i2o_version = sb->i2o_version;
 
879
                systab->iops[count].iop_state = sb->iop_state;
 
880
                systab->iops[count].msg_type = sb->msg_type;
 
881
                systab->iops[count].frame_size = sb->inbound_frame_size;
 
882
                systab->iops[count].last_changed = change_ind;
 
883
                systab->iops[count].iop_capabilities = sb->iop_capabilities;
 
884
                systab->iops[count].inbound_low =
 
885
                    i2o_dma_low(c->base.phys + I2O_IN_PORT);
 
886
                systab->iops[count].inbound_high =
 
887
                    i2o_dma_high(c->base.phys + I2O_IN_PORT);
 
888
 
 
889
                count++;
 
890
        }
 
891
 
 
892
        systab->num_entries = count;
 
893
 
 
894
        return 0;
 
895
};
 
896
 
 
897
/**
 
898
 *      i2o_parse_hrt - Parse the hardware resource table.
 
899
 *      @c: I2O controller
 
900
 *
 
901
 *      We don't do anything with it except dumping it (in debug mode).
 
902
 *
 
903
 *      Returns 0.
 
904
 */
 
905
static int i2o_parse_hrt(struct i2o_controller *c)
 
906
{
 
907
        i2o_dump_hrt(c);
 
908
        return 0;
 
909
};
 
910
 
 
911
/**
 
912
 *      i2o_status_get - Get the status block from the I2O controller
 
913
 *      @c: I2O controller
 
914
 *
 
915
 *      Issue a status query on the controller. This updates the attached
 
916
 *      status block. The status block could then be accessed through
 
917
 *      c->status_block.
 
918
 *
 
919
 *      Returns 0 on success or negative error code on failure.
 
920
 */
 
921
int i2o_status_get(struct i2o_controller *c)
 
922
{
 
923
        struct i2o_message *msg;
 
924
        volatile u8 *status_block;
 
925
        unsigned long timeout;
 
926
 
 
927
        status_block = (u8 *) c->status_block.virt;
 
928
        memset(c->status_block.virt, 0, sizeof(i2o_status_block));
 
929
 
 
930
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
931
        if (IS_ERR(msg))
 
932
                return PTR_ERR(msg);
 
933
 
 
934
        msg->u.head[0] = cpu_to_le32(NINE_WORD_MSG_SIZE | SGL_OFFSET_0);
 
935
        msg->u.head[1] =
 
936
            cpu_to_le32(I2O_CMD_STATUS_GET << 24 | HOST_TID << 12 |
 
937
                        ADAPTER_TID);
 
938
        msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);
 
939
        msg->u.s.tcntxt = cpu_to_le32(0x00000000);
 
940
        msg->body[0] = cpu_to_le32(0x00000000);
 
941
        msg->body[1] = cpu_to_le32(0x00000000);
 
942
        msg->body[2] = cpu_to_le32(i2o_dma_low(c->status_block.phys));
 
943
        msg->body[3] = cpu_to_le32(i2o_dma_high(c->status_block.phys));
 
944
        msg->body[4] = cpu_to_le32(sizeof(i2o_status_block));   /* always 88 bytes */
 
945
 
 
946
        i2o_msg_post(c, msg);
 
947
 
 
948
        /* Wait for a reply */
 
949
        timeout = jiffies + I2O_TIMEOUT_STATUS_GET * HZ;
 
950
        while (status_block[87] != 0xFF) {
 
951
                if (time_after(jiffies, timeout)) {
 
952
                        osm_err("%s: Get status timeout.\n", c->name);
 
953
                        return -ETIMEDOUT;
 
954
                }
 
955
 
 
956
                schedule_timeout_uninterruptible(1);
 
957
        }
 
958
 
 
959
#ifdef DEBUG
 
960
        i2o_debug_state(c);
 
961
#endif
 
962
 
 
963
        return 0;
 
964
}
 
965
 
 
966
/*
 
967
 *      i2o_hrt_get - Get the Hardware Resource Table from the I2O controller
 
968
 *      @c: I2O controller from which the HRT should be fetched
 
969
 *
 
970
 *      The HRT contains information about possible hidden devices but is
 
971
 *      mostly useless to us.
 
972
 *
 
973
 *      Returns 0 on success or negative error code on failure.
 
974
 */
 
975
static int i2o_hrt_get(struct i2o_controller *c)
 
976
{
 
977
        int rc;
 
978
        int i;
 
979
        i2o_hrt *hrt = c->hrt.virt;
 
980
        u32 size = sizeof(i2o_hrt);
 
981
        struct device *dev = &c->pdev->dev;
 
982
 
 
983
        for (i = 0; i < I2O_HRT_GET_TRIES; i++) {
 
984
                struct i2o_message *msg;
 
985
 
 
986
                msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
987
                if (IS_ERR(msg))
 
988
                        return PTR_ERR(msg);
 
989
 
 
990
                msg->u.head[0] = cpu_to_le32(SIX_WORD_MSG_SIZE | SGL_OFFSET_4);
 
991
                msg->u.head[1] =
 
992
                    cpu_to_le32(I2O_CMD_HRT_GET << 24 | HOST_TID << 12 |
 
993
                                ADAPTER_TID);
 
994
                msg->body[0] = cpu_to_le32(0xd0000000 | c->hrt.len);
 
995
                msg->body[1] = cpu_to_le32(c->hrt.phys);
 
996
 
 
997
                rc = i2o_msg_post_wait_mem(c, msg, 20, &c->hrt);
 
998
 
 
999
                if (rc < 0) {
 
1000
                        osm_err("%s: Unable to get HRT (status=%#x)\n", c->name,
 
1001
                                -rc);
 
1002
                        return rc;
 
1003
                }
 
1004
 
 
1005
                size = hrt->num_entries * hrt->entry_len << 2;
 
1006
                if (size > c->hrt.len) {
 
1007
                        if (i2o_dma_realloc(dev, &c->hrt, size))
 
1008
                                return -ENOMEM;
 
1009
                        else
 
1010
                                hrt = c->hrt.virt;
 
1011
                } else
 
1012
                        return i2o_parse_hrt(c);
 
1013
        }
 
1014
 
 
1015
        osm_err("%s: Unable to get HRT after %d tries, giving up\n", c->name,
 
1016
                I2O_HRT_GET_TRIES);
 
1017
 
 
1018
        return -EBUSY;
 
1019
}
 
1020
 
 
1021
/**
 
1022
 *      i2o_iop_release - release the memory for a I2O controller
 
1023
 *      @dev: I2O controller which should be released
 
1024
 *
 
1025
 *      Release the allocated memory. This function is called if refcount of
 
1026
 *      device reaches 0 automatically.
 
1027
 */
 
1028
static void i2o_iop_release(struct device *dev)
 
1029
{
 
1030
        struct i2o_controller *c = to_i2o_controller(dev);
 
1031
 
 
1032
        i2o_iop_free(c);
 
1033
};
 
1034
 
 
1035
/**
 
1036
 *      i2o_iop_alloc - Allocate and initialize a i2o_controller struct
 
1037
 *
 
1038
 *      Allocate the necessary memory for a i2o_controller struct and
 
1039
 *      initialize the lists and message mempool.
 
1040
 *
 
1041
 *      Returns a pointer to the I2O controller or a negative error code on
 
1042
 *      failure.
 
1043
 */
 
1044
struct i2o_controller *i2o_iop_alloc(void)
 
1045
{
 
1046
        static int unit = 0;    /* 0 and 1 are NULL IOP and Local Host */
 
1047
        struct i2o_controller *c;
 
1048
        char poolname[32];
 
1049
 
 
1050
        c = kzalloc(sizeof(*c), GFP_KERNEL);
 
1051
        if (!c) {
 
1052
                osm_err("i2o: Insufficient memory to allocate a I2O controller."
 
1053
                        "\n");
 
1054
                return ERR_PTR(-ENOMEM);
 
1055
        }
 
1056
 
 
1057
        c->unit = unit++;
 
1058
        sprintf(c->name, "iop%d", c->unit);
 
1059
 
 
1060
        snprintf(poolname, sizeof(poolname), "i2o_%s_msg_inpool", c->name);
 
1061
        if (i2o_pool_alloc
 
1062
            (&c->in_msg, poolname, I2O_INBOUND_MSG_FRAME_SIZE * 4 + sizeof(u32),
 
1063
             I2O_MSG_INPOOL_MIN)) {
 
1064
                kfree(c);
 
1065
                return ERR_PTR(-ENOMEM);
 
1066
        };
 
1067
 
 
1068
        INIT_LIST_HEAD(&c->devices);
 
1069
        spin_lock_init(&c->lock);
 
1070
        mutex_init(&c->lct_lock);
 
1071
 
 
1072
        device_initialize(&c->device);
 
1073
 
 
1074
        c->device.release = &i2o_iop_release;
 
1075
 
 
1076
        dev_set_name(&c->device, "iop%d", c->unit);
 
1077
 
 
1078
#if BITS_PER_LONG == 64
 
1079
        spin_lock_init(&c->context_list_lock);
 
1080
        atomic_set(&c->context_list_counter, 0);
 
1081
        INIT_LIST_HEAD(&c->context_list);
 
1082
#endif
 
1083
 
 
1084
        return c;
 
1085
};
 
1086
 
 
1087
/**
 
1088
 *      i2o_iop_add - Initialize the I2O controller and add him to the I2O core
 
1089
 *      @c: controller
 
1090
 *
 
1091
 *      Initialize the I2O controller and if no error occurs add him to the I2O
 
1092
 *      core.
 
1093
 *
 
1094
 *      Returns 0 on success or negative error code on failure.
 
1095
 */
 
1096
int i2o_iop_add(struct i2o_controller *c)
 
1097
{
 
1098
        int rc;
 
1099
 
 
1100
        if ((rc = device_add(&c->device))) {
 
1101
                osm_err("%s: could not add controller\n", c->name);
 
1102
                goto iop_reset;
 
1103
        }
 
1104
 
 
1105
        osm_info("%s: Activating I2O controller...\n", c->name);
 
1106
        osm_info("%s: This may take a few minutes if there are many devices\n",
 
1107
                 c->name);
 
1108
 
 
1109
        if ((rc = i2o_iop_activate(c))) {
 
1110
                osm_err("%s: could not activate controller\n", c->name);
 
1111
                goto device_del;
 
1112
        }
 
1113
 
 
1114
        osm_debug("%s: building sys table...\n", c->name);
 
1115
 
 
1116
        if ((rc = i2o_systab_build()))
 
1117
                goto device_del;
 
1118
 
 
1119
        osm_debug("%s: online controller...\n", c->name);
 
1120
 
 
1121
        if ((rc = i2o_iop_online(c)))
 
1122
                goto device_del;
 
1123
 
 
1124
        osm_debug("%s: getting LCT...\n", c->name);
 
1125
 
 
1126
        if ((rc = i2o_exec_lct_get(c)))
 
1127
                goto device_del;
 
1128
 
 
1129
        list_add(&c->list, &i2o_controllers);
 
1130
 
 
1131
        i2o_driver_notify_controller_add_all(c);
 
1132
 
 
1133
        osm_info("%s: Controller added\n", c->name);
 
1134
 
 
1135
        return 0;
 
1136
 
 
1137
      device_del:
 
1138
        device_del(&c->device);
 
1139
 
 
1140
      iop_reset:
 
1141
        i2o_iop_reset(c);
 
1142
 
 
1143
        return rc;
 
1144
};
 
1145
 
 
1146
/**
 
1147
 *      i2o_event_register - Turn on/off event notification for a I2O device
 
1148
 *      @dev: I2O device which should receive the event registration request
 
1149
 *      @drv: driver which want to get notified
 
1150
 *      @tcntxt: transaction context to use with this notifier
 
1151
 *      @evt_mask: mask of events
 
1152
 *
 
1153
 *      Create and posts an event registration message to the task. No reply
 
1154
 *      is waited for, or expected. If you do not want further notifications,
 
1155
 *      call the i2o_event_register again with a evt_mask of 0.
 
1156
 *
 
1157
 *      Returns 0 on success or negative error code on failure.
 
1158
 */
 
1159
int i2o_event_register(struct i2o_device *dev, struct i2o_driver *drv,
 
1160
                       int tcntxt, u32 evt_mask)
 
1161
{
 
1162
        struct i2o_controller *c = dev->iop;
 
1163
        struct i2o_message *msg;
 
1164
 
 
1165
        msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);
 
1166
        if (IS_ERR(msg))
 
1167
                return PTR_ERR(msg);
 
1168
 
 
1169
        msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);
 
1170
        msg->u.head[1] =
 
1171
            cpu_to_le32(I2O_CMD_UTIL_EVT_REGISTER << 24 | HOST_TID << 12 | dev->
 
1172
                        lct_data.tid);
 
1173
        msg->u.s.icntxt = cpu_to_le32(drv->context);
 
1174
        msg->u.s.tcntxt = cpu_to_le32(tcntxt);
 
1175
        msg->body[0] = cpu_to_le32(evt_mask);
 
1176
 
 
1177
        i2o_msg_post(c, msg);
 
1178
 
 
1179
        return 0;
 
1180
};
 
1181
 
 
1182
/**
 
1183
 *      i2o_iop_init - I2O main initialization function
 
1184
 *
 
1185
 *      Initialize the I2O drivers (OSM) functions, register the Executive OSM,
 
1186
 *      initialize the I2O PCI part and finally initialize I2O device stuff.
 
1187
 *
 
1188
 *      Returns 0 on success or negative error code on failure.
 
1189
 */
 
1190
static int __init i2o_iop_init(void)
 
1191
{
 
1192
        int rc = 0;
 
1193
 
 
1194
        printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n");
 
1195
 
 
1196
        if ((rc = i2o_driver_init()))
 
1197
                goto exit;
 
1198
 
 
1199
        if ((rc = i2o_exec_init()))
 
1200
                goto driver_exit;
 
1201
 
 
1202
        if ((rc = i2o_pci_init()))
 
1203
                goto exec_exit;
 
1204
 
 
1205
        return 0;
 
1206
 
 
1207
      exec_exit:
 
1208
        i2o_exec_exit();
 
1209
 
 
1210
      driver_exit:
 
1211
        i2o_driver_exit();
 
1212
 
 
1213
      exit:
 
1214
        return rc;
 
1215
}
 
1216
 
 
1217
/**
 
1218
 *      i2o_iop_exit - I2O main exit function
 
1219
 *
 
1220
 *      Removes I2O controllers from PCI subsystem and shut down OSMs.
 
1221
 */
 
1222
static void __exit i2o_iop_exit(void)
 
1223
{
 
1224
        i2o_pci_exit();
 
1225
        i2o_exec_exit();
 
1226
        i2o_driver_exit();
 
1227
};
 
1228
 
 
1229
module_init(i2o_iop_init);
 
1230
module_exit(i2o_iop_exit);
 
1231
 
 
1232
MODULE_AUTHOR("Red Hat Software");
 
1233
MODULE_LICENSE("GPL");
 
1234
MODULE_DESCRIPTION(OSM_DESCRIPTION);
 
1235
MODULE_VERSION(OSM_VERSION);
 
1236
 
 
1237
#if BITS_PER_LONG == 64
 
1238
EXPORT_SYMBOL(i2o_cntxt_list_add);
 
1239
EXPORT_SYMBOL(i2o_cntxt_list_get);
 
1240
EXPORT_SYMBOL(i2o_cntxt_list_remove);
 
1241
EXPORT_SYMBOL(i2o_cntxt_list_get_ptr);
 
1242
#endif
 
1243
EXPORT_SYMBOL(i2o_msg_get_wait);
 
1244
EXPORT_SYMBOL(i2o_find_iop);
 
1245
EXPORT_SYMBOL(i2o_iop_find_device);
 
1246
EXPORT_SYMBOL(i2o_event_register);
 
1247
EXPORT_SYMBOL(i2o_status_get);
 
1248
EXPORT_SYMBOL(i2o_controllers);