Root/
1 | /* |
2 | * Function Control Protocol (IEC 61883-1) helper functions |
3 | * |
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> |
5 | * Licensed under the terms of the GNU General Public License, version 2. |
6 | */ |
7 | |
8 | #include <linux/device.h> |
9 | #include <linux/firewire.h> |
10 | #include <linux/firewire-constants.h> |
11 | #include <linux/list.h> |
12 | #include <linux/module.h> |
13 | #include <linux/sched.h> |
14 | #include <linux/spinlock.h> |
15 | #include <linux/wait.h> |
16 | #include <linux/delay.h> |
17 | #include "fcp.h" |
18 | #include "lib.h" |
19 | |
20 | #define CTS_AVC 0x00 |
21 | |
22 | #define ERROR_RETRIES 3 |
23 | #define ERROR_DELAY_MS 5 |
24 | #define FCP_TIMEOUT_MS 125 |
25 | |
26 | static DEFINE_SPINLOCK(transactions_lock); |
27 | static LIST_HEAD(transactions); |
28 | |
29 | enum fcp_state { |
30 | STATE_PENDING, |
31 | STATE_BUS_RESET, |
32 | STATE_COMPLETE, |
33 | }; |
34 | |
35 | struct fcp_transaction { |
36 | struct list_head list; |
37 | struct fw_unit *unit; |
38 | void *response_buffer; |
39 | unsigned int response_size; |
40 | unsigned int response_match_bytes; |
41 | enum fcp_state state; |
42 | wait_queue_head_t wait; |
43 | }; |
44 | |
45 | /** |
46 | * fcp_avc_transaction - send an AV/C command and wait for its response |
47 | * @unit: a unit on the target device |
48 | * @command: a buffer containing the command frame; must be DMA-able |
49 | * @command_size: the size of @command |
50 | * @response: a buffer for the response frame |
51 | * @response_size: the maximum size of @response |
52 | * @response_match_bytes: a bitmap specifying the bytes used to detect the |
53 | * correct response frame |
54 | * |
55 | * This function sends a FCP command frame to the target and waits for the |
56 | * corresponding response frame to be returned. |
57 | * |
58 | * Because it is possible for multiple FCP transactions to be active at the |
59 | * same time, the correct response frame is detected by the value of certain |
60 | * bytes. These bytes must be set in @response before calling this function, |
61 | * and the corresponding bits must be set in @response_match_bytes. |
62 | * |
63 | * @command and @response can point to the same buffer. |
64 | * |
65 | * Asynchronous operation (INTERIM, NOTIFY) is not supported at the moment. |
66 | * |
67 | * Returns the actual size of the response frame, or a negative error code. |
68 | */ |
69 | int fcp_avc_transaction(struct fw_unit *unit, |
70 | const void *command, unsigned int command_size, |
71 | void *response, unsigned int response_size, |
72 | unsigned int response_match_bytes) |
73 | { |
74 | struct fcp_transaction t; |
75 | int tcode, ret, tries = 0; |
76 | |
77 | t.unit = unit; |
78 | t.response_buffer = response; |
79 | t.response_size = response_size; |
80 | t.response_match_bytes = response_match_bytes; |
81 | t.state = STATE_PENDING; |
82 | init_waitqueue_head(&t.wait); |
83 | |
84 | spin_lock_irq(&transactions_lock); |
85 | list_add_tail(&t.list, &transactions); |
86 | spin_unlock_irq(&transactions_lock); |
87 | |
88 | for (;;) { |
89 | tcode = command_size == 4 ? TCODE_WRITE_QUADLET_REQUEST |
90 | : TCODE_WRITE_BLOCK_REQUEST; |
91 | ret = snd_fw_transaction(t.unit, tcode, |
92 | CSR_REGISTER_BASE + CSR_FCP_COMMAND, |
93 | (void *)command, command_size, 0); |
94 | if (ret < 0) |
95 | break; |
96 | |
97 | wait_event_timeout(t.wait, t.state != STATE_PENDING, |
98 | msecs_to_jiffies(FCP_TIMEOUT_MS)); |
99 | |
100 | if (t.state == STATE_COMPLETE) { |
101 | ret = t.response_size; |
102 | break; |
103 | } else if (t.state == STATE_BUS_RESET) { |
104 | msleep(ERROR_DELAY_MS); |
105 | } else if (++tries >= ERROR_RETRIES) { |
106 | dev_err(&t.unit->device, "FCP command timed out\n"); |
107 | ret = -EIO; |
108 | break; |
109 | } |
110 | } |
111 | |
112 | spin_lock_irq(&transactions_lock); |
113 | list_del(&t.list); |
114 | spin_unlock_irq(&transactions_lock); |
115 | |
116 | return ret; |
117 | } |
118 | EXPORT_SYMBOL(fcp_avc_transaction); |
119 | |
120 | /** |
121 | * fcp_bus_reset - inform the target handler about a bus reset |
122 | * @unit: the unit that might be used by fcp_avc_transaction() |
123 | * |
124 | * This function must be called from the driver's .update handler to inform |
125 | * the FCP transaction handler that a bus reset has happened. Any pending FCP |
126 | * transactions are retried. |
127 | */ |
128 | void fcp_bus_reset(struct fw_unit *unit) |
129 | { |
130 | struct fcp_transaction *t; |
131 | |
132 | spin_lock_irq(&transactions_lock); |
133 | list_for_each_entry(t, &transactions, list) { |
134 | if (t->unit == unit && |
135 | t->state == STATE_PENDING) { |
136 | t->state = STATE_BUS_RESET; |
137 | wake_up(&t->wait); |
138 | } |
139 | } |
140 | spin_unlock_irq(&transactions_lock); |
141 | } |
142 | EXPORT_SYMBOL(fcp_bus_reset); |
143 | |
144 | /* checks whether the response matches the masked bytes in response_buffer */ |
145 | static bool is_matching_response(struct fcp_transaction *transaction, |
146 | const void *response, size_t length) |
147 | { |
148 | const u8 *p1, *p2; |
149 | unsigned int mask, i; |
150 | |
151 | p1 = response; |
152 | p2 = transaction->response_buffer; |
153 | mask = transaction->response_match_bytes; |
154 | |
155 | for (i = 0; ; ++i) { |
156 | if ((mask & 1) && p1[i] != p2[i]) |
157 | return false; |
158 | mask >>= 1; |
159 | if (!mask) |
160 | return true; |
161 | if (--length == 0) |
162 | return false; |
163 | } |
164 | } |
165 | |
166 | static void fcp_response(struct fw_card *card, struct fw_request *request, |
167 | int tcode, int destination, int source, |
168 | int generation, unsigned long long offset, |
169 | void *data, size_t length, void *callback_data) |
170 | { |
171 | struct fcp_transaction *t; |
172 | unsigned long flags; |
173 | |
174 | if (length < 1 || (*(const u8 *)data & 0xf0) != CTS_AVC) |
175 | return; |
176 | |
177 | spin_lock_irqsave(&transactions_lock, flags); |
178 | list_for_each_entry(t, &transactions, list) { |
179 | struct fw_device *device = fw_parent_device(t->unit); |
180 | if (device->card != card || |
181 | device->generation != generation) |
182 | continue; |
183 | smp_rmb(); /* node_id vs. generation */ |
184 | if (device->node_id != source) |
185 | continue; |
186 | |
187 | if (t->state == STATE_PENDING && |
188 | is_matching_response(t, data, length)) { |
189 | t->state = STATE_COMPLETE; |
190 | t->response_size = min((unsigned int)length, |
191 | t->response_size); |
192 | memcpy(t->response_buffer, data, t->response_size); |
193 | wake_up(&t->wait); |
194 | } |
195 | } |
196 | spin_unlock_irqrestore(&transactions_lock, flags); |
197 | } |
198 | |
199 | static struct fw_address_handler response_register_handler = { |
200 | .length = 0x200, |
201 | .address_callback = fcp_response, |
202 | }; |
203 | |
204 | static int __init fcp_module_init(void) |
205 | { |
206 | static const struct fw_address_region response_register_region = { |
207 | .start = CSR_REGISTER_BASE + CSR_FCP_RESPONSE, |
208 | .end = CSR_REGISTER_BASE + CSR_FCP_END, |
209 | }; |
210 | |
211 | fw_core_add_address_handler(&response_register_handler, |
212 | &response_register_region); |
213 | |
214 | return 0; |
215 | } |
216 | |
217 | static void __exit fcp_module_exit(void) |
218 | { |
219 | WARN_ON(!list_empty(&transactions)); |
220 | fw_core_remove_address_handler(&response_register_handler); |
221 | } |
222 | |
223 | module_init(fcp_module_init); |
224 | module_exit(fcp_module_exit); |
225 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9