Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | #ifndef IEEE1394_HIGHLEVEL_H | |
3 | #define IEEE1394_HIGHLEVEL_H | |
4 | ||
5 | ||
6 | struct hpsb_address_serve { | |
7 | struct list_head host_list; /* per host list */ | |
8 | ||
9 | struct list_head hl_list; /* hpsb_highlevel list */ | |
10 | ||
11 | struct hpsb_address_ops *op; | |
12 | ||
13 | struct hpsb_host *host; | |
14 | ||
15 | /* first address handled and first address behind, quadlet aligned */ | |
16 | u64 start, end; | |
17 | }; | |
18 | ||
19 | ||
20 | /* | |
21 | * The above structs are internal to highlevel driver handling. Only the | |
22 | * following structures are of interest to actual highlevel drivers. | |
23 | */ | |
24 | ||
25 | struct hpsb_highlevel { | |
26 | struct module *owner; | |
27 | const char *name; | |
28 | ||
29 | /* Any of the following pointers can legally be NULL, except for | |
30 | * iso_receive which can only be NULL when you don't request | |
31 | * channels. */ | |
32 | ||
33 | /* New host initialized. Will also be called during | |
34 | * hpsb_register_highlevel for all hosts already installed. */ | |
35 | void (*add_host) (struct hpsb_host *host); | |
36 | ||
37 | /* Host about to be removed. Will also be called during | |
38 | * hpsb_unregister_highlevel once for each host. */ | |
39 | void (*remove_host) (struct hpsb_host *host); | |
40 | ||
41 | /* Host experienced bus reset with possible configuration changes. | |
42 | * Note that this one may occur during interrupt/bottom half handling. | |
43 | * You can not expect to be able to do stock hpsb_reads. */ | |
44 | void (*host_reset) (struct hpsb_host *host); | |
45 | ||
46 | /* An isochronous packet was received. Channel contains the channel | |
47 | * number for your convenience, it is also contained in the included | |
48 | * packet header (first quadlet, CRCs are missing). You may get called | |
49 | * for channel/host combinations you did not request. */ | |
50 | void (*iso_receive) (struct hpsb_host *host, int channel, | |
51 | quadlet_t *data, size_t length); | |
52 | ||
53 | /* A write request was received on either the FCP_COMMAND (direction = | |
54 | * 0) or the FCP_RESPONSE (direction = 1) register. The cts arg | |
55 | * contains the cts field (first byte of data). */ | |
56 | void (*fcp_request) (struct hpsb_host *host, int nodeid, int direction, | |
57 | int cts, u8 *data, size_t length); | |
58 | ||
59 | /* These are initialized by the subsystem when the | |
60 | * hpsb_higlevel is registered. */ | |
61 | struct list_head hl_list; | |
62 | struct list_head irq_list; | |
63 | struct list_head addr_list; | |
64 | ||
65 | struct list_head host_info_list; | |
66 | rwlock_t host_info_lock; | |
67 | }; | |
68 | ||
69 | struct hpsb_address_ops { | |
70 | /* | |
71 | * Null function pointers will make the respective operation complete | |
72 | * with RCODE_TYPE_ERROR. Makes for easy to implement read-only | |
73 | * registers (just leave everything but read NULL). | |
74 | * | |
75 | * All functions shall return appropriate IEEE 1394 rcodes. | |
76 | */ | |
77 | ||
78 | /* These functions have to implement block reads for themselves. */ | |
79 | /* These functions either return a response code | |
80 | or a negative number. In the first case a response will be generated; in the | |
81 | later case, no response will be sent and the driver, that handled the request | |
82 | will send the response itself | |
83 | */ | |
84 | int (*read) (struct hpsb_host *host, int nodeid, quadlet_t *buffer, | |
85 | u64 addr, size_t length, u16 flags); | |
86 | int (*write) (struct hpsb_host *host, int nodeid, int destid, | |
87 | quadlet_t *data, u64 addr, size_t length, u16 flags); | |
88 | ||
89 | /* Lock transactions: write results of ext_tcode operation into | |
90 | * *store. */ | |
91 | int (*lock) (struct hpsb_host *host, int nodeid, quadlet_t *store, | |
92 | u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags); | |
93 | int (*lock64) (struct hpsb_host *host, int nodeid, octlet_t *store, | |
94 | u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags); | |
95 | }; | |
96 | ||
97 | ||
98 | void highlevel_add_host(struct hpsb_host *host); | |
99 | void highlevel_remove_host(struct hpsb_host *host); | |
100 | void highlevel_host_reset(struct hpsb_host *host); | |
101 | ||
102 | ||
103 | /* these functions are called to handle transactions. They are called, when | |
104 | a packet arrives. The flags argument contains the second word of the first header | |
105 | quadlet of the incoming packet (containing transaction label, retry code, | |
106 | transaction code and priority). These functions either return a response code | |
107 | or a negative number. In the first case a response will be generated; in the | |
108 | later case, no response will be sent and the driver, that handled the request | |
109 | will send the response itself. | |
110 | */ | |
111 | int highlevel_read(struct hpsb_host *host, int nodeid, void *data, | |
112 | u64 addr, unsigned int length, u16 flags); | |
113 | int highlevel_write(struct hpsb_host *host, int nodeid, int destid, | |
114 | void *data, u64 addr, unsigned int length, u16 flags); | |
115 | int highlevel_lock(struct hpsb_host *host, int nodeid, quadlet_t *store, | |
116 | u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags); | |
117 | int highlevel_lock64(struct hpsb_host *host, int nodeid, octlet_t *store, | |
118 | u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags); | |
119 | ||
120 | void highlevel_iso_receive(struct hpsb_host *host, void *data, | |
121 | size_t length); | |
122 | void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction, | |
123 | void *data, size_t length); | |
124 | ||
125 | ||
126 | /* | |
127 | * Register highlevel driver. The name pointer has to stay valid at all times | |
128 | * because the string is not copied. | |
129 | */ | |
130 | void hpsb_register_highlevel(struct hpsb_highlevel *hl); | |
131 | void hpsb_unregister_highlevel(struct hpsb_highlevel *hl); | |
132 | ||
133 | /* | |
134 | * Register handlers for host address spaces. Start and end are 48 bit pointers | |
135 | * and have to be quadlet aligned (end points to the first address behind the | |
136 | * handled addresses. This function can be called multiple times for a single | |
137 | * hpsb_highlevel to implement sparse register sets. The requested region must | |
138 | * not overlap any previously allocated region, otherwise registering will fail. | |
139 | * | |
140 | * It returns true for successful allocation. There is no unregister function, | |
141 | * all address spaces are deallocated together with the hpsb_highlevel. | |
142 | */ | |
143 | u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl, | |
144 | struct hpsb_host *host, | |
145 | struct hpsb_address_ops *ops, | |
146 | u64 size, u64 alignment, | |
147 | u64 start, u64 end); | |
148 | int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host, | |
149 | struct hpsb_address_ops *ops, u64 start, u64 end); | |
150 | ||
151 | int hpsb_unregister_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host, | |
152 | u64 start); | |
153 | ||
154 | /* | |
155 | * Enable or disable receving a certain isochronous channel through the | |
156 | * iso_receive op. | |
157 | */ | |
158 | int hpsb_listen_channel(struct hpsb_highlevel *hl, struct hpsb_host *host, | |
159 | unsigned int channel); | |
160 | void hpsb_unlisten_channel(struct hpsb_highlevel *hl, struct hpsb_host *host, | |
161 | unsigned int channel); | |
162 | ||
163 | ||
164 | /* Retrieve a hostinfo pointer bound to this driver/host */ | |
165 | void *hpsb_get_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host); | |
166 | ||
167 | /* Allocate a hostinfo pointer of data_size bound to this driver/host */ | |
168 | void *hpsb_create_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host, | |
169 | size_t data_size); | |
170 | ||
171 | /* Free and remove the hostinfo pointer bound to this driver/host */ | |
172 | void hpsb_destroy_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host); | |
173 | ||
174 | /* Set an alternate lookup key for the hostinfo bound to this driver/host */ | |
175 | void hpsb_set_hostinfo_key(struct hpsb_highlevel *hl, struct hpsb_host *host, unsigned long key); | |
176 | ||
177 | /* Retrieve the alternate lookup key for the hostinfo bound to this driver/host */ | |
178 | unsigned long hpsb_get_hostinfo_key(struct hpsb_highlevel *hl, struct hpsb_host *host); | |
179 | ||
180 | /* Retrieve a hostinfo pointer bound to this driver using its alternate key */ | |
181 | void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel *hl, unsigned long key); | |
182 | ||
183 | /* Set the hostinfo pointer to something useful. Usually follows a call to | |
184 | * hpsb_create_hostinfo, where the size is 0. */ | |
185 | int hpsb_set_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host, void *data); | |
186 | ||
187 | /* Retrieve hpsb_host using a highlevel handle and a key */ | |
188 | struct hpsb_host *hpsb_get_host_bykey(struct hpsb_highlevel *hl, unsigned long key); | |
189 | ||
190 | #endif /* IEEE1394_HIGHLEVEL_H */ |