rio.h 16.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
 * RapidIO interconnect services
 * (RapidIO Interconnect Specification, http://www.rapidio.org)
 *
 * Copyright 2005 MontaVista Software, Inc.
 * Matt Porter <mporter@kernel.crashing.org>
 *
 * 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.
 */

#ifndef LINUX_RIO_H
#define LINUX_RIO_H

#include <linux/types.h>
#include <linux/ioport.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/device.h>
#include <linux/rio_regs.h>
23
#include <linux/mod_devicetable.h>
24
25
26
#ifdef CONFIG_RAPIDIO_DMA_ENGINE
#include <linux/dmaengine.h>
#endif
27
28

#define RIO_NO_HOPCOUNT		-1
29
#define RIO_INVALID_DESTID	0xffff
30

31
#define RIO_MAX_MPORTS		8
32
33
#define RIO_MAX_MPORT_RESOURCES	16
#define RIO_MAX_DEV_RESOURCES	16
34
#define RIO_MAX_MPORT_NAME	40
35
36
37
38
39
40
41
42
43
44

#define RIO_GLOBAL_TABLE	0xff	/* Indicates access of a switch's
					   global routing table if it
					   has multiple (or per port)
					   tables */

#define RIO_INVALID_ROUTE	0xff	/* Indicates that a route table
					   entry is invalid (no route
					   exists for the device ID) */

45
46
#define RIO_MAX_ROUTE_ENTRIES(size)	(size ? (1 << 16) : (1 << 8))
#define RIO_ANY_DESTID(size)		(size ? 0xffff : 0xff)
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#define RIO_MAX_MBOX		4
#define RIO_MAX_MSG_SIZE	0x1000

/*
 * Error values that may be returned by RIO functions.
 */
#define RIO_SUCCESSFUL			0x00
#define RIO_BAD_SIZE			0x81

/*
 * For RIO devices, the region numbers are assigned this way:
 *
 *	0	RapidIO outbound doorbells
 *      1-15	RapidIO memory regions
 *
 * For RIO master ports, the region number are assigned this way:
 *
 *	0	RapidIO inbound doorbells
 *	1	RapidIO inbound mailboxes
Chad Reese's avatar
Chad Reese committed
67
 *	2	RapidIO outbound mailboxes
68
69
70
71
72
 */
#define RIO_DOORBELL_RESOURCE	0
#define RIO_INB_MBOX_RESOURCE	1
#define RIO_OUTB_MBOX_RESOURCE	2

73
74
#define RIO_PW_MSG_SIZE		64

75
76
77
78
79
80
81
82
83
84
/*
 * A component tag value (stored in the component tag CSR) is used as device's
 * unique identifier assigned during enumeration. Besides being used for
 * identifying switches (which do not have device ID register), it also is used
 * by error management notification and therefore has to be assigned
 * to endpoints as well.
 */
#define RIO_CTAG_RESRVD	0xfffe0000 /* Reserved */
#define RIO_CTAG_UDEVID	0x0001ffff /* Unique device identifier */

85
extern struct bus_type rio_bus_type;
86
extern struct device rio_bus;
87
88

struct rio_mport;
89
struct rio_dev;
90
union rio_pw_msg;
91

92
93
94
95
96
/**
 * struct rio_switch - RIO switch info
 * @node: Node in global list of switches
 * @route_table: Copy of switch routing table
 * @port_ok: Status of each port (one bit per port) - OK=1 or UNINIT=0
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 * @ops: pointer to switch-specific operations
 * @lock: lock to serialize operations updates
 * @nextdev: Array of per-port pointers to the next attached device
 */
struct rio_switch {
	struct list_head node;
	u8 *route_table;
	u32 port_ok;
	struct rio_switch_ops *ops;
	spinlock_t lock;
	struct rio_dev *nextdev[0];
};

/**
 * struct rio_switch_ops - Per-switch operations
 * @owner: The module owner of this structure
113
114
115
116
117
118
119
 * @add_entry: Callback for switch-specific route add function
 * @get_entry: Callback for switch-specific route get function
 * @clr_table: Callback for switch-specific clear route table function
 * @set_domain: Callback for switch-specific domain setting function
 * @get_domain: Callback for switch-specific domain get function
 * @em_init: Callback for switch-specific error management init function
 * @em_handle: Callback for switch-specific error management handler function
120
121
122
 *
 * Defines the operations that are necessary to initialize/control
 * a particular RIO switch device.
123
 */
124
125
struct rio_switch_ops {
	struct module *owner;
126
127
128
129
130
131
132
133
134
135
136
137
138
139
	int (*add_entry) (struct rio_mport *mport, u16 destid, u8 hopcount,
			  u16 table, u16 route_destid, u8 route_port);
	int (*get_entry) (struct rio_mport *mport, u16 destid, u8 hopcount,
			  u16 table, u16 route_destid, u8 *route_port);
	int (*clr_table) (struct rio_mport *mport, u16 destid, u8 hopcount,
			  u16 table);
	int (*set_domain) (struct rio_mport *mport, u16 destid, u8 hopcount,
			   u8 sw_domain);
	int (*get_domain) (struct rio_mport *mport, u16 destid, u8 hopcount,
			   u8 *sw_domain);
	int (*em_init) (struct rio_dev *dev);
	int (*em_handle) (struct rio_dev *dev, u8 swport);
};

140
141
142
143
144
/**
 * struct rio_dev - RIO device info
 * @global_list: Node in list of all RIO devices
 * @net_list: Node in list of RIO devices in a network
 * @net: Network this device is a part of
145
 * @do_enum: Enumeration flag
146
147
148
149
150
151
152
153
154
155
156
 * @did: Device ID
 * @vid: Vendor ID
 * @device_rev: Device revision
 * @asm_did: Assembly device ID
 * @asm_vid: Assembly vendor ID
 * @asm_rev: Assembly revision
 * @efptr: Extended feature pointer
 * @pef: Processing element features
 * @swpinfo: Switch port info
 * @src_ops: Source operation capabilities
 * @dst_ops: Destination operation capabilities
157
158
159
 * @comp_tag: RIO component tag
 * @phys_efptr: RIO device extended features pointer
 * @em_efptr: RIO Error Management features pointer
Matt Porter's avatar
Matt Porter committed
160
 * @dma_mask: Mask of bits of RIO address this device implements
161
162
163
 * @driver: Driver claiming this device
 * @dev: Device model device
 * @riores: RIO resources this device owns
164
 * @pwcback: port-write callback function for this device
165
166
 * @destid: Network destination ID (or associated destid for switch)
 * @hopcount: Hopcount to this device
167
 * @prev: Previous RIO device connected to the current one
168
 * @rswitch: struct rio_switch (if valid for this device)
169
170
171
172
173
 */
struct rio_dev {
	struct list_head global_list;	/* node in list of all RIO devices */
	struct list_head net_list;	/* node in per net list */
	struct rio_net *net;	/* RIO net this device resides in */
174
	bool do_enum;
175
176
177
178
179
180
181
182
	u16 did;
	u16 vid;
	u32 device_rev;
	u16 asm_did;
	u16 asm_vid;
	u16 asm_rev;
	u16 efptr;
	u32 pef;
183
	u32 swpinfo;
184
185
	u32 src_ops;
	u32 dst_ops;
186
187
188
	u32 comp_tag;
	u32 phys_efptr;
	u32 em_efptr;
Matt Porter's avatar
Matt Porter committed
189
	u64 dma_mask;
190
191
192
	struct rio_driver *driver;	/* RIO driver claiming this device */
	struct device dev;	/* LDM device structure */
	struct resource riores[RIO_MAX_DEV_RESOURCES];
193
	int (*pwcback) (struct rio_dev *rdev, union rio_pw_msg *msg, int step);
194
	u16 destid;
195
	u8 hopcount;
196
	struct rio_dev *prev;
197
	struct rio_switch rswitch[0];	/* RIO switch info */
198
199
200
201
202
};

#define rio_dev_g(n) list_entry(n, struct rio_dev, global_list)
#define rio_dev_f(n) list_entry(n, struct rio_dev, net_list)
#define	to_rio_dev(n) container_of(n, struct rio_dev, dev)
203
#define sw_to_rio_dev(n) container_of(n, struct rio_dev, rswitch[0])
204
205
206
207
208
209
210
211

/**
 * struct rio_msg - RIO message event
 * @res: Mailbox resource
 * @mcback: Message event callback
 */
struct rio_msg {
	struct resource *res;
212
	void (*mcback) (struct rio_mport * mport, void *dev_id, int mbox, int slot);
213
214
215
216
217
218
219
};

/**
 * struct rio_dbell - RIO doorbell event
 * @node: Node in list of doorbell events
 * @res: Doorbell resource
 * @dinb: Doorbell event callback
220
 * @dev_id: Device specific pointer to pass on event
221
222
223
224
 */
struct rio_dbell {
	struct list_head node;
	struct resource *res;
225
226
	void (*dinb) (struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info);
	void *dev_id;
227
228
};

229
230
231
232
233
enum rio_phy_type {
	RIO_PHY_PARALLEL,
	RIO_PHY_SERIAL,
};

234
235
236
237
238
239
240
241
242
243
244
245
246
/**
 * struct rio_mport - RIO master port info
 * @dbells: List of doorbell events
 * @node: Node in global list of master ports
 * @nnode: Node in network list of master ports
 * @iores: I/O mem resource that this master port interface owns
 * @riores: RIO resources that this master port interfaces owns
 * @inb_msg: RIO inbound message event descriptors
 * @outb_msg: RIO outbound message event descriptors
 * @host_deviceid: Host device ID associated with this master port
 * @ops: configuration space functions
 * @id: Port ID, unique among all ports
 * @index: Port index, unique among all port interfaces of the same type
247
248
 * @sys_size: RapidIO common transport system size
 * @phy_type: RapidIO phy type
249
 * @phys_efptr: RIO port extended features pointer
250
 * @name: Port name string
251
 * @priv: Master port private data
252
 * @dma: DMA device associated with mport
253
 * @nscan: RapidIO network enumeration/discovery operations
254
255
256
257
258
259
260
261
262
263
 */
struct rio_mport {
	struct list_head dbells;	/* list of doorbell events */
	struct list_head node;	/* node in global list of ports */
	struct list_head nnode;	/* node in net list of ports */
	struct resource iores;
	struct resource riores[RIO_MAX_MPORT_RESOURCES];
	struct rio_msg inb_msg[RIO_MAX_MBOX];
	struct rio_msg outb_msg[RIO_MAX_MBOX];
	int host_deviceid;	/* Host device ID */
264
	struct rio_ops *ops;	/* low-level architecture-dependent routines */
265
266
267
	unsigned char id;	/* port ID, unique among all ports */
	unsigned char index;	/* port index, unique among all port
				   interfaces of the same type */
268
269
270
271
	unsigned int sys_size;	/* RapidIO common transport system size.
				 * 0 - Small size. 256 devices.
				 * 1 - Large size, 65536 devices.
				 */
272
	enum rio_phy_type phy_type;	/* RapidIO phy type */
273
	u32 phys_efptr;
274
	unsigned char name[RIO_MAX_MPORT_NAME];
275
	void *priv;		/* Master port private data */
276
277
278
#ifdef CONFIG_RAPIDIO_DMA_ENGINE
	struct dma_device	dma;
#endif
279
	struct rio_scan *nscan;
280
281
};

282
283
284
285
286
/*
 * Enumeration/discovery control flags
 */
#define RIO_SCAN_ENUM_NO_WAIT	0x00000001 /* Do not wait for enum completed */

287
288
289
290
291
292
293
struct rio_id_table {
	u16 start;	/* logical minimal id */
	u32 max;	/* max number of IDs in table */
	spinlock_t lock;
	unsigned long *table;
};

294
295
296
297
/**
 * struct rio_net - RIO network info
 * @node: Node in global list of RIO networks
 * @devices: List of devices in this network
298
 * @switches: List of switches in this netowrk
299
300
301
 * @mports: List of master ports accessing this network
 * @hport: Default port for accessing this network
 * @id: RIO network ID
302
 * @destid_table: destID allocation table
303
304
305
306
 */
struct rio_net {
	struct list_head node;	/* node in list of networks */
	struct list_head devices;	/* list of devices in this net */
307
	struct list_head switches;	/* list of switches in this net */
308
309
310
	struct list_head mports;	/* list of ports accessing net */
	struct rio_mport *hport;	/* primary port for accessing net */
	unsigned char id;	/* RIO network ID */
311
	struct rio_id_table destid_table;  /* destID allocation table */
312
313
314
315
316
317
318
319
320
321
322
};

/* Low-level architecture-dependent routines */

/**
 * struct rio_ops - Low-level RIO configuration space operations
 * @lcread: Callback to perform local (master port) read of config space.
 * @lcwrite: Callback to perform local (master port) write of config space.
 * @cread: Callback to perform network read of config space.
 * @cwrite: Callback to perform network write of config space.
 * @dsend: Callback to send a doorbell message.
323
 * @pwenable: Callback to enable/disable port-write message handling.
324
325
326
327
328
329
330
 * @open_outb_mbox: Callback to initialize outbound mailbox.
 * @close_outb_mbox: Callback to shut down outbound mailbox.
 * @open_inb_mbox: Callback to initialize inbound mailbox.
 * @close_inb_mbox: Callback to	shut down inbound mailbox.
 * @add_outb_message: Callback to add a message to an outbound mailbox queue.
 * @add_inb_buffer: Callback to	add a buffer to an inbound mailbox queue.
 * @get_inb_message: Callback to get a message from an inbound mailbox queue.
331
332
 * @map_inb: Callback to map RapidIO address region into local memory space.
 * @unmap_inb: Callback to unmap RapidIO address region mapped with map_inb().
333
334
 */
struct rio_ops {
335
336
337
338
339
340
341
342
343
	int (*lcread) (struct rio_mport *mport, int index, u32 offset, int len,
			u32 *data);
	int (*lcwrite) (struct rio_mport *mport, int index, u32 offset, int len,
			u32 data);
	int (*cread) (struct rio_mport *mport, int index, u16 destid,
			u8 hopcount, u32 offset, int len, u32 *data);
	int (*cwrite) (struct rio_mport *mport, int index, u16 destid,
			u8 hopcount, u32 offset, int len, u32 data);
	int (*dsend) (struct rio_mport *mport, int index, u16 destid, u16 data);
344
	int (*pwenable) (struct rio_mport *mport, int enable);
345
346
347
348
349
350
351
352
353
354
	int (*open_outb_mbox)(struct rio_mport *mport, void *dev_id,
			      int mbox, int entries);
	void (*close_outb_mbox)(struct rio_mport *mport, int mbox);
	int  (*open_inb_mbox)(struct rio_mport *mport, void *dev_id,
			     int mbox, int entries);
	void (*close_inb_mbox)(struct rio_mport *mport, int mbox);
	int  (*add_outb_message)(struct rio_mport *mport, struct rio_dev *rdev,
				 int mbox, void *buffer, size_t len);
	int (*add_inb_buffer)(struct rio_mport *mport, int mbox, void *buf);
	void *(*get_inb_message)(struct rio_mport *mport, int mbox);
355
356
357
	int (*map_inb)(struct rio_mport *mport, dma_addr_t lstart,
			u64 rstart, u32 size, u32 flags);
	void (*unmap_inb)(struct rio_mport *mport, dma_addr_t lstart);
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
};

#define RIO_RESOURCE_MEM	0x00000100
#define RIO_RESOURCE_DOORBELL	0x00000200
#define RIO_RESOURCE_MAILBOX	0x00000400

#define RIO_RESOURCE_CACHEABLE	0x00010000
#define RIO_RESOURCE_PCI	0x00020000

#define RIO_RESOURCE_BUSY	0x80000000

/**
 * struct rio_driver - RIO driver info
 * @node: Node in list of drivers
 * @name: RIO driver name
 * @id_table: RIO device ids to be associated with this driver
 * @probe: RIO device inserted
 * @remove: RIO device removed
 * @suspend: RIO device suspended
 * @resume: RIO device awakened
 * @enable_wake: RIO device enable wake event
 * @driver: LDM driver struct
 *
 * Provides info on a RIO device driver for insertion/removal and
 * power management purposes.
 */
struct rio_driver {
	struct list_head node;
	char *name;
	const struct rio_device_id *id_table;
	int (*probe) (struct rio_dev * dev, const struct rio_device_id * id);
	void (*remove) (struct rio_dev * dev);
	int (*suspend) (struct rio_dev * dev, u32 state);
	int (*resume) (struct rio_dev * dev);
	int (*enable_wake) (struct rio_dev * dev, u32 state, int enable);
	struct device_driver driver;
};

#define	to_rio_driver(drv) container_of(drv,struct rio_driver, driver)

398
399
400
401
402
403
404
405
406
407
408
union rio_pw_msg {
	struct {
		u32 comptag;	/* Component Tag CSR */
		u32 errdetect;	/* Port N Error Detect CSR */
		u32 is_port;	/* Implementation specific + PortID */
		u32 ltlerrdet;	/* LTL Error Detect CSR */
		u32 padding[12];
	} em;
	u32 raw[RIO_PW_MSG_SIZE/sizeof(u32)];
};

409
410
#ifdef CONFIG_RAPIDIO_DMA_ENGINE

411
/*
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 * enum rio_write_type - RIO write transaction types used in DMA transfers
 *
 * Note: RapidIO specification defines write (NWRITE) and
 * write-with-response (NWRITE_R) data transfer operations.
 * Existing DMA controllers that service RapidIO may use one of these operations
 * for entire data transfer or their combination with only the last data packet
 * requires response.
 */
enum rio_write_type {
	RDW_DEFAULT,		/* default method used by DMA driver */
	RDW_ALL_NWRITE,		/* all packets use NWRITE */
	RDW_ALL_NWRITE_R,	/* all packets use NWRITE_R */
	RDW_LAST_NWRITE_R,	/* last packet uses NWRITE_R, others - NWRITE */
};

struct rio_dma_ext {
	u16 destid;
	u64 rio_addr;	/* low 64-bits of 66-bit RapidIO address */
	u8  rio_addr_u;  /* upper 2-bits of 66-bit RapidIO address */
	enum rio_write_type wr_type; /* preferred RIO write operation type */
};

struct rio_dma_data {
	/* Local data (as scatterlist) */
	struct scatterlist	*sg;	/* I/O scatter list */
	unsigned int		sg_len;	/* size of scatter list */
	/* Remote device address (flat buffer) */
	u64 rio_addr;	/* low 64-bits of 66-bit RapidIO address */
	u8  rio_addr_u;  /* upper 2-bits of 66-bit RapidIO address */
	enum rio_write_type wr_type; /* preferred RIO write operation type */
};

static inline struct rio_mport *dma_to_mport(struct dma_device *ddev)
{
	return container_of(ddev, struct rio_mport, dma);
}
#endif /* CONFIG_RAPIDIO_DMA_ENGINE */

450
451
/**
 * struct rio_scan - RIO enumeration and discovery operations
452
 * @owner: The module owner of this structure
453
454
455
456
 * @enumerate: Callback to perform RapidIO fabric enumeration.
 * @discover: Callback to perform RapidIO fabric discovery.
 */
struct rio_scan {
457
	struct module *owner;
458
459
	int (*enumerate)(struct rio_mport *mport, u32 flags);
	int (*discover)(struct rio_mport *mport, u32 flags);
460
461
};

462
463
464
465
466
467
468
469
470
471
472
473
474
/**
 * struct rio_scan_node - list node to register RapidIO enumeration and
 * discovery methods with RapidIO core.
 * @mport_id: ID of an mport (net) serviced by this enumerator
 * @node: node in global list of registered enumerators
 * @ops: RIO enumeration and discovery operations
 */
struct rio_scan_node {
	int mport_id;
	struct list_head node;
	struct rio_scan *ops;
};

475
/* Architecture and hardware-specific functions */
476
extern int rio_register_mport(struct rio_mport *);
477
extern int rio_open_inb_mbox(struct rio_mport *, void *, int, int);
478
extern void rio_close_inb_mbox(struct rio_mport *, int);
479
extern int rio_open_outb_mbox(struct rio_mport *, void *, int, int);
480
481
482
extern void rio_close_outb_mbox(struct rio_mport *, int);

#endif				/* LINUX_RIO_H */