i2o.h 29.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*
 * I2O kernel space accessible structures/APIs
 *
 * (c) Copyright 1999, 2000 Red Hat Software
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 *************************************************************************
 *
 * This header file defined the I2O APIs/structures for use by
 * the I2O kernel modules.
 *
 */

#ifndef _I2O_H
#define _I2O_H

#include <linux/i2o-dev.h>

/* How many different OSM's are we allowing */
#define I2O_MAX_DRIVERS		8

#include <linux/pci.h>
#include <linux/dma-mapping.h>
Tim Schmielau's avatar
Tim Schmielau committed
28 29 30
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/workqueue.h>	/* work_struct */
31
#include <linux/mempool.h>
32
#include <linux/mutex.h>
Jens Axboe's avatar
Jens Axboe committed
33
#include <linux/scatterlist.h>
34
#include <linux/semaphore.h>	/* Needed for MUTEX init macros */
Tim Schmielau's avatar
Tim Schmielau committed
35 36

#include <asm/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39 40 41

/* message queue empty */
#define I2O_QUEUE_EMPTY		0xffffffff

/*
42
 *	Cache strategies
Linus Torvalds's avatar
Linus Torvalds committed
43 44
 */

45 46
/*	The NULL strategy leaves everything up to the controller. This tends to be a
 *	pessimal but functional choice.
Linus Torvalds's avatar
Linus Torvalds committed
47
 */
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
#define CACHE_NULL		0
/*	Prefetch data when reading. We continually attempt to load the next 32 sectors
 *	into the controller cache.
 */
#define CACHE_PREFETCH		1
/*	Prefetch data when reading. We sometimes attempt to load the next 32 sectors
 *	into the controller cache. When an I/O is less <= 8K we assume its probably
 *	not sequential and don't prefetch (default)
 */
#define CACHE_SMARTFETCH	2
/*	Data is written to the cache and then out on to the disk. The I/O must be
 *	physically on the medium before the write is acknowledged (default without
 *	NVRAM)
 */
#define CACHE_WRITETHROUGH	17
/*	Data is written to the cache and then out on to the disk. The controller
 *	is permitted to write back the cache any way it wants. (default if battery
 *	backed NVRAM is present). It can be useful to set this for swap regardless of
 *	battery state.
 */
#define CACHE_WRITEBACK		18
/*	Optimise for under powered controllers, especially on RAID1 and RAID0. We
 *	write large I/O's directly to disk bypassing the cache to avoid the extra
 *	memory copy hits. Small writes are writeback cached
 */
#define CACHE_SMARTBACK		19
/*	Optimise for under powered controllers, especially on RAID1 and RAID0. We
 *	write large I/O's directly to disk bypassing the cache to avoid the extra
 *	memory copy hits. Small writes are writethrough cached. Suitable for devices
 *	lacking battery backup
 */
#define CACHE_SMARTTHROUGH	20
Linus Torvalds's avatar
Linus Torvalds committed
80 81

/*
82
 *	Ioctl structures
Linus Torvalds's avatar
Linus Torvalds committed
83
 */
84 85 86 87 88

#define 	BLKI2OGRSTRAT	_IOR('2', 1, int)
#define 	BLKI2OGWSTRAT	_IOR('2', 2, int)
#define 	BLKI2OSRSTRAT	_IOW('2', 3, int)
#define 	BLKI2OSWSTRAT	_IOW('2', 4, int)
Linus Torvalds's avatar
Linus Torvalds committed
89 90

/*
91
 *	I2O Function codes
Linus Torvalds's avatar
Linus Torvalds committed
92 93 94
 */

/*
95
 *	Executive Class
Linus Torvalds's avatar
Linus Torvalds committed
96
 */
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
#define	I2O_CMD_ADAPTER_ASSIGN		0xB3
#define	I2O_CMD_ADAPTER_READ		0xB2
#define	I2O_CMD_ADAPTER_RELEASE		0xB5
#define	I2O_CMD_BIOS_INFO_SET		0xA5
#define	I2O_CMD_BOOT_DEVICE_SET		0xA7
#define	I2O_CMD_CONFIG_VALIDATE		0xBB
#define	I2O_CMD_CONN_SETUP		0xCA
#define	I2O_CMD_DDM_DESTROY		0xB1
#define	I2O_CMD_DDM_ENABLE		0xD5
#define	I2O_CMD_DDM_QUIESCE		0xC7
#define	I2O_CMD_DDM_RESET		0xD9
#define	I2O_CMD_DDM_SUSPEND		0xAF
#define	I2O_CMD_DEVICE_ASSIGN		0xB7
#define	I2O_CMD_DEVICE_RELEASE		0xB9
#define	I2O_CMD_HRT_GET			0xA8
#define	I2O_CMD_ADAPTER_CLEAR		0xBE
#define	I2O_CMD_ADAPTER_CONNECT		0xC9
#define	I2O_CMD_ADAPTER_RESET		0xBD
#define	I2O_CMD_LCT_NOTIFY		0xA2
#define	I2O_CMD_OUTBOUND_INIT		0xA1
#define	I2O_CMD_PATH_ENABLE		0xD3
#define	I2O_CMD_PATH_QUIESCE		0xC5
#define	I2O_CMD_PATH_RESET		0xD7
#define	I2O_CMD_STATIC_MF_CREATE	0xDD
#define	I2O_CMD_STATIC_MF_RELEASE	0xDF
#define	I2O_CMD_STATUS_GET		0xA0
#define	I2O_CMD_SW_DOWNLOAD		0xA9
#define	I2O_CMD_SW_UPLOAD		0xAB
#define	I2O_CMD_SW_REMOVE		0xAD
#define	I2O_CMD_SYS_ENABLE		0xD1
#define	I2O_CMD_SYS_MODIFY		0xC1
#define	I2O_CMD_SYS_QUIESCE		0xC3
#define	I2O_CMD_SYS_TAB_SET		0xA3
Linus Torvalds's avatar
Linus Torvalds committed
130 131

/*
132
 * Utility Class
Linus Torvalds's avatar
Linus Torvalds committed
133
 */
134 135 136 137 138 139 140 141 142 143 144 145 146 147
#define I2O_CMD_UTIL_NOP		0x00
#define I2O_CMD_UTIL_ABORT		0x01
#define I2O_CMD_UTIL_CLAIM		0x09
#define I2O_CMD_UTIL_RELEASE		0x0B
#define I2O_CMD_UTIL_PARAMS_GET		0x06
#define I2O_CMD_UTIL_PARAMS_SET		0x05
#define I2O_CMD_UTIL_EVT_REGISTER	0x13
#define I2O_CMD_UTIL_EVT_ACK		0x14
#define I2O_CMD_UTIL_CONFIG_DIALOG	0x10
#define I2O_CMD_UTIL_DEVICE_RESERVE	0x0D
#define I2O_CMD_UTIL_DEVICE_RELEASE	0x0F
#define I2O_CMD_UTIL_LOCK		0x17
#define I2O_CMD_UTIL_LOCK_RELEASE	0x19
#define I2O_CMD_UTIL_REPLY_FAULT_NOTIFY	0x15
148 149

/*
150
 * SCSI Host Bus Adapter Class
151
 */
152 153 154
#define I2O_CMD_SCSI_EXEC		0x81
#define I2O_CMD_SCSI_ABORT		0x83
#define I2O_CMD_SCSI_BUSRESET		0x27
Linus Torvalds's avatar
Linus Torvalds committed
155 156

/*
157
 * Bus Adapter Class
Linus Torvalds's avatar
Linus Torvalds committed
158
 */
159 160 161 162
#define I2O_CMD_BUS_ADAPTER_RESET	0x85
#define I2O_CMD_BUS_RESET		0x87
#define I2O_CMD_BUS_SCAN		0x89
#define I2O_CMD_BUS_QUIESCE		0x8b
Linus Torvalds's avatar
Linus Torvalds committed
163 164

/*
165
 * Random Block Storage Class
Linus Torvalds's avatar
Linus Torvalds committed
166
 */
167 168 169 170 171 172 173 174
#define I2O_CMD_BLOCK_READ		0x30
#define I2O_CMD_BLOCK_WRITE		0x31
#define I2O_CMD_BLOCK_CFLUSH		0x37
#define I2O_CMD_BLOCK_MLOCK		0x49
#define I2O_CMD_BLOCK_MUNLOCK		0x4B
#define I2O_CMD_BLOCK_MMOUNT		0x41
#define I2O_CMD_BLOCK_MEJECT		0x43
#define I2O_CMD_BLOCK_POWER		0x70
Linus Torvalds's avatar
Linus Torvalds committed
175

176
#define I2O_CMD_PRIVATE			0xFF
Linus Torvalds's avatar
Linus Torvalds committed
177

178
/* Command status values  */
Linus Torvalds's avatar
Linus Torvalds committed
179

180 181 182 183
#define I2O_CMD_IN_PROGRESS	0x01
#define I2O_CMD_REJECTED	0x02
#define I2O_CMD_FAILED		0x03
#define I2O_CMD_COMPLETED	0x04
184

185
/* I2O API function return values */
Linus Torvalds's avatar
Linus Torvalds committed
186

187 188 189 190 191 192 193 194 195 196 197 198
#define I2O_RTN_NO_ERROR			0
#define I2O_RTN_NOT_INIT			1
#define I2O_RTN_FREE_Q_EMPTY			2
#define I2O_RTN_TCB_ERROR			3
#define I2O_RTN_TRANSACTION_ERROR		4
#define I2O_RTN_ADAPTER_ALREADY_INIT		5
#define I2O_RTN_MALLOC_ERROR			6
#define I2O_RTN_ADPTR_NOT_REGISTERED		7
#define I2O_RTN_MSG_REPLY_TIMEOUT		8
#define I2O_RTN_NO_STATUS			9
#define I2O_RTN_NO_FIRM_VER			10
#define	I2O_RTN_NO_LINK_SPEED			11
Linus Torvalds's avatar
Linus Torvalds committed
199

200
/* Reply message status defines for all messages */
Linus Torvalds's avatar
Linus Torvalds committed
201

202 203 204 205 206 207 208 209 210 211 212 213
#define I2O_REPLY_STATUS_SUCCESS                    	0x00
#define I2O_REPLY_STATUS_ABORT_DIRTY                	0x01
#define I2O_REPLY_STATUS_ABORT_NO_DATA_TRANSFER     	0x02
#define	I2O_REPLY_STATUS_ABORT_PARTIAL_TRANSFER		0x03
#define	I2O_REPLY_STATUS_ERROR_DIRTY			0x04
#define	I2O_REPLY_STATUS_ERROR_NO_DATA_TRANSFER		0x05
#define	I2O_REPLY_STATUS_ERROR_PARTIAL_TRANSFER		0x06
#define	I2O_REPLY_STATUS_PROCESS_ABORT_DIRTY		0x08
#define	I2O_REPLY_STATUS_PROCESS_ABORT_NO_DATA_TRANSFER	0x09
#define	I2O_REPLY_STATUS_PROCESS_ABORT_PARTIAL_TRANSFER	0x0A
#define	I2O_REPLY_STATUS_TRANSACTION_ERROR		0x0B
#define	I2O_REPLY_STATUS_PROGRESS_REPORT		0x80
Linus Torvalds's avatar
Linus Torvalds committed
214

215
/* Status codes and Error Information for Parameter functions */
Linus Torvalds's avatar
Linus Torvalds committed
216

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
#define I2O_PARAMS_STATUS_SUCCESS		0x00
#define I2O_PARAMS_STATUS_BAD_KEY_ABORT		0x01
#define I2O_PARAMS_STATUS_BAD_KEY_CONTINUE   	0x02
#define I2O_PARAMS_STATUS_BUFFER_FULL		0x03
#define I2O_PARAMS_STATUS_BUFFER_TOO_SMALL	0x04
#define I2O_PARAMS_STATUS_FIELD_UNREADABLE	0x05
#define I2O_PARAMS_STATUS_FIELD_UNWRITEABLE	0x06
#define I2O_PARAMS_STATUS_INSUFFICIENT_FIELDS	0x07
#define I2O_PARAMS_STATUS_INVALID_GROUP_ID	0x08
#define I2O_PARAMS_STATUS_INVALID_OPERATION	0x09
#define I2O_PARAMS_STATUS_NO_KEY_FIELD		0x0A
#define I2O_PARAMS_STATUS_NO_SUCH_FIELD		0x0B
#define I2O_PARAMS_STATUS_NON_DYNAMIC_GROUP	0x0C
#define I2O_PARAMS_STATUS_OPERATION_ERROR	0x0D
#define I2O_PARAMS_STATUS_SCALAR_ERROR		0x0E
#define I2O_PARAMS_STATUS_TABLE_ERROR		0x0F
#define I2O_PARAMS_STATUS_WRONG_GROUP_TYPE	0x10
Linus Torvalds's avatar
Linus Torvalds committed
234

235 236
/* DetailedStatusCode defines for Executive, DDM, Util and Transaction error
 * messages: Table 3-2 Detailed Status Codes.*/
Linus Torvalds's avatar
Linus Torvalds committed
237

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
#define I2O_DSC_SUCCESS                        0x0000
#define I2O_DSC_BAD_KEY                        0x0002
#define I2O_DSC_TCL_ERROR                      0x0003
#define I2O_DSC_REPLY_BUFFER_FULL              0x0004
#define I2O_DSC_NO_SUCH_PAGE                   0x0005
#define I2O_DSC_INSUFFICIENT_RESOURCE_SOFT     0x0006
#define I2O_DSC_INSUFFICIENT_RESOURCE_HARD     0x0007
#define I2O_DSC_CHAIN_BUFFER_TOO_LARGE         0x0009
#define I2O_DSC_UNSUPPORTED_FUNCTION           0x000A
#define I2O_DSC_DEVICE_LOCKED                  0x000B
#define I2O_DSC_DEVICE_RESET                   0x000C
#define I2O_DSC_INAPPROPRIATE_FUNCTION         0x000D
#define I2O_DSC_INVALID_INITIATOR_ADDRESS      0x000E
#define I2O_DSC_INVALID_MESSAGE_FLAGS          0x000F
#define I2O_DSC_INVALID_OFFSET                 0x0010
#define I2O_DSC_INVALID_PARAMETER              0x0011
#define I2O_DSC_INVALID_REQUEST                0x0012
#define I2O_DSC_INVALID_TARGET_ADDRESS         0x0013
#define I2O_DSC_MESSAGE_TOO_LARGE              0x0014
#define I2O_DSC_MESSAGE_TOO_SMALL              0x0015
#define I2O_DSC_MISSING_PARAMETER              0x0016
#define I2O_DSC_TIMEOUT                        0x0017
#define I2O_DSC_UNKNOWN_ERROR                  0x0018
#define I2O_DSC_UNKNOWN_FUNCTION               0x0019
#define I2O_DSC_UNSUPPORTED_VERSION            0x001A
#define I2O_DSC_DEVICE_BUSY                    0x001B
#define I2O_DSC_DEVICE_NOT_AVAILABLE           0x001C
Linus Torvalds's avatar
Linus Torvalds committed
265

266 267
/* DetailedStatusCode defines for Block Storage Operation: Table 6-7 Detailed
   Status Codes.*/
Linus Torvalds's avatar
Linus Torvalds committed
268

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
#define I2O_BSA_DSC_SUCCESS               0x0000
#define I2O_BSA_DSC_MEDIA_ERROR           0x0001
#define I2O_BSA_DSC_ACCESS_ERROR          0x0002
#define I2O_BSA_DSC_DEVICE_FAILURE        0x0003
#define I2O_BSA_DSC_DEVICE_NOT_READY      0x0004
#define I2O_BSA_DSC_MEDIA_NOT_PRESENT     0x0005
#define I2O_BSA_DSC_MEDIA_LOCKED          0x0006
#define I2O_BSA_DSC_MEDIA_FAILURE         0x0007
#define I2O_BSA_DSC_PROTOCOL_FAILURE      0x0008
#define I2O_BSA_DSC_BUS_FAILURE           0x0009
#define I2O_BSA_DSC_ACCESS_VIOLATION      0x000A
#define I2O_BSA_DSC_WRITE_PROTECTED       0x000B
#define I2O_BSA_DSC_DEVICE_RESET          0x000C
#define I2O_BSA_DSC_VOLUME_CHANGED        0x000D
#define I2O_BSA_DSC_TIMEOUT               0x000E
Linus Torvalds's avatar
Linus Torvalds committed
284

285
/* FailureStatusCodes, Table 3-3 Message Failure Codes */
Linus Torvalds's avatar
Linus Torvalds committed
286

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
#define I2O_FSC_TRANSPORT_SERVICE_SUSPENDED             0x81
#define I2O_FSC_TRANSPORT_SERVICE_TERMINATED            0x82
#define I2O_FSC_TRANSPORT_CONGESTION                    0x83
#define I2O_FSC_TRANSPORT_FAILURE                       0x84
#define I2O_FSC_TRANSPORT_STATE_ERROR                   0x85
#define I2O_FSC_TRANSPORT_TIME_OUT                      0x86
#define I2O_FSC_TRANSPORT_ROUTING_FAILURE               0x87
#define I2O_FSC_TRANSPORT_INVALID_VERSION               0x88
#define I2O_FSC_TRANSPORT_INVALID_OFFSET                0x89
#define I2O_FSC_TRANSPORT_INVALID_MSG_FLAGS             0x8A
#define I2O_FSC_TRANSPORT_FRAME_TOO_SMALL               0x8B
#define I2O_FSC_TRANSPORT_FRAME_TOO_LARGE               0x8C
#define I2O_FSC_TRANSPORT_INVALID_TARGET_ID             0x8D
#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_ID          0x8E
#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_CONTEXT     0x8F
#define I2O_FSC_TRANSPORT_UNKNOWN_FAILURE               0xFF
Linus Torvalds's avatar
Linus Torvalds committed
303

304 305 306 307 308
/* Device Claim Types */
#define	I2O_CLAIM_PRIMARY					0x01000000
#define	I2O_CLAIM_MANAGEMENT					0x02000000
#define	I2O_CLAIM_AUTHORIZED					0x03000000
#define	I2O_CLAIM_SECONDARY					0x04000000
Linus Torvalds's avatar
Linus Torvalds committed
309

310 311 312
/* Message header defines for VersionOffset */
#define I2OVER15	0x0001
#define I2OVER20	0x0002
Linus Torvalds's avatar
Linus Torvalds committed
313

314 315
/* Default is 1.5 */
#define I2OVERSION	I2OVER15
Linus Torvalds's avatar
Linus Torvalds committed
316

317 318 319 320 321 322 323 324 325 326 327
#define SGL_OFFSET_0    I2OVERSION
#define SGL_OFFSET_4    (0x0040 | I2OVERSION)
#define SGL_OFFSET_5    (0x0050 | I2OVERSION)
#define SGL_OFFSET_6    (0x0060 | I2OVERSION)
#define SGL_OFFSET_7    (0x0070 | I2OVERSION)
#define SGL_OFFSET_8    (0x0080 | I2OVERSION)
#define SGL_OFFSET_9    (0x0090 | I2OVERSION)
#define SGL_OFFSET_10   (0x00A0 | I2OVERSION)
#define SGL_OFFSET_11   (0x00B0 | I2OVERSION)
#define SGL_OFFSET_12   (0x00C0 | I2OVERSION)
#define SGL_OFFSET(x)   (((x)<<4) | I2OVERSION)
Linus Torvalds's avatar
Linus Torvalds committed
328

329 330 331 332
/* Transaction Reply Lists (TRL) Control Word structure */
#define TRL_SINGLE_FIXED_LENGTH		0x00
#define TRL_SINGLE_VARIABLE_LENGTH	0x40
#define TRL_MULTIPLE_FIXED_LENGTH	0x80
Linus Torvalds's avatar
Linus Torvalds committed
333

334 335 336 337 338 339 340
 /* msg header defines for MsgFlags */
#define MSG_STATIC	0x0100
#define MSG_64BIT_CNTXT	0x0200
#define MSG_MULTI_TRANS	0x1000
#define MSG_FAIL	0x2000
#define MSG_FINAL	0x4000
#define MSG_REPLY	0x8000
341

342 343 344 345 346 347 348 349 350 351 352
 /* minimum size msg */
#define THREE_WORD_MSG_SIZE	0x00030000
#define FOUR_WORD_MSG_SIZE	0x00040000
#define FIVE_WORD_MSG_SIZE	0x00050000
#define SIX_WORD_MSG_SIZE	0x00060000
#define SEVEN_WORD_MSG_SIZE	0x00070000
#define EIGHT_WORD_MSG_SIZE	0x00080000
#define NINE_WORD_MSG_SIZE	0x00090000
#define TEN_WORD_MSG_SIZE	0x000A0000
#define ELEVEN_WORD_MSG_SIZE	0x000B0000
#define I2O_MESSAGE_SIZE(x)	((x)<<16)
353

354 355 356
/* special TID assignments */
#define ADAPTER_TID		0
#define HOST_TID		1
Linus Torvalds's avatar
Linus Torvalds committed
357

358 359 360
/* outbound queue defines */
#define I2O_MAX_OUTBOUND_MSG_FRAMES	128
#define I2O_OUTBOUND_MSG_FRAME_SIZE	128	/* in 32-bit words */
Linus Torvalds's avatar
Linus Torvalds committed
361

362 363 364
/* inbound queue definitions */
#define I2O_MSG_INPOOL_MIN		32
#define I2O_INBOUND_MSG_FRAME_SIZE	128	/* in 32-bit words */
Linus Torvalds's avatar
Linus Torvalds committed
365

366 367
#define I2O_POST_WAIT_OK	0
#define I2O_POST_WAIT_TIMEOUT	-ETIMEDOUT
Linus Torvalds's avatar
Linus Torvalds committed
368

369 370 371
#define I2O_CONTEXT_LIST_MIN_LENGTH	15
#define I2O_CONTEXT_LIST_USED		0x01
#define I2O_CONTEXT_LIST_DELETED	0x02
Linus Torvalds's avatar
Linus Torvalds committed
372

373 374 375 376 377 378 379
/* timeouts */
#define I2O_TIMEOUT_INIT_OUTBOUND_QUEUE	15
#define I2O_TIMEOUT_MESSAGE_GET		5
#define I2O_TIMEOUT_RESET		30
#define I2O_TIMEOUT_STATUS_GET		5
#define I2O_TIMEOUT_LCT_GET		360
#define I2O_TIMEOUT_SCSI_SCB_ABORT	240
380

381 382 383
/* retries */
#define I2O_HRT_GET_TRIES		3
#define I2O_LCT_GET_TRIES		3
384

385 386
/* defines for max_sectors and max_phys_segments */
#define I2O_MAX_SECTORS			1024
Markus Lidel's avatar
Markus Lidel committed
387
#define I2O_MAX_SECTORS_LIMITED		128
388
#define I2O_MAX_PHYS_SEGMENTS		MAX_PHYS_SEGMENTS
389

390 391
/*
 *	Message structures
392
 */
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
struct i2o_message {
	union {
		struct {
			u8 version_offset;
			u8 flags;
			u16 size;
			u32 target_tid:12;
			u32 init_tid:12;
			u32 function:8;
			u32 icntxt;	/* initiator context */
			u32 tcntxt;	/* transaction context */
		} s;
		u32 head[4];
	} u;
	/* List follows */
	u32 body[0];
};
410

411 412 413 414
/* MFA and I2O message used by mempool */
struct i2o_msg_mfa {
	u32 mfa;		/* MFA returned by the controller */
	struct i2o_message msg;	/* I2O message */
415 416
};

417 418
/*
 *	Each I2O device entity has one of these. There is one per device.
419
 */
420 421
struct i2o_device {
	i2o_lct_entry lct_data;	/* Device LCT information */
422

423 424
	struct i2o_controller *iop;	/* Controlling IOP */
	struct list_head list;	/* node in IOP devices list */
425

426
	struct device device;
427

428
	struct mutex lock;	/* device lock */
429 430
};

431 432
/*
 *	Event structure provided to the event handling function
433
 */
434 435 436 437 438 439 440 441 442 443
struct i2o_event {
	struct work_struct work;
	struct i2o_device *i2o_dev;	/* I2O device pointer from which the
					   event reply was initiated */
	u16 size;		/* Size of data in 32-bit words */
	u32 tcntxt;		/* Transaction context used at
				   registration */
	u32 event_indicator;	/* Event indicator from reply */
	u32 data[0];		/* Event data from reply */
};
444

445 446 447 448 449
/*
 *	I2O classes which could be handled by the OSM
 */
struct i2o_class_id {
	u16 class_id:12;
450 451
};

452 453
/*
 *	I2O driver structure for OSMs
454
 */
455 456 457 458
struct i2o_driver {
	char *name;		/* OSM name */
	int context;		/* Low 8 bits of the transaction info */
	struct i2o_class_id *classes;	/* I2O classes that this OSM handles */
459

460 461
	/* Message reply handler */
	int (*reply) (struct i2o_controller *, u32, struct i2o_message *);
462

463
	/* Event handler */
464
	work_func_t event;
465

466
	struct workqueue_struct *event_queue;	/* Event queue */
467

468
	struct device_driver driver;
469

470 471 472 473 474
	/* notification of changes */
	void (*notify_controller_add) (struct i2o_controller *);
	void (*notify_controller_remove) (struct i2o_controller *);
	void (*notify_device_add) (struct i2o_device *);
	void (*notify_device_remove) (struct i2o_device *);
475

476
	struct semaphore lock;
477 478
};

479 480
/*
 *	Contains DMA mapped address information
481
 */
482 483 484 485
struct i2o_dma {
	void *virt;
	dma_addr_t phys;
	size_t len;
486 487
};

488 489
/*
 *	Contains slab cache and mempool information
490
 */
491 492
struct i2o_pool {
	char *name;
493
	struct kmem_cache *slab;
494
	mempool_t *mempool;
495 496
};

497 498
/*
 *	Contains IO mapped address information
Linus Torvalds's avatar
Linus Torvalds committed
499
 */
500 501 502 503
struct i2o_io {
	void __iomem *virt;
	unsigned long phys;
	unsigned long len;
Linus Torvalds's avatar
Linus Torvalds committed
504 505
};

506 507
/*
 *	Context queue entry, used for 32-bit context on 64-bit systems
Linus Torvalds's avatar
Linus Torvalds committed
508
 */
509 510 511 512 513
struct i2o_context_list_element {
	struct list_head list;
	u32 context;
	void *ptr;
	unsigned long timestamp;
Linus Torvalds's avatar
Linus Torvalds committed
514 515
};

516 517
/*
 * Each I2O controller has one of these objects
Linus Torvalds's avatar
Linus Torvalds committed
518
 */
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
struct i2o_controller {
	char name[16];
	int unit;
	int type;

	struct pci_dev *pdev;	/* PCI device */

	unsigned int promise:1;	/* Promise controller */
	unsigned int adaptec:1;	/* DPT / Adaptec controller */
	unsigned int raptor:1;	/* split bar */
	unsigned int no_quiesce:1;	/* dont quiesce before reset */
	unsigned int short_req:1;	/* use small block sizes */
	unsigned int limit_sectors:1;	/* limit number of sectors / request */
	unsigned int pae_support:1;	/* controller has 64-bit SGL support */

	struct list_head devices;	/* list of I2O devices */
	struct list_head list;	/* Controller list */

	void __iomem *in_port;	/* Inbout port address */
	void __iomem *out_port;	/* Outbound port address */
	void __iomem *irq_status;	/* Interrupt status register address */
	void __iomem *irq_mask;	/* Interrupt mask register address */

	struct i2o_dma status;	/* IOP status block */

	struct i2o_dma hrt;	/* HW Resource Table */
	i2o_lct *lct;		/* Logical Config Table */
	struct i2o_dma dlct;	/* Temp LCT */
547
	struct mutex lct_lock;	/* Lock for LCT updates */
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
	struct i2o_dma status_block;	/* IOP status block */

	struct i2o_io base;	/* controller messaging unit */
	struct i2o_io in_queue;	/* inbound message queue Host->IOP */
	struct i2o_dma out_queue;	/* outbound message queue IOP->Host */

	struct i2o_pool in_msg;	/* mempool for inbound messages */

	unsigned int battery:1;	/* Has a battery backup */
	unsigned int io_alloc:1;	/* An I/O resource was allocated */
	unsigned int mem_alloc:1;	/* A memory resource was allocated */

	struct resource io_resource;	/* I/O resource allocated to the IOP */
	struct resource mem_resource;	/* Mem resource allocated to the IOP */

	struct device device;
	struct i2o_device *exec;	/* Executive */
#if BITS_PER_LONG == 64
	spinlock_t context_list_lock;	/* lock for context_list */
	atomic_t context_list_counter;	/* needed for unique contexts */
	struct list_head context_list;	/* list of context id's
					   and pointers */
#endif
	spinlock_t lock;	/* lock for controller
				   configuration */
	void *driver_data[I2O_MAX_DRIVERS];	/* storage for drivers */
Linus Torvalds's avatar
Linus Torvalds committed
574 575
};

576 577
/*
 * I2O System table entry
Linus Torvalds's avatar
Linus Torvalds committed
578
 *
579 580 581
 * The system table contains information about all the IOPs in the
 * system.  It is sent to all IOPs so that they can create peer2peer
 * connections between them.
Linus Torvalds's avatar
Linus Torvalds committed
582
 */
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
struct i2o_sys_tbl_entry {
	u16 org_id;
	u16 reserved1;
	u32 iop_id:12;
	u32 reserved2:20;
	u16 seg_num:12;
	u16 i2o_version:4;
	u8 iop_state;
	u8 msg_type;
	u16 frame_size;
	u16 reserved3;
	u32 last_changed;
	u32 iop_capabilities;
	u32 inbound_low;
	u32 inbound_high;
Linus Torvalds's avatar
Linus Torvalds committed
598 599
};

600 601 602 603 604 605 606 607 608
struct i2o_sys_tbl {
	u8 num_entries;
	u8 version;
	u16 reserved1;
	u32 change_ind;
	u32 reserved2;
	u32 reserved3;
	struct i2o_sys_tbl_entry iops[0];
};
Linus Torvalds's avatar
Linus Torvalds committed
609

610
extern struct list_head i2o_controllers;
Linus Torvalds's avatar
Linus Torvalds committed
611

612 613 614 615
/* Message functions */
extern struct i2o_message *i2o_msg_get_wait(struct i2o_controller *, int);
extern int i2o_msg_post_wait_mem(struct i2o_controller *, struct i2o_message *,
				 unsigned long, struct i2o_dma *);
Linus Torvalds's avatar
Linus Torvalds committed
616

617 618
/* IOP functions */
extern int i2o_status_get(struct i2o_controller *);
Linus Torvalds's avatar
Linus Torvalds committed
619

620 621 622 623
extern int i2o_event_register(struct i2o_device *, struct i2o_driver *, int,
			      u32);
extern struct i2o_device *i2o_iop_find_device(struct i2o_controller *, u16);
extern struct i2o_controller *i2o_find_iop(int);
Linus Torvalds's avatar
Linus Torvalds committed
624

625 626 627 628 629 630
/* Functions needed for handling 64-bit pointers in 32-bit context */
#if BITS_PER_LONG == 64
extern u32 i2o_cntxt_list_add(struct i2o_controller *, void *);
extern void *i2o_cntxt_list_get(struct i2o_controller *, u32);
extern u32 i2o_cntxt_list_remove(struct i2o_controller *, void *);
extern u32 i2o_cntxt_list_get_ptr(struct i2o_controller *, void *);
Linus Torvalds's avatar
Linus Torvalds committed
631

632 633 634
static inline u32 i2o_ptr_low(void *ptr)
{
	return (u32) (u64) ptr;
Linus Torvalds's avatar
Linus Torvalds committed
635 636
};

637
static inline u32 i2o_ptr_high(void *ptr)
Linus Torvalds's avatar
Linus Torvalds committed
638
{
639
	return (u32) ((u64) ptr >> 32);
Linus Torvalds's avatar
Linus Torvalds committed
640 641
};

642
static inline u32 i2o_dma_low(dma_addr_t dma_addr)
Linus Torvalds's avatar
Linus Torvalds committed
643
{
644
	return (u32) (u64) dma_addr;
Linus Torvalds's avatar
Linus Torvalds committed
645 646
};

647
static inline u32 i2o_dma_high(dma_addr_t dma_addr)
Linus Torvalds's avatar
Linus Torvalds committed
648
{
649 650 651 652 653 654
	return (u32) ((u64) dma_addr >> 32);
};
#else
static inline u32 i2o_cntxt_list_add(struct i2o_controller *c, void *ptr)
{
	return (u32) ptr;
Linus Torvalds's avatar
Linus Torvalds committed
655 656
};

657
static inline void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
Linus Torvalds's avatar
Linus Torvalds committed
658
{
659 660
	return (void *)context;
};
Linus Torvalds's avatar
Linus Torvalds committed
661

662 663 664
static inline u32 i2o_cntxt_list_remove(struct i2o_controller *c, void *ptr)
{
	return (u32) ptr;
Linus Torvalds's avatar
Linus Torvalds committed
665 666
};

667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
static inline u32 i2o_cntxt_list_get_ptr(struct i2o_controller *c, void *ptr)
{
	return (u32) ptr;
};

static inline u32 i2o_ptr_low(void *ptr)
{
	return (u32) ptr;
};

static inline u32 i2o_ptr_high(void *ptr)
{
	return 0;
};

static inline u32 i2o_dma_low(dma_addr_t dma_addr)
{
	return (u32) dma_addr;
};

static inline u32 i2o_dma_high(dma_addr_t dma_addr)
{
	return 0;
};
#endif

Alan Cox's avatar
Alan Cox committed
693 694
extern u16 i2o_sg_tablesize(struct i2o_controller *c, u16 body_size);
extern dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr,
695 696
					    size_t size,
					    enum dma_data_direction direction,
Alan Cox's avatar
Alan Cox committed
697 698
					    u32 ** sg_ptr);
extern int i2o_dma_map_sg(struct i2o_controller *c,
699 700
				 struct scatterlist *sg, int sg_count,
				 enum dma_data_direction direction,
Alan Cox's avatar
Alan Cox committed
701 702 703 704 705 706 707 708
				 u32 ** sg_ptr);
extern int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len);
extern void i2o_dma_free(struct device *dev, struct i2o_dma *addr);
extern int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr,
								size_t len);
extern int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
				 size_t size, int min_nr);
extern void i2o_pool_free(struct i2o_pool *pool);
709 710 711
/* I2O driver (OSM) functions */
extern int i2o_driver_register(struct i2o_driver *);
extern void i2o_driver_unregister(struct i2o_driver *);
Linus Torvalds's avatar
Linus Torvalds committed
712

713 714
/**
 *	i2o_driver_notify_controller_add - Send notification of added controller
715 716
 *	@drv: I2O driver
 *	@c: I2O controller
717 718 719 720 721 722 723 724 725
 *
 *	Send notification of added controller to a single registered driver.
 */
static inline void i2o_driver_notify_controller_add(struct i2o_driver *drv,
						    struct i2o_controller *c)
{
	if (drv->notify_controller_add)
		drv->notify_controller_add(c);
};
Linus Torvalds's avatar
Linus Torvalds committed
726

727
/**
728 729 730
 *	i2o_driver_notify_controller_remove - Send notification of removed controller
 *	@drv: I2O driver
 *	@c: I2O controller
731 732 733 734 735 736 737 738 739
 *
 *	Send notification of removed controller to a single registered driver.
 */
static inline void i2o_driver_notify_controller_remove(struct i2o_driver *drv,
						       struct i2o_controller *c)
{
	if (drv->notify_controller_remove)
		drv->notify_controller_remove(c);
};
Linus Torvalds's avatar
Linus Torvalds committed
740

741
/**
742 743 744
 *	i2o_driver_notify_device_add - Send notification of added device
 *	@drv: I2O driver
 *	@i2o_dev: the added i2o_device
745 746 747 748 749 750 751 752 753
 *
 *	Send notification of added device to a single registered driver.
 */
static inline void i2o_driver_notify_device_add(struct i2o_driver *drv,
						struct i2o_device *i2o_dev)
{
	if (drv->notify_device_add)
		drv->notify_device_add(i2o_dev);
};
Linus Torvalds's avatar
Linus Torvalds committed
754

755 756
/**
 *	i2o_driver_notify_device_remove - Send notification of removed device
757 758
 *	@drv: I2O driver
 *	@i2o_dev: the added i2o_device
759 760 761 762 763 764 765 766 767
 *
 *	Send notification of removed device to a single registered driver.
 */
static inline void i2o_driver_notify_device_remove(struct i2o_driver *drv,
						   struct i2o_device *i2o_dev)
{
	if (drv->notify_device_remove)
		drv->notify_device_remove(i2o_dev);
};
Linus Torvalds's avatar
Linus Torvalds committed
768

769 770 771 772
extern void i2o_driver_notify_controller_add_all(struct i2o_controller *);
extern void i2o_driver_notify_controller_remove_all(struct i2o_controller *);
extern void i2o_driver_notify_device_add_all(struct i2o_device *);
extern void i2o_driver_notify_device_remove_all(struct i2o_device *);
Linus Torvalds's avatar
Linus Torvalds committed
773

774 775 776
/* I2O device functions */
extern int i2o_device_claim(struct i2o_device *);
extern int i2o_device_claim_release(struct i2o_device *);
Linus Torvalds's avatar
Linus Torvalds committed
777

778 779
/* Exec OSM functions */
extern int i2o_exec_lct_get(struct i2o_controller *);
Linus Torvalds's avatar
Linus Torvalds committed
780

781 782 783 784 785
/* device / driver / kobject conversion functions */
#define to_i2o_driver(drv) container_of(drv,struct i2o_driver, driver)
#define to_i2o_device(dev) container_of(dev, struct i2o_device, device)
#define to_i2o_controller(dev) container_of(dev, struct i2o_controller, device)
#define kobj_to_i2o_device(kobj) to_i2o_device(container_of(kobj, struct device, kobj))
Linus Torvalds's avatar
Linus Torvalds committed
786

787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
/**
 *	i2o_out_to_virt - Turn an I2O message to a virtual address
 *	@c: controller
 *	@m: message engine value
 *
 *	Turn a receive message from an I2O controller bus address into
 *	a Linux virtual address. The shared page frame is a linear block
 *	so we simply have to shift the offset. This function does not
 *	work for sender side messages as they are ioremap objects
 *	provided by the I2O controller.
 */
static inline struct i2o_message *i2o_msg_out_to_virt(struct i2o_controller *c,
						      u32 m)
{
	BUG_ON(m < c->out_queue.phys
	       || m >= c->out_queue.phys + c->out_queue.len);
Linus Torvalds's avatar
Linus Torvalds committed
803

804 805
	return c->out_queue.virt + (m - c->out_queue.phys);
};
Linus Torvalds's avatar
Linus Torvalds committed
806

807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
/**
 *	i2o_msg_in_to_virt - Turn an I2O message to a virtual address
 *	@c: controller
 *	@m: message engine value
 *
 *	Turn a send message from an I2O controller bus address into
 *	a Linux virtual address. The shared page frame is a linear block
 *	so we simply have to shift the offset. This function does not
 *	work for receive side messages as they are kmalloc objects
 *	in a different pool.
 */
static inline struct i2o_message __iomem *i2o_msg_in_to_virt(struct
							     i2o_controller *c,
							     u32 m)
{
	return c->in_queue.virt + m;
};
Linus Torvalds's avatar
Linus Torvalds committed
824

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
/**
 *	i2o_msg_get - obtain an I2O message from the IOP
 *	@c: I2O controller
 *
 *	This function tries to get a message frame. If no message frame is
 *	available do not wait until one is availabe (see also i2o_msg_get_wait).
 *	The returned pointer to the message frame is not in I/O memory, it is
 *	allocated from a mempool. But because a MFA is allocated from the
 *	controller too it is guaranteed that i2o_msg_post() will never fail.
 *
 *	On a success a pointer to the message frame is returned. If the message
 *	queue is empty -EBUSY is returned and if no memory is available -ENOMEM
 *	is returned.
 */
static inline struct i2o_message *i2o_msg_get(struct i2o_controller *c)
{
	struct i2o_msg_mfa *mmsg = mempool_alloc(c->in_msg.mempool, GFP_ATOMIC);
	if (!mmsg)
		return ERR_PTR(-ENOMEM);

	mmsg->mfa = readl(c->in_port);
846
	if (unlikely(mmsg->mfa >= c->in_queue.len)) {
847 848
		u32 mfa = mmsg->mfa;

849
		mempool_free(mmsg, c->in_msg.mempool);
850 851

		if (mfa == I2O_QUEUE_EMPTY)
852 853
			return ERR_PTR(-EBUSY);
		return ERR_PTR(-EFAULT);
854
	}
Linus Torvalds's avatar
Linus Torvalds committed
855

856 857
	return &mmsg->msg;
};
Linus Torvalds's avatar
Linus Torvalds committed
858

859 860 861 862 863 864 865 866 867 868 869
/**
 *	i2o_msg_post - Post I2O message to I2O controller
 *	@c: I2O controller to which the message should be send
 *	@msg: message returned by i2o_msg_get()
 *
 *	Post the message to the I2O controller and return immediately.
 */
static inline void i2o_msg_post(struct i2o_controller *c,
				struct i2o_message *msg)
{
	struct i2o_msg_mfa *mmsg;
Linus Torvalds's avatar
Linus Torvalds committed
870

871 872 873 874 875 876
	mmsg = container_of(msg, struct i2o_msg_mfa, msg);
	memcpy_toio(i2o_msg_in_to_virt(c, mmsg->mfa), msg,
		    (le32_to_cpu(msg->u.head[0]) >> 16) << 2);
	writel(mmsg->mfa, c->in_port);
	mempool_free(mmsg, c->in_msg.mempool);
};
Linus Torvalds's avatar
Linus Torvalds committed
877

878 879 880
/**
 * 	i2o_msg_post_wait - Post and wait a message and wait until return
 *	@c: controller
881
 *	@msg: message to post
882 883 884 885 886 887 888 889 890 891 892 893 894 895
 *	@timeout: time in seconds to wait
 *
 * 	This API allows an OSM to post a message and then be told whether or
 *	not the system received a successful reply. If the message times out
 *	then the value '-ETIMEDOUT' is returned.
 *
 *	Returns 0 on success or negative error code on failure.
 */
static inline int i2o_msg_post_wait(struct i2o_controller *c,
				    struct i2o_message *msg,
				    unsigned long timeout)
{
	return i2o_msg_post_wait_mem(c, msg, timeout, NULL);
};
Linus Torvalds's avatar
Linus Torvalds committed
896

897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
/**
 *	i2o_msg_nop_mfa - Returns a fetched MFA back to the controller
 *	@c: I2O controller from which the MFA was fetched
 *	@mfa: MFA which should be returned
 *
 *	This function must be used for preserved messages, because i2o_msg_nop()
 *	also returns the allocated memory back to the msg_pool mempool.
 */
static inline void i2o_msg_nop_mfa(struct i2o_controller *c, u32 mfa)
{
	struct i2o_message __iomem *msg;
	u32 nop[3] = {
		THREE_WORD_MSG_SIZE | SGL_OFFSET_0,
		I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | ADAPTER_TID,
		0x00000000
	};

	msg = i2o_msg_in_to_virt(c, mfa);
	memcpy_toio(msg, nop, sizeof(nop));
	writel(mfa, c->in_port);
};
Linus Torvalds's avatar
Linus Torvalds committed
918

919 920 921 922 923 924 925 926 927 928 929 930 931 932
/**
 *	i2o_msg_nop - Returns a message which is not used
 *	@c: I2O controller from which the message was created
 *	@msg: message which should be returned
 *
 *	If you fetch a message via i2o_msg_get, and can't use it, you must
 *	return the message with this function. Otherwise the MFA is lost as well
 *	as the allocated memory from the mempool.
 */
static inline void i2o_msg_nop(struct i2o_controller *c,
			       struct i2o_message *msg)
{
	struct i2o_msg_mfa *mmsg;
	mmsg = container_of(msg, struct i2o_msg_mfa, msg);
Linus Torvalds's avatar
Linus Torvalds committed
933

934 935 936
	i2o_msg_nop_mfa(c, mmsg->mfa);
	mempool_free(mmsg, c->in_msg.mempool);
};
Linus Torvalds's avatar
Linus Torvalds committed
937

938 939 940 941 942 943 944 945 946 947 948 949 950
/**
 *	i2o_flush_reply - Flush reply from I2O controller
 *	@c: I2O controller
 *	@m: the message identifier
 *
 *	The I2O controller must be informed that the reply message is not needed
 *	anymore. If you forget to flush the reply, the message frame can't be
 *	used by the controller anymore and is therefore lost.
 */
static inline void i2o_flush_reply(struct i2o_controller *c, u32 m)
{
	writel(m, c->out_port);
};
Linus Torvalds's avatar
Linus Torvalds committed
951

952 953 954 955
/*
 *	Endian handling wrapped into the macro - keeps the core code
 *	cleaner.
 */
Linus Torvalds's avatar
Linus Torvalds committed
956

957
#define i2o_raw_writel(val, mem)	__raw_writel(cpu_to_le32(val), mem)
Linus Torvalds's avatar
Linus Torvalds committed
958

959 960 961
extern int i2o_parm_field_get(struct i2o_device *, int, int, void *, int);
extern int i2o_parm_table_get(struct i2o_device *, int, int, int, void *, int,
			      void *, int);
Linus Torvalds's avatar
Linus Torvalds committed
962

963 964 965
/* debugging and troubleshooting/diagnostic helpers. */
#define osm_printk(level, format, arg...)  \
	printk(level "%s: " format, OSM_NAME , ## arg)
Linus Torvalds's avatar
Linus Torvalds committed
966

967 968 969 970 971 972 973
#ifdef DEBUG
#define osm_debug(format, arg...) \
	osm_printk(KERN_DEBUG, format , ## arg)
#else
#define osm_debug(format, arg...) \
        do { } while (0)
#endif
Linus Torvalds's avatar
Linus Torvalds committed
974

975 976 977 978 979 980
#define osm_err(format, arg...)		\
	osm_printk(KERN_ERR, format , ## arg)
#define osm_info(format, arg...)		\
	osm_printk(KERN_INFO, format , ## arg)
#define osm_warn(format, arg...)		\
	osm_printk(KERN_WARNING, format , ## arg)
Linus Torvalds's avatar
Linus Torvalds committed
981

982 983 984 985 986
/* debugging functions */
extern void i2o_report_status(const char *, const char *, struct i2o_message *);
extern void i2o_dump_message(struct i2o_message *);
extern void i2o_dump_hrt(struct i2o_controller *c);
extern void i2o_debug_state(struct i2o_controller *c);
Linus Torvalds's avatar
Linus Torvalds committed
987 988

#endif				/* _I2O_H */